模拟 DbSet<T> 内联。

Question

我正在使用.NET4.5，EF6和Moq进行单元测试。我试图模拟一些数据库数据以进行测试。我有一个示例，如何通过声明mockset作为变量然后使用mocks来实现这一点。

public static class TestExtensionMethods
{
       public static DbSet<T> AsDbSet<T>(this List<T> sourceList) where T : class
       {
           var queryable = sourceList.AsQueryable();

           var dbSet = new Mock<DbSet<T>>();
           dbSet.As<IQueryable<T>>().Setup(m => m.Provider).Returns(queryable.Provider);
           dbSet.As<IQueryable<T>>().Setup(m => m.Expression).Returns(queryable.Expression);
           dbSet.As<IQueryable<T>>().Setup(m => m.ElementType).Returns(queryable.ElementType);
           dbSet.As<IQueryable<T>>().Setup(m => m.GetEnumerator()).Returns(queryable.GetEnumerator());
           dbSet.Setup(d => d.Add(It.IsAny<T>())).Callback<T>(sourceList.Add);
           return dbSet.Object;
       }
}

我正在将它用作扩展方法，例如：mockedDbContext.Journey = new List<Journey> { }.AsDbSet(); 是否有一种方法可以将其声明为单行代码（这样我就可以将db集合作为TestCaseData传递，而无需编写扩展方法）。我尝试了以下方法。

var mockedDbContext = new Mock<OnlineLegal>();
mockedDbContext.Setup(o => o.Journey).Returns(() => (DbSet<Journey>)(new List<Journey> { new Journey { SessionId = sessionId, ConveyancingAnswer = new Collection<ConveyancingAnswer>()} }.AsEnumerable()));

但它会出现错误：System.InvalidCastException : 无法将类型为 'System.Collections.Generic.List1[Saga.Services.Legal.Website.Journey]' 的对象强制转换为类型 'System.Data.Entity.DbSet1[Saga.Services.Legal.Website.Journey]'。

如何内联模拟 DbSet<T>？

编辑：关于重复，标记我的问题的人没有花费精力阅读比标题更多的内容，他们今年会从圣诞老人那里得到沙林毒气。

- Matas Vaitkevicius

---

尝试一下这个：http://www.loganfranken.com/blog/517/mocking-dbset-queries-in-ef6/ - Vadim Martynov

@VadimMartynov 你好，谢谢提供链接，请问在文章中他们声明了内联db set的位置吗？ - Matas Vaitkevicius

另一种方法 - 不要模拟DBContext ;) - Fabio

Answer 1

使用你定义的方法，在这种情况下从一个列表中创建一个DbSet，其中T是类型Journey，并假设o.Journey是类型为DbSet<Journey>。

private DbSet<T> ToDbSet<T>(List<T> sourceList) where T : class
{
    var queryable = sourceList.AsQueryable();

    var dbSet = new Mock<DbSet<T>>();
    dbSet.As<IQueryable<T>>().Setup(m => m.Provider).Returns(queryable.Provider);
    dbSet.As<IQueryable<T>>().Setup(m => m.Expression).Returns(queryable.Expression);
    dbSet.As<IQueryable<T>>().Setup(m => m.ElementType).Returns(queryable.ElementType);
    dbSet.As<IQueryable<T>>().Setup(m => m.GetEnumerator()).Returns(queryable.GetEnumerator());
    dbSet.Setup(d => d.Add(It.IsAny<T>())).Callback<T>(sourceList.Add);
    return dbSet.Object;
}

private void SomeOtherMethod() 
{
    var journey = new Journey 
    { 
        SessionId = sessionId, 
        ConveyancingAnswer = new Collection<ConveyancingAnswer>()
    };
    var journeys = new List<Journey> { journey };  
    mockedDbContext.Setup(o => o.Journey)
                   .Returns(() => ToDbSet<Journey>(journeys));
}

如果你想把这个放在一行上，那是可能的，但从可读性的角度来看并不一定是理想的。

- silleknarf

---

嗨，silleknarf，谢谢你的回复。在你的答案中，我可以找到DbSet是如何在不使用扩展方法的情况下被内联声明的？ - Matas Vaitkevicius

TestExtensionMethods.AsDbSet<Journey>(journeys) 返回一个 DbSet。 - silleknarf

我已经在我的答案中删除了扩展方法的使用。 - silleknarf

sillknarf，我非常感谢你的努力，绝不想打击你的积极性，但是你的回答只是我的问题的重复，并进行了一些转换。我正在寻找的是如何在不编写其他机制的情况下动态声明DbSet，例如声明列表然后以某种方式进行转换，可以简单地使用new List<T>().Select(o => new DbSet(o))或类似的东西，但DbSet构造函数是内部的，所以问题相当复杂，可能根本没有办法做到。还是感谢你的尝试。 - Matas Vaitkevicius

Answer 2

昨天我花了几个小时研究这个主题。@silleknarf的答案是正确的，但不完整。异步方法会抛出异常。昨天我在网上搜寻了答案，并找到了这个扩展方法作为解决方案。它适用于dotnet 3.1。由于接口的一些变化，以前的版本可能需要不同的实现。希望对你们中的一些人有用。 :)

public static class DbSet
{
    public static DbSet<T> ToDbSet<T>(this List<T> sourceList) where T : class
    {
        var queryable = sourceList.AsQueryable();
        var dbSet = new Mock<DbSet<T>>();

        dbSet.As<IAsyncEnumerable<T>>()
             .Setup(m => m.GetAsyncEnumerator(It.IsAny<CancellationToken>()))
             .Returns(new MockAsyncEnumerator<T>(queryable.GetEnumerator()));

        dbSet.As<IQueryable<T>>()
            .Setup(m => m.Provider)
            .Returns(new MockAsyncQueryProvider<T>(queryable.Provider));

        dbSet.As<IQueryable<T>>().Setup(m => m.Expression).Returns(queryable.Expression);
        dbSet.As<IQueryable<T>>().Setup(m => m.ElementType).Returns(queryable.ElementType);
        dbSet.As<IQueryable<T>>().Setup(m => m.GetEnumerator()).Returns(queryable.GetEnumerator());
        dbSet.Setup(d => d.Add(It.IsAny<T>())).Callback<T>(sourceList.Add);
        return dbSet.Object;
    }
    private class MockAsyncQueryProvider<TEntity> : IAsyncQueryProvider
    {
        private readonly IQueryProvider _inner;

        internal MockAsyncQueryProvider(IQueryProvider inner)
        {
            _inner = inner;
        }

        public IQueryable CreateQuery(Expression expression)
        {
            return new MockAsyncEnumerable<TEntity>(expression);
        }

        public IQueryable<TElement> CreateQuery<TElement>(Expression expression)
        {
            return new MockAsyncEnumerable<TElement>(expression);
        }

        public object Execute(Expression expression)
        {
            return _inner.Execute(expression);
        }

        public TResult Execute<TResult>(Expression expression)
        {
            return _inner.Execute<TResult>(expression);
        }

        public TResult ExecuteAsync<TResult>(Expression expression, CancellationToken cancellationToken = default)
        {
            var expectedResultType = typeof(TResult).GetGenericArguments()[0];
            var executionResult = typeof(IQueryProvider)
                     .GetMethod(name: nameof(IQueryProvider.Execute), genericParameterCount: 1, types: new[] { typeof(Expression) })
                     .MakeGenericMethod(expectedResultType)
                     .Invoke(this, new[] {expression});

            return (TResult)typeof(Task)
                .GetMethod(nameof(Task.FromResult))
                ?.MakeGenericMethod(expectedResultType)
                .Invoke(null, new[] { executionResult });
        }
    }
    private class MockAsyncEnumerable<T> : EnumerableQuery<T>, IAsyncEnumerable<T>, IQueryable<T>
    {
        IQueryProvider IQueryable.Provider => new MockAsyncQueryProvider<T>(this);

        public MockAsyncEnumerable(IEnumerable<T> enumerable) : base(enumerable) { } 
        public MockAsyncEnumerable(Expression expression) : base(expression) { } 

        public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default)
        {
            return new MockAsyncEnumerator<T>(this.AsEnumerable().GetEnumerator());
        }
    }
    private class MockAsyncEnumerator<T> : IAsyncEnumerator<T>
    {
        private readonly IEnumerator<T> _inner;

        public T Current => _inner.Current;

        public MockAsyncEnumerator(IEnumerator<T> inner)
        {
            _inner = inner;
        }

        public ValueTask<bool> MoveNextAsync()
        {
            return new ValueTask<bool>(_inner.MoveNext());
        }
        public ValueTask DisposeAsync()
        {
            _inner.Dispose();

            return new ValueTask();
        }
    }
}

- Nieksa