.NET 测试驱动开发(TDD)之封装数据库以便Mock测试

在测试驱动开发中，对数据库特别是ORM的测试，有的时候不好做，这里介绍我们的做法。

本文的方案是基于Entity Framework 4.0 Code First, Autofac的。

Entity Framework 4.0 Code First对测试驱动的支持

由于Entity Framework 4.0 Code First可以从业务层的简单C#对象（POCO）反向生成数据库以及数据库相应的表，如果数据简单的话，那么就直接实行TDD模式：

1、 首先创建测试用例，这里我们以一个客户关系管理系统为例讲解，用例是测试保存客户资料的功能：

    [TestMethod]
    public void 测试保存客户资料功能()
    {
        using (var rep = new CrmContext())
        {
            var customer = Customer.New<Customer>();
            customer.Name = "上海知平";
            rep.Customers.Add(customer);

            rep.SaveChanges();
        }
    }

2、 补充几个必要的类型：

public class Customer : ISecret, INamedTable
{
    public Guid Id { get; set; }

    public int Permission
    {
        get;
        set;
    }

    public string Name
    {
        get;
        set;
    }

    public static T New<T>() where T : Customer, new()
    {
        var ret = new T()
        {
            Id = Guid.NewGuid()
        };

        return ret;
    }
}

public class CrmContext : DbContext
{
    public CrmContext() { }

    public CrmContext(string nameOrConnectionString)

        : base(nameOrConnectionString)
    {
    }

    public DbSet<Customer> Customers { get; set; }
}

其中Customer是OR映射过的类型，用以在数据库和业务层之间加载和保存客户资料；而CrmContext就可以理解成数据库，里面有一个表Customers，当然这个是经过Entity Framework做OR映射后的结果。

3、 在测试工程的app.config文件里，添加CrmContext的链接字符串：

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <connectionStrings>
    <add name="Vowei.Data.VoweiContextImpl" connectionString="Data Source=.\SQLEXPRESS;Integrated Security=SSPI;Database=TaskConnect1" providerName="System.Data.SqlClient" />
  </connectionStrings>
</configuration>

4、 这个时候运行测试用例就可以看到数据库已经自动生成了，而且也可以看到数据已经插入。

在EF的基础上再封装一层

从上文中可以看到，EF对测试驱动的支持已经很好了，但为什么还需要再封装一层呢？主要是出于两个目的：

1、 有些数据表，比如跟别的数据有比较复杂的联系，代码在设计时，一时半会不好确定对数据的建模是否合理，API设计是否流畅，因此为了保险起见，先在内存里模拟一个数据库，确定API设计合理之后，再将数据之间的关系通过EF映射到数据库上。

2、 将业务层和数据层的细节分离开来，比如业务层可能在后续版本使用RESTful API获取数据。

下面是我们再封装的过程。

1、 首先将CrmContext的属性和方法提成一个接口：

public interface IContext : IDisposable
{
    IRepository<Customer> Customers { get; }

    int SaveChanges();
}

因为需要完全和EF分离出来，需要把CrmContext里的DbSet<Customer>类型的Customers属性也分离出一个接口。

/// <summary>
/// 代表数据库中的一个表
/// </summary>
/// <typeparam name="T">OR映射里的类型</typeparam>
public interface IRepository<T> where T : class
{
    /// <summary>
    /// 获取数据表的名称(在数据库中对应的表)
    /// </summary>
    string Name { get; }

    /// <summary>
    /// 返回一个组合后的IQueryable查询
    /// </summary>
    IQueryable<T> Query { get; }

    /// <summary>
    /// 添加外键查询
    /// </summary>
    /// <param name="navigationProperty">OR映射中对象的外键属性</param>
    /// <returns>返回对象本身,以达到IRepository.Include("Property1").Include("Property2").Query的效果</returns>
    IRepository<T> Include(string navigationProperty);

    /// <summary>
    /// 往数据层中添加一个新的对象
    /// </summary>
    /// <param name="item">新对象</param>
    void Add(T item);

    /// <summary>
    /// 在数据层中删除一个对象
    /// </summary>
    /// <param name="item">要删除的对象</param>
    void Remove(T item);

    /// <summary>
    /// 用于更新操作时，将尚未和数据库关联的对象关联
    /// </summary>
    /// <param name="entity">尚未和数据库关联的对象</param>
    /// <returns>一个已经和数据库关联的对象</returns>
    T Attach(T entity);

    IQueryable<T> SqlQuery(string sql, params object[] parameters);

    /// <summary>
    /// 获取所属的数据库
    /// </summary>
    IContext Context { get; }
}

2、 实现接口IContext，并且将具体的实现隐藏。

public class CrmContext : IContext
{
    private CrmContextImpl _contextImpl;

    internal CrmContextImpl Impl { get { return _contextImpl; } }

    static CrmContext()
    {
        Database.SetInitializer(new CrmContextInitializer());
    }

    public CrmContext() :
        this(new CrmContextImpl())
    {
    }

    public CrmContext(string nameOrConnectionString)
        : this(new CrmContextImpl(nameOrConnectionString))
    {
    }

    public IRepository<Customer> Customers
    {
        get;
        private set;
    }

    public int SaveChanges()
    {
        return _contextImpl.SaveChanges();
    }

    public void Dispose()
    {
        if (_contextImpl != null)
        {
            _contextImpl.Dispose();
            _contextImpl = null;
        }
    }
}

3、 为了避免对每个数据表都重复实现IRepository这个接口，做了一个通用的接口实现类型，通过反射将IContext的数据表属性和具体实现的数据表属性关联起来。

internal class RepositoryImpl<T, U> : IRepository<U>
    where T : class
    where U : class, T
{
    // 被封装的数据表实现方式
    private DbSet<U> _table;
    // 保存上一次类似Where等Lambda调用保存的表达式树
    private IQueryable<U> _query;
    // 保存新数据的回调函数
    private Func<T, U> _persistRouing;
    private string _tableName;
    private VoweiContext _context;

    // 这个变量仅仅是用来在实现继承类型，避免编译器混乱用的
    public IRepository<T> IfImplementation { get; private set; }

    private RepositoryImpl(IQueryable<U> query, Func<T, U> persistRouing, string tableName)
    {
        _query = query;
        _persistRouing = persistRouing;
        _tableName = tableName;
    }

    public RepositoryImpl(VoweiContext context, Func<T, U> persistRouing, string tableName)
    {
        var property = typeof(VoweiContextImpl).GetProperty(tableName);
        // 通过反射的机制，根据“tableName”参数给出的属性名，获取实现IContext某个数据表的具体对象引用
        // 并保存到类型变量里，以便将所有的查询、Include、增删改等操作传递给这个对象。
        _table = (DbSet<U>)property.GetValue(context._contextImpl, new object[] { });
        _query = _table;
        _persistRouing = persistRouing;
        _tableName = tableName;
        _context = context;

        // 如果类型T和U不是同一个类型，说明要么U继承与T，或者U实现了T这个接口
        // 这样一来，为了规避编译器编译错误，需要再封一层
        if (typeof(T) != typeof(U))
            IfImplementation = new RepositoryIfImpl(this, tableName);
        else // 否则就很简单了
            IfImplementation = (IRepository<T>)this;
    }

    public RepositoryImpl(VoweiContext context)
        : this(context, null, typeof(U).Name)
    {
    }

    /// <summary>
    /// 获取该Repository对应的数据库里的表名
    /// </summary>
    public string Name { get { return _tableName; } }

    public IContext Context { get { return _context; } }

    public IQueryable<U> Query
    {
        get
        {
            if (_query == null)
                return _table;
            else
                return _query;
        }
    }

    public IRepository<U> Include(string navigationProperty)
    {
        if (_query == null)
            return new RepositoryImpl<T, U>(_table.Include(navigationProperty), _persistRouing, _tableName);
        else
            return new RepositoryImpl<T, U>(_query.Include(navigationProperty), _persistRouing, _tableName) { _table = _table };
    }

    public IQueryable<U> SqlQuery(string sql, params object[] parameters)
    {
        return _table.SqlQuery(sql, parameters).AsQueryable<U>();
    }

    public virtual void Add(U item)
    {
        _table.Add(item);
    }

    public virtual void Remove(U item)
    {
        _table.Remove(item);
    }

    public U Attach(U entity)
    {
        return _table.Attach(entity);
    }

    class RepositoryIfImpl : IRepository<T>
    {
        private RepositoryImpl<T, U> _outer;
        private IQueryable<U> _tmpQuery;
        private string _tableName;

        public RepositoryIfImpl(RepositoryImpl<T, U> outer, string tableName)
        {
            _outer = outer;
            _tableName = tableName;
        }

        public string Name { get { return _tableName; } }

        public IContext Context { get { return _outer._context; } }

        public IQueryable<T> Query
        {
            get
            {
                if (_tmpQuery == null)
                    return _outer._table;
                else
                    return _tmpQuery;
            }
        }

        public IQueryable<T> SqlQuery(string sql, params object[] parameters)
        {
            return _outer._table.SqlQuery(sql, parameters).AsQueryable<U>();
        }

        public IRepository<T> Include(string navigationProperty)
        {
            var result = new RepositoryIfImpl(_outer, _tableName);
            result._tmpQuery = _tmpQuery == null ? _outer._table.Include(navigationProperty)
                                                 : _tmpQuery.Include(navigationProperty);

            return result;
        }

        public virtual void Add(T item)
        {
            if (_outer._persistRouing == null)
                throw new InvalidOperationException("当需要从基类T的对象实例生成一个派生类型U的实例时，需要指明转换的方式！");
            _outer._table.Add(_outer._persistRouing(item));
        }

        public virtual void Remove(T item)
        {
            _outer._table.Remove((U)item);
        }

        public T Attach(T entity)
        {
            return _outer.Attach((U)entity);
        }
    }
}

从上面的代码里可以看到，RepositoryImpl和RepositoryIfImpl两个类是内部类，而且是CrmContext的内部类，避免了被系统其他代码调用到的机会。

4、 因为IRepository这个接口是一个通用接口，所以需要一个机制映射IContext的数据表属性和CrmContextImpl的数据表属性，下面两个函数就是用来做映射的。

    // 如果封装的类型和数据库里的其他类型没有继承关系，则使用这个函数执行映射
    private IRepository<T> RegisterTable<T>(string tableName)
    where T : class
    {
        var result = new RepositoryImpl<T, T>(this, null, tableName);
        _tableMap.Add(typeof(T), result);
        return result;
    }

    // 如果封装的类型和数据库里的其他类型有继承关系，则使用这个函数执行映射，
    // 需要指定类型和类型的基类
    private IRepository<T> RegisterDeliveredTable<T, U>(Func<T, U> persistRouting, string tableName)
        where T : class
        where U : class, T
    {
        var result = new RepositoryImpl<T, U>(this, persistRouting, tableName);
        _tableMap.Add(typeof(T), result.IfImplementation);
        _tableMap.Add(typeof(U), result);
        return result.IfImplementation;
    }

5、 通用的接口实现封装好了以后，加一个新的数据表就是一个注册的过程，这个过程在构造函数里就做了。

    internal VoweiContext(VoweiContextImpl impl)
    {
        _contextImpl = impl;
        Customers = RegisterTable<Customer>("Customers");
    }

6、 再在测试用例或者程序启动合适的地方，通过Ioc机制将数据库接口IContext和实现接口的对象注册一番就可以用了。

var builder = new ContainerBuilder();
builder.RegisterType<CrmContext>().AsImplementedInterfaces();
IocHelper.Container = builder.Build();

7、 最后用的时候很简单，本文开头的例子就改成使用Ioc的方式从容器里获取一个接口实现：

    [TestMethod]
    public void 测试保存客户资料功能()
    {
        using (var rep = IocHelper.Container.Resolve<IContext>())
        {
            var customer = Customer.New<Customer>();
            customer.Name = "上海知平";
            rep.Customers.Add(customer);
            rep.SaveChanges();
        }
    }

本文由知平软件 施懿民编写，请关注我们的微博。