使用xunit 测试Entity Framework (EF6.0)

上一篇 / 下一篇  2017-06-02 11:52:09 / 个人分类：白盒测试工具

查看( 681 ) / 评论( 0 ) / 评分( 0 / 0 )
模拟对象的创建
有两种不同的方法可以用来创建一个内存中的上下文
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");
        }
    }

收藏 举报

TAG: xunit xUnit

 

评分：0

我来说两句

Open Toolbar