3

今天我想开始对一个小的 asp.net MVC 3 Web（测试）应用程序进行单元测试，以学习一些新东西。

但事情比我预想的还要糟糕……

我现在已经阅读了一些关于与实体框架相关的单元测试的线程，现在我首先想为我的实体框架相关类实现接口，以便我可以为我的单元测试实现一个内存中的“数据库”。

我的代码库来自ASP.NET MVC 教程。我读过MSDN，但在我的情况下它对我没有帮助。

我想向您展示我的代码。我正在使用带有存储库的工作单元模式：

工作单位：

public class SqlUnitOfWork : IUnitOfWork, IDisposable
{
    private SqlContext context = new SqlContext();
    private IGenericRepository<Message> messageRepository;
    private IGenericRepository<Receipt> receiptRepository;
    private IGenericRepository<Useraccount> useraccountRepository;
    private bool disposed = false;

    public IGenericRepository<Message> MessageRepository
    {
        get
        {
            if (this.messageRepository == null)
            {
                this.messageRepository = new SqlGenericRepository<Message>(context);
            }
            return messageRepository;
        }
    }

    public IGenericRepository<Receipt> ReceiptRepository
    {
        get
        {
            if (this.receiptRepository == null)
            {
                this.receiptRepository = new SqlGenericRepository<Receipt>(context);
            }
            return receiptRepository;
        }
    }

    public IGenericRepository<Useraccount> UseraccountRepository
    {
        get
        {
            if (this.useraccountRepository == null)
            {
                this.useraccountRepository = new SqlGenericRepository<Useraccount>(context);
            }
            return useraccountRepository;
        }
    }

    public SqlUnitOfWork()
    {
    }

    ~SqlUnitOfWork()
    {
    }

    public virtual void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if (disposing)
            {
                context.Dispose();
            }
        }

        this.disposed = true;
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    public void Save()
    {
        context.SaveChanges();
    }
}

这个实现了我创建的接口。

我的 sql 通用存储库：

public class SqlGenericRepository<TEntity> : IGenericRepository<TEntity> where TEntity : class
{
    internal SqlContext context;
    internal DbSet<TEntity> dbSet;

    public SqlGenericRepository(SqlContext context)
    {
        this.context = context;
        this.dbSet = context.Set<TEntity>();
    }

    ~SqlGenericRepository()
    {
    }

    public virtual IEnumerable<TEntity> Get(Expression<Func<TEntity, bool>> filter = null, 
        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null, string includeProperties = "")
    {
        IQueryable<TEntity> query = dbSet;

        if (filter != null)
        {
            query = query.Where(filter);
        }

        foreach (var includeProperty in includeProperties.Split
            (new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
        {
            query = query.Include(includeProperty);
        }

        if (orderBy != null)
        {
            return orderBy(query).ToList();
        }
        else
        {
            return query.ToList();
        }
    }

    public virtual TEntity GetByID(object id)
    {
        return dbSet.Find(id);
    }

    public virtual void Insert(TEntity entity)
    {
        dbSet.Add(entity);
    }


    public virtual void Delete(object id)
    {
        TEntity entityToDelete = dbSet.Find(id);
        Delete(entityToDelete);
    }

    public virtual void Delete(TEntity entityToDelete)
    {
        if (context.Entry(entityToDelete).State == EntityState.Detached)
        {
            dbSet.Attach(entityToDelete);
        }
        dbSet.Remove(entityToDelete);
    }

    public virtual void Update(TEntity entityToUpdate)
    {
        dbSet.Attach(entityToUpdate);
        context.Entry(entityToUpdate).State = EntityState.Modified;
    }
}

它实现了我编写的接口：

public interface IGenericRepository<TEntity> where TEntity : class
{
    IEnumerable<TEntity> Get(Expression<Func<TEntity, bool>> filter = null, Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null, string includeProperties = "");

    TEntity GetByID(object id);

    void Insert(TEntity entity);

    void Delete(object id);

    void Delete(TEntity entityToDelete);

    void Update(TEntity entityToUpdate);
}

我现在想为我的单元测试实现一个“InMemoryGenericRepository”，然后是一个“InMemoryUnitOfWork”。那些“InMemoryGenericRepository”会是什么样子？

我想我会在存储所有数据的存储库中使用通用列表：

IEnumerable<TEntity> List { get; set; }

但是我怎样才能适应这种方法：

public virtual IEnumerable<TEntity> Get(Expression<Func<TEntity, bool>> filter = null, Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null, string includeProperties = "")
{
    IQueryable<TEntity> query = dbSet;

    if (filter != null)
    {
        query = query.Where(filter);
    }

    foreach (var includeProperty in includeProperties.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
    {
        query = query.Include(includeProperty);
    }

    if (orderBy != null)
    {
        return orderBy(query).ToList();
    }
    else
    {
        return query.ToList();
    }
}

所以它适用于我的

IEnumerable<TEntity> List { get; set; }

我希望你能做到我的问题结束。

4

3 回答 3

1

如果您的课程是 POCO，那么它们看起来像这样：

namespace Project.Model // auto-generated Foo.cs
{
    public partial class Foo // notice partiality
    {
    }
}

然后你写这个：

namespace Project.Model // custom Foo.cs in another folder
{
    public partial class Foo : IEntity // notice interface
    {
    }
}
于 2013-02-17T21:58:21.670 回答
0

你也可以重写你的惰性属性：

private IGenericRepository<Message> messageRepository;

public IGenericRepository<Message> MessageRepository
{
    get
    {
        return messageRepository ?? (messageRepository = new IGenericRepository<Message>());
    }
}

或者

private Lazy<IGenericRepository<Message>> messageRepository = new Lazy<IGenericRepository<Message>>(new IGenericRepository<Message>()));

public IGenericRepository<Message> MessageRepository
{
    get
    {
        return messageRepository.Value;
    }
}
于 2013-02-17T22:04:12.103 回答
0

通用存储库模式不是一个好的模式。为了换取存储独立性（你可能不需要它。你喜欢拥有它但你并不真正需要它），它会让你付出很多痛苦。由于以下几个原因，您真的很难编写可查询的内存存储库：

  • 实体具有必须正确设置的关系
  • 内存中查询的行为与 SQL 查询不同（例如，它们区分大小写）
  • 内存中查询没有优化器，这会导致测试运行时间过长
  • 基本上，您现在必须测试测试，因此您可以确定不存在行为差异

此外，通过抽象出您的 ORM，您可以不使用它的任何功能。您只能使用最通用和一般的功能。

几年前我就这样做了，痛苦还没有结束。我发现使用真正的 SQL 数据库进行测试是一种很好的模式。这样你就不需要任何存储库并且可以测试真实的东西。这有它的问题，但它是可行的。

这个问题的解决方案是放弃通用存储库模式。

于 2013-02-17T23:27:40.720 回答