使用xunit、Shouldy、NSubstitute 测试E

作者: 诸葛_小亮 | 来源:发表于2017-04-16 17:20 被阅读406次

前言

此篇文章只针对ef6.0的特性和API,较早的版本，可能有部分或全部信息不适用。

参考

Entity Framework Testing with a Mocking Framework

NSubstitute完全手册索引

源代码

模拟对象的创建

有两种不同的方法可以用来创建一个内存中的上下文

1.创建自定义模拟对象

创建自定义模拟对象,需要编写自己的上下文和DbSets内存中的实现。
这样我们就可以控制很对的类行为以及编写合理数量的代码。

2.适用Mocking框架创建模拟对象

使用模拟框架(如NSubstitute)你可以有内存的实现上下文和集在运行时动态创建

这篇文章主要主要是讲述如何使用模拟框架。关于如何创建自定义模拟对象，可参阅:Testing with Your Own Test Doubles (EF6 onwards)

为了使用 EF 的 mocking 框架，我们将使用 NSubstitute。

测试更早版本

本文中显示的方案取决于我们对EF6中的DbSet所做的一些更改。
对于使用EF5和更早版本的测试，请参阅使用Fake Context进行测试。

局限性

内存模拟测试是提供使用EF的应用程序单元测试级别覆盖率的好方法。但是，在执行操作时，您正在使用的Linq to Obejcts来对内存中的数据执行查询。这可能导致与使用EF的Linq提供程序(linq to entities )将查询转换为针对数据库运行的sql 不同的行为。
比如，在加载相关数据方面。如果您创建了一系列具有相关帖子的博客，那么在使用内存中的数据时，相关帖子将始终被每个博客加载。但是，当对数据库运行时，只有使用Include方法时，才会加载数据。
因此，建议始终包括一些级别的端对端测试(除了单元测试)，以确保应用程序对数据库正常工作。

使用准备

本文提供了完整的代码清单，您可以将其复制到Visual Stuio中使用。
需要使用 .Net Framework4.5
1.创建单元测试项目
2.使用nuget添加一下包

Nuget.png

EF模型

我们要测试的服务使用由BloggingContext和Blog和Post类组成的EF模型。此代码可能是由EF Designer生成的，或者是Code First模型。

using System.Collections.Generic;
using System.Data.Entity;

namespace TestingDemo
{
    public class BloggingContext : DbContext
    {
        public virtual DbSet<Blog> Blogs { get; set; }
        public virtual DbSet<Post> Posts { get; set; }
    }

    public class Blog 
    { 
        public int BlogId { get; set; } 
        public string Name { get; set; } 
        public string Url { get; set; } 
 
        public virtual List<Post> Posts { get; set; } 
    } 
 
    public class Post 
    { 
        public int PostId { get; set; } 
        public string Title { get; set; } 
        public string Content { get; set; } 
 
        public int BlogId { get; set; } 
        public virtual Blog Blog { get; set; } 
    } 
}

在上下文使用 virtual 标识 DbSet属性

上下文中的DbSet 属性标记为虚拟，这将允许模拟框架从我们自己的上下中导出，并使用模拟实现来覆盖这些属性。

测试服务

为了展示使用内存测试模拟对象，我们将为BlogService 编写几个测试。该服务能工创建新的博客（AddBlog）并返回所有按名次（GetAllBlogs）排序的博客。
除了GetAllBlogs之外，我们还提供了一种方法，它将异步地获取按名称(GetAllBlogsAsync)排序的所有博客。


using System.Collections.Generic; 
using System.Data.Entity; 
using System.Linq; 
using System.Threading.Tasks; 
 
namespace TestingDemo 
{ 
    public class BlogService 
    { 
        private BloggingContext _context; 
 
        public BlogService(BloggingContext context) 
        { 
            _context = context; 
        } 
 
        public Blog AddBlog(string name, string url) 
        { 
            var blog = _context.Blogs.Add(new Blog { Name = name, Url = url }); 
            _context.SaveChanges(); 
 
            return blog; 
        } 
 
        public List<Blog> GetAllBlogs() 
        { 
            var query = from b in _context.Blogs 
                        orderby b.Name 
                        select b; 
 
            return query.ToList(); 
        } 
 
        public async Task<List<Blog>> GetAllBlogsAsync() 
        { 
            var query = from b in _context.Blogs 
                        orderby b.Name 
                        select b; 
 
            return await query.ToListAsync(); 
        } 
    } 
}

测试非查询

测试非查询方案测试非查询方案

这就是我们需要做的，以开始测试非查询方法。以下测试使用Moq创建上下文。然后创建一个DbSet <Blog>并将其连接起来，从上下文的“博客”属性返回。接下来，上下文用于创建一个新的BlogService，然后用它来创建一个新的博客 - 使用AddBlog方法。最后，测试验证该服务在上下文中添加了一个新的Blog并调用SaveChanges。


using Microsoft.VisualStudio.TestTools.UnitTesting; 
using Moq; 
using System.Data.Entity; 
 
namespace TestingDemo 
{ 
    public class NonQueryTests
    {
        [Fact]
        public void CreateBlog_saves_a_blog_via_context()
        {
            var mockSet = Substitute.For<DbSet<Blog>>();
            var mockContext = Substitute.For<BloggingContext>();
            mockContext.Blogs.Returns(mockSet);

            var addBolg = new Blog(); // 用来验证add 方法 传入的参数使用为预期内容
            mockSet.Add(Arg.Do<Blog>(x => addBolg = x)); 

            var service = new BlogService(mockContext);
            service.AddBlog("ADO.NET Blog", "http://blogs.msdn.com/adonet");
            
            mockSet.Received(1).Add(Arg.Any<Blog>()); // set add 方法调用一次
            mockContext.Received(1).SaveChanges(); // context savechanges 方法调用一次
            
            // 实体属性验证
            addBolg.Name.ShouldBe("ADO.NET Blog");
            addBolg.Url.ShouldBe("http://blogs.msdn.com/adonet");

            addBolg.Name.ShouldNotBe("ADO.NET");
        }
    }
}

测试查询

为了能够针对我们的DbSet测试执行查询，我们需要设置一个IQueryable的实现。第一步是创建一些内存中的数据 - 我们使用的是List <Blog>。接下来，我们创建一个上下文和DBSet <Blog>，然后连接DbSet的IQueryable实现 - 它们只是委托给与List <T>一起使用的LINQ to Objects提供程序。为了能够针对我们的DbSet测试执行查询，我们需要设置一个IQueryable的实现。第一步是创建一些内存中的数据 - 我们使用的是List <Blog>。接下来，我们创建一个上下文和DBSet <Blog>，然后连接DbSet的IQueryable实现 - 它们只是委托给与List <T>一起使用的LINQ to Objects提供程序。


using Microsoft.VisualStudio.TestTools.UnitTesting; 
using Moq; 
using System.Collections.Generic; 
using System.Data.Entity; 
using System.Linq; 
 
namespace TestingDemo 
{ 
    public class QueryTests
    {
        [Fact]
        public void GetAllBlogs_orders_by_name()
        {
            var data = new List<Blog>
                           {
                               new Blog { Name = "BBB" },
                               new Blog { Name = "ZZZ" },
                               new Blog { Name = "AAA" },
                           }.AsQueryable();

            var mockSet = Substitute.For<DbSet<Blog>, IQueryable<Blog>>();
            ((IQueryable<Blog>)mockSet).Provider.Returns(data.Provider);
            ((IQueryable<Blog>)mockSet).Expression.Returns(data.Expression);
            ((IQueryable<Blog>)mockSet).ElementType.Returns(data.ElementType);
            ((IQueryable<Blog>)mockSet).GetEnumerator().Returns(data.GetEnumerator());
            
            var mockContext = Substitute.For<BloggingContext>();
            mockContext.Blogs.Returns(mockSet);
            var service = new BlogService(mockContext);
            var blogs = service.GetAllBlogs();
            blogs.Count.ShouldBe(3);
            blogs[0].Name.ShouldBe("AAA");
            blogs[1].Name.ShouldBe("BBB");
            blogs[2].Name.ShouldBe("ZZZ");
            
        }
    }
}

测试异步查询方案

为了使用异步查询，我们需要做更多的工作。如果我们尝试使用我们的Moq DbSet与GetAllBlogsAsync方法，我们将得到以下异常：为了使用异步查询，我们需要做更多的工作。如果我们尝试使用我们的Moq DbSet与GetAllBlogsAsync方法，我们将得到以下异常：

System.InvalidOperationException: The source IQueryable doesn't implement IDbAsyncEnumerable<TestingDemo.Blog>. Only sources that implement IDbAsyncEnumerable can be used for Entity Framework asynchronous operations. For more details see http://go.microsoft.com/fwlink/?LinkId=287068._System.InvalidOperationException

为了使用异步方法，我们需要创建一个内存中的DbAsyncQueryProvider来处理异步查询。虽然可以使用Moq设置查询提供程序，但是在代码中创建测试双重实现要容易得多。此实现的代码如下：


using System.Collections.Generic; 
using System.Data.Entity.Infrastructure; 
using System.Linq; 
using System.Linq.Expressions; 
using System.Threading; 
using System.Threading.Tasks; 
 
namespace TestingDemo 
{ 
    internal class TestDbAsyncQueryProvider<TEntity> : IDbAsyncQueryProvider 
    { 
        private readonly IQueryProvider _inner; 
 
        internal TestDbAsyncQueryProvider(IQueryProvider inner) 
        { 
            _inner = inner; 
        } 
 
        public IQueryable CreateQuery(Expression expression) 
        { 
            return new TestDbAsyncEnumerable<TEntity>(expression); 
        } 
 
        public IQueryable<TElement> CreateQuery<TElement>(Expression expression) 
        { 
            return new TestDbAsyncEnumerable<TElement>(expression); 
        } 
 
        public object Execute(Expression expression) 
        { 
            return _inner.Execute(expression); 
        } 
 
        public TResult Execute<TResult>(Expression expression) 
        { 
            return _inner.Execute<TResult>(expression); 
        } 
 
        public Task<object> ExecuteAsync(Expression expression, CancellationToken cancellationToken) 
        { 
            return Task.FromResult(Execute(expression)); 
        } 
 
        public Task<TResult> ExecuteAsync<TResult>(Expression expression, CancellationToken cancellationToken) 
        { 
            return Task.FromResult(Execute<TResult>(expression)); 
        } 
    } 
 
    internal class TestDbAsyncEnumerable<T> : EnumerableQuery<T>, IDbAsyncEnumerable<T>, IQueryable<T> 
    { 
        public TestDbAsyncEnumerable(IEnumerable<T> enumerable) 
            : base(enumerable) 
        { } 
 
        public TestDbAsyncEnumerable(Expression expression) 
            : base(expression) 
        { } 
 
        public IDbAsyncEnumerator<T> GetAsyncEnumerator() 
        { 
            return new TestDbAsyncEnumerator<T>(this.AsEnumerable().GetEnumerator()); 
        } 
 
        IDbAsyncEnumerator IDbAsyncEnumerable.GetAsyncEnumerator() 
        { 
            return GetAsyncEnumerator(); 
        } 
 
        IQueryProvider IQueryable.Provider 
        { 
            get { return new TestDbAsyncQueryProvider<T>(this); } 
        } 
    } 
 
    internal class TestDbAsyncEnumerator<T> : IDbAsyncEnumerator<T> 
    { 
        private readonly IEnumerator<T> _inner; 
 
        public TestDbAsyncEnumerator(IEnumerator<T> inner) 
        { 
            _inner = inner; 
        } 
 
        public void Dispose() 
        { 
            _inner.Dispose(); 
        } 
 
        public Task<bool> MoveNextAsync(CancellationToken cancellationToken) 
        { 
            return Task.FromResult(_inner.MoveNext()); 
        } 
 
        public T Current 
        { 
            get { return _inner.Current; } 
        } 
 
        object IDbAsyncEnumerator.Current 
        { 
            get { return Current; } 
        } 
    } 
}

现在我们有一个异步查询提供程序，我们可以为我们的新的GetAllBlogsAsync方法编写单元测试。现在我们有一个异步查询提供程序，我们可以为我们的新的GetAllBlogsAsync方法编写单元测试。


using Microsoft.VisualStudio.TestTools.UnitTesting; 
using Moq; 
using System.Collections.Generic; 
using System.Data.Entity; 
using System.Data.Entity.Infrastructure; 
using System.Linq; 
using System.Threading.Tasks; 
 
namespace TestingDemo 
{ 
    public class AsyncQueryTests
    {
        [Fact]
        public async Task GetAllBlogsAsync_orders_by_name()
        {
            var data = new List<Blog>
                           {
                               new Blog { Name = "BBB" },
                               new Blog { Name = "ZZZ" },
                               new Blog { Name = "AAA" },
                           }.AsQueryable();

            var mockSet = Substitute.For<DbSet<Blog>, IQueryable<Blog>, IDbAsyncEnumerable<Blog>>();

            ((IDbAsyncEnumerable<Blog>)mockSet).GetAsyncEnumerator()
                .Returns(new TestDbAsyncEnumerator<Blog>(data.GetEnumerator()));
            ((IQueryable<Blog>)mockSet).Provider
                .Returns(new TestDbAsyncQueryProvider<Blog>(data.Provider));

            ((IQueryable<Blog>)mockSet).Expression
                .Returns(data.Expression);
            ((IQueryable<Blog>)mockSet).ElementType
                .Returns(data.ElementType);
            ((IQueryable<Blog>)mockSet).GetEnumerator()
                .Returns(data.GetEnumerator());
            
            var mockContext = Substitute.For<BloggingContext>();
            mockContext.Blogs.Returns(mockSet);
            var service = new BlogService(mockContext);
            var blogs = await service.GetAllBlogsAsync();
            blogs.Count.ShouldBe(3);
            blogs[0].Name.ShouldBe("AAA");
            blogs[1].Name.ShouldBe("BBB");
            blogs[2].Name.ShouldBe("ZZZ");
        }
    }
}

QQ：1260825783(诸葛小亮)

使用xunit、Shouldy、NSubstitute 测试E

前言

参考

源代码

模拟对象的创建

1.创建自定义模拟对象

2.适用Mocking框架创建模拟对象

测试更早版本

局限性

使用准备

EF模型

在上下文使用 virtual 标识 DbSet属性

测试服务

测试非查询

测试查询

测试异步查询方案

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

.NET

asp.net

Asp.net开发

.NET

ABP

使用xunit、Shouldy、NSubstitute 测试E

前言

参考

源代码

模拟对象的创建

1.创建自定义模拟对象

2.适用Mocking框架创建模拟对象

测试更早版本

局限性

使用准备

EF模型

在上下文 使用 virtual 标识 DbSet属性

测试服务

测试非查询

测试查询

测试异步查询方案

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

.NET

asp.net

Asp.net开发

.NET

ABP

在上下文使用 virtual 标识 DbSet属性