基于Entity Framework 4.1实现一个适用于单元测试的MockDbContext(下)

上篇中提到，我们在利用修改做的MockDbContext进行单元测试时，在获取数据时出现了问题。原因在于，在写获取的代码时，我们直接调用了DbContext的Set<T>()方法，而这个方法会从数据库中取数据。

我们来看一个例子：

这是一个简化的业务逻辑代码来获取全部的Handbook：

        public IList<Handbook> GetMyHandbooks()
        {
            var handbookSet = dbContext.Set<Handbook>();
            return handbookSet.ToList();
        }

对应的单元测试：

        [TestMethod]
        public void GetMyHandBooksTest()
        {
            var mockDbContext = new MockMTBContainer();
            BizHandbook target = new BizHandbook(mockDbContext);

            mockDbContext.Handbooks1.Add(new Handbook() { HandbookID = 1 });
            mockDbContext.Handbooks1.Add(new Handbook() { HandbookID = 2 });

            var result = target.GetMyHandbooks();
            Assert.IsNotNull(result);
            Assert.AreEqual(2, result.Count);
        }

行4-5创建一个业务逻辑对象，也是我们的测试目标target，第5行中的构造函数以以mockDbContext为参数，此业务逻辑对象会使用mockDbContext而非默认的DbContext。第10行代码调用了GetMyHandbooks()方法。第11行和12行分别验能够获得结果并且结果集中有两个对象。大家已经知道使用上篇中的mockDbContext，这个单元测试会Fail。第12行Assert预期为2，实际为0。

直接问题出在GetMyHandbooks方法的return语句中的.ToList()方法。这是一个System.Linq中提供的扩展方法，它所做的事情是：调用Expression对象进行数据查询得到一个IEnumerator<TEntity>，然后创建一个List<TEntity>对象，进行迭代将数据填入列表，最后返回。谁提供了Expression？DbContext中的DbSet<TEntity>。

 

在上篇中，我们仅仅是简单的重写了（或者说，废掉了^_^）DbContext的SaveChanges()，但是在查询数据的时候，Expression仍然会从对应的DB中获取数据。另外，对Local属性的理解也有问题，Local里并不是所有数据，但是新增或变更过的数据。于是，单元测试12行出现actual＝0的现象也就得到合理解释了。看来，之前的想法太过简单了。需要重新构思一个mockDbContext。

由于DbSet<TEntity>的Expression属性不是virtual属性，简单重写一下Expression的想法行不通。曾经想过用一个同名属性覆盖它，但是，这样应该也有问题（之所以说应该，是因为没有试过），因为DbContext中使用的都是DbSet<TEntity>类，会调用原来的Expression属性的。

 

通过以上的分析，我们知道，要让MockDbContext好用，涉及两个类：DbContext和DbSet<TEntity>，因此，现在的思路是，实现两个新的类，替换掉它们。

由于要在业务逻辑不作任何修改的情况下调用DbContext和MockDbContext，这两个类要求实现同一接口；

同理，DbSet<TEntity>和新写的类（叫MockDbSet<TEntity>吧）同样也要实现同一个接口。

我们从MockDbSet<TEntity>着手。由于DbSet<TEntity>实现了IDbSet<TEntity>接口，因此，对于MockDbSet<TEntity>来说，实现IDbSet<TEntity>即可（这个类方法比较多，但都是非常基本的方法，文章最后有下载）：

    public class MockDbSet<TEntity> : IDbSet<TEntity>
        where TEntity : class
    {
        private ObservableCollection<TEntity> storage = new ObservableCollection<TEntity>();


        public TEntity Add(TEntity entity)
        {
            if (entity != null)
            {
                storage.Add(entity);
            }
            return entity;
        }

        public TEntity Attach(TEntity entity)
        {
            storage.Add(entity);
            return entity;
        }

        public TDerivedEntity Create<TDerivedEntity>() where TDerivedEntity : class, TEntity
        {
            return Activator.CreateInstance<TDerivedEntity>();
        }

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

        public TEntity Find(params object[] keyValues)
        {
            int currentKeyPropertyIndex;
            foreach (var entity in storage)
            {
                currentKeyPropertyIndex = 0;
                foreach (var property in typeof(TEntity).GetProperties())
                {
                    if (property.Name.Contains("ID"))
                    {
                        if (property.GetValue(entity).Equals(keyValues[currentKeyPropertyIndex]))
                        {
                            currentKeyPropertyIndex++;
                            if (currentKeyPropertyIndex == keyValues.Length)
                            {
                                return entity;
                            }
                        }
                    }
                }
            }
            return null;
        }

        public System.Collections.ObjectModel.ObservableCollection<TEntity> Local
        {
            get { return new ObservableCollection<TEntity>(this.storage); }
        }

        public TEntity Remove(TEntity entity)
        {
            storage.Remove(entity);
            return entity;
        }

        public IEnumerator<TEntity> GetEnumerator()
        {
            return this.storage.GetEnumerator();
        }

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

        public Type ElementType
        {
            get
            {
                return storage.AsQueryable().ElementType;
            }
        }

        public System.Linq.Expressions.Expression Expression
        {
            get
            {
                return storage.AsQueryable().Expression;
            }
        }

        public IQueryProvider Provider
        {
            get
            {
                return storage.AsQueryable().Provider;
            }
        }
    }

延续前文思路，在第4行添加了一个ObservableCollection<T>的集合，用作本地存储；增、删、改全部针对这个集合来完成。第85到91行，在返回Expression的时候，把storage.AsQueryable()的表达式返回出去，这样，查询的的时候就会获取到查询storage中元素的表达式。

接下来，我们要把使用DbSet<TEntity>的DbContext和使用MockDbSet<TEntity>的MockDbContext统一起来。查看一下DbContext……呃~没有实现任何接口-.-||（曾经有位伟人说过……算了，不说了）既然没有接口，我们就来创建一个：

using System.Data.Entity;

namespace MTB.Data
{
    public interface ITestableDbContext
    {
        IDbSet<TEntity> Set<TEntity>() where TEntity : class;
        int SaveChanges();
    }
}

这个接口做两件事，第一，可以实现数据持久化——SaveChanges()。第二，可以获取到IDbSet<TEntity>集合以对集合中数据进行操作。然后，做两件事：第一，让具体的DbContext实现这个接口；第二，写一个MockDbContext实现这个接口。
我们先来看DbContext实现接口的部分：

    public partial class MTBContainer : DbContext, ITestableDbContext
    {
        public MTBContainer()
            : base("name=MTBContainer")
        {
        }

        public new IDbSet<TEntity> Set<TEntity>() where TEntity : class
        {
            return base.Set<TEntity>();
        }

        //... Other code...

        public IDbSet<Handbook> Handbooks1 { get; set; }
        public IDbSet<Trip> Trips { get; set; }
        // ... more item
    }

其中，第8到11行，虽然覆盖了Set<TEntity>()，但调用的仍然是DbContext类中的Set<TEntity>()方法；然后把对应的DbSet<TEntity对象集合全部改为IDbSet<TEntity>，大功告成。由于用的是Model First的EF4.1，因此，其实这个类是通过修改模板而来的。修改过的模板会在文章结束时附上。

MockDbContext实现：

    public partial class MockMTBContainer : DbContext, ITestableDbContext
    {
        public MockMTBContainer()
            : base("name=MTBContainer")
        {
            Handbooks1 = new MockDbSet<Handbook>();
            Trips = new MockDbSet<Trip>();
                   // Other code
        }

        public new IDbSet<TEntity> Set<TEntity>() where TEntity : class
        {
                foreach (PropertyInfo property in typeof(MockMTBContainer).GetProperties())
                {
                    if (property.PropertyType == typeof(IDbSet<TEntity>))
                    {
                        return property.GetValue(this, null) as IDbSet<TEntity>;
                    }
                }
                throw new Exception("Type collection not found");
        }

        public override int SaveChanges()
        {
            //Do nothing
            return 0;
        }

        // ...

        public IDbSet<Handbook> Handbooks1 { get; set; }
        public IDbSet<Trip> Trips { get; set; }
        // ...
    }

这个MockDbContext同样继承自DbContext类（嗯，可以少写不少代码呢）。但是，覆盖了Set<TEntity>()方法；当然，第29到33行废掉SaveChanges()的事仍然不可不做——如果想让测试更全面一些，看看那些个增、删、改方法有没有忘调用SaveChanges()，利用这个重写设置一个标志为也不错啊

 

Okay，一切就绪，我们把这一切综合起来使用：

首先，业务逻辑：

    public class BizHandbook
    {
        ITestableDbContext dbContext = null;

        #region Constructions
        public BizHandbook()
            : this(null)
        {
        }


        public BizHandbook(ITestableDbContext dbContextl)
        {
            if (dbContext == null)
            {
                dbContext = new MTBContainer();
            }
            this.dbContext = dbContext;
        }
        #endregion

        #region Publich Methods
        public IList<Handbook> GetMyHandbooks()
        {
            var handbookSet = dbContext.Set<Handbook>();
            return handbookSet.ToList();
        }
        #endregion
    }

测试：

……跟本而第二个代码片段一样，没有变化！（其实，MockDbContext变了）。

 

Okay，小结时间：

我们创建了一个接口ITestableDbContext，并且写了一个MockDbContext类，来实现对调用EF4.1的业务逻辑代码的单元测试（红的部分）：

模板下载，使用的时候记得修改对应的using和inputFile变量——点击下载。

内容：

1. 使用IDbSet<T>的DbContext的模板；

2. MockDbContext模板；

3. MockDbSet<TEntity>类；

4. ITestableDbContext接口；

对了，顺便提一下，在MockDbSet<TEntity>实现的时候，Find()方法为了方便起见，使用了一个Hack的方法来判断属性是否为Key属性——属性名称中是否含有ID。