DbSetMock

DbSetMock.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data.Entity;
using System.Linq;
using System.Linq.Expressions;

namespace Billing.Tests.Models
{
    public class DbSetMock<T> : DbSet<T>, IQueryable, IEnumerable<T>
        where T : class
    {
        ObservableCollection<T> _data;
        IQueryable _query;

        public DbSetMock()
        {
            _data = new ObservableCollection<T>();
            _query = _data.AsQueryable();
        }

        public override T Add(T item)
        {
            _data.Add(item);
            return item;
        }

        public override T Remove(T item)
        {
            _data.Remove(item);
            return item;
        }

        public override T Attach(T item)
        {
            _data.Add(item);
            return item;
        }

        public override T Create()
        {
            return Activator.CreateInstance<T>();
        }

        public override TDerivedEntity Create<TDerivedEntity>()
        {
            return Activator.CreateInstance<TDerivedEntity>();
        }

        public override ObservableCollection<T> Local
        {
            get { return new ObservableCollection<T>(_data); }
        }

        Type IQueryable.ElementType
        {
            get { return _query.ElementType; }
        }

        System.Linq.Expressions.Expression IQueryable.Expression
        {
            get { return _query.Expression; }
        }

        IQueryProvider IQueryable.Provider
        {
            get { return _query.Provider; }
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return _data.GetEnumerator();
        }

        IEnumerator<T> IEnumerable<T>.GetEnumerator()
        {
            return _data.GetEnumerator();
        }

        public override T Find(params object[] keyValues)
        {
            return this.SingleOrDefault(this.BuildFindPredicate<T>(keyValues));
        }

        public Func<T, bool> BuildFindPredicate<T>(params object[] keyValues)
        {
            String entityName = String.Format("{0}", typeof(T).Name);

            String primaryKeyName = String.Format("{0}Id", entityName);

            var exp = String.Format("{0}.{1} == {2}", entityName, primaryKeyName, keyValues.SingleOrDefault());

            var p = Expression.Parameter(typeof(T), entityName);

            var e = System.Linq.Dynamic.DynamicExpression.ParseLambda(new[] { p }, null, exp);

            return (Func<T, bool>)e.Compile();
        }
    }
}

Ficou muito maneiro mesmo o BuildFindPredicate.