使用模擬架構進行測試

發行項
09/12/2023

注意

僅限 EF6 及更新版本 - Entity Framework 6 已引進此頁面中所討論的功能及 API 等等。如果您使用的是較早版本，則不適用部分或全部的資訊。

撰寫應用程式的測試時，通常最好避免達到資料庫。 Entity Framework 可讓您藉由建立內容來達成此目的，其中包含測試所定義的行為，以利用記憶體內部資料。

建立測試雙精度浮點數的選項

有兩種不同的方法可用來建立內容記憶體內部版本。

建立您自己的測試雙精度浮點 數 – 此方法牽涉到撰寫內容和 DbSets 的記憶體內部實作。這可讓您充分掌控類別的行為，但可能牽涉到撰寫及擁有合理的程式碼數量。
使用模擬架構來建立測試雙精度浮 點數 – 使用模擬架構（例如 Moq），您可以擁有內容的記憶體內實作，並在執行時間動態建立集合。

本文將處理使用模擬架構。若要建立您自己的測試雙精度浮點數，請參閱使用您自己的測試雙精度浮點數進行測試。

為了示範搭配模擬架構使用 EF，我們將使用 Moq。取得 Moq 最簡單的方式是從 NuGet 安裝 Moq 套件。

使用 EF6 前版本進行測試

本文所示的案例取決於我們對 EF6 中 DbSet 所做的一些變更。若要使用 EF5 和舊版進行測試，請參閱使用 Fake CoNtext 進行測試。

EF 記憶體內部測試雙精度浮點數的限制

記憶體內部測試雙精度浮點數是提供使用 EF 之應用程式的單元測試層級涵蓋範圍的好方法。不過，當您這樣做時，您會使用 LINQ to Objects 對記憶體內部資料執行查詢。這可能會導致與使用 EF 的 LINQ 提供者（LINQ to Entities）不同的行為，將查詢轉譯成針對資料庫執行的 SQL。

這類差異的其中一個範例是載入相關資料。如果您建立一系列具有相關文章的部落格，則在使用記憶體內部資料時，每個部落格一律會載入相關的文章。不過，針對資料庫執行時，只有在您使用 Include 方法時，才會載入資料。

基於這個理由，建議一律包含一些端對端測試層級（除了單元測試外），以確保您的應用程式可針對資料庫正確運作。

遵循這篇文章

本文提供完整的程式代碼清單，您可以視需要複製到 Visual Studio 中以遵循。建立單元測試專案最簡單的方式 ，您必須以 .NET Framework 4.5 為目標 ，才能完成使用非同步區 段。

EF 模型

我們將測試的服務會使用由 BloggingCoNtext 和 Blog 和 Post 類別組成的 EF 模型。此程式碼可能是由 EF 設計工具產生，或是程式碼優先模型。

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; }
    }
}

使用 EF 設計工具的虛擬 DbSet 屬性

請注意，內容上的 DbSet 屬性會標示為虛擬。這可讓模擬架構衍生自我們的內容，並使用模擬實作覆寫這些屬性。

如果您使用 Code First，則可以直接編輯類別。如果您使用 EF 設計工具，則必須編輯產生內容的 T4 範本。 <開啟巢狀于 edmx 檔案下的 model_name.CoNtext.tt > 檔案，尋找下列程式碼片段，並在虛擬關鍵字中新增，如下所示。

public string DbSet(EntitySet entitySet)
{
    return string.Format(
        CultureInfo.InvariantCulture,
        "{0} virtual DbSet\<{1}> {2} {{ get; set; }}",
        Accessibility.ForReadOnlyProperty(entitySet),
        _typeMapper.GetTypeName(entitySet.ElementType),
        _code.Escape(entitySet));
}

要測試的服務

為了示範使用記憶體內部測試的雙重測試，我們將撰寫一些 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 < 部落格 > ，並連接它，以從內容的 Blogs 屬性傳回。接下來，內容會用來建立新的 BlogService，然後使用 AddBlog 方法來建立新的部落格。最後，測試會確認服務已新增部落格，並在內容上呼叫 SaveChanges。

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;
using System.Data.Entity;

namespace TestingDemo
{
    [TestClass]
    public class NonQueryTests
    {
        [TestMethod]
        public void CreateBlog_saves_a_blog_via_context()
        {
            var mockSet = new Mock<DbSet<Blog>>();

            var mockContext = new Mock<BloggingContext>();
            mockContext.Setup(m => m.Blogs).Returns(mockSet.Object);

            var service = new BlogService(mockContext.Object);
            service.AddBlog("ADO.NET Blog", "http://blogs.msdn.com/adonet");

            mockSet.Verify(m => m.Add(It.IsAny<Blog>()), Times.Once());
            mockContext.Verify(m => m.SaveChanges(), Times.Once());
        }
    }
}

測試查詢案例

為了能夠針對 DbSet 測試雙重執行查詢，我們需要設定 IQueryable 的實作。第一個步驟是建立一些記憶體內部資料 – 我們使用清單 < 部落格 > 。接下來，我們會建立內容和 DBSet < 部落格 > ，然後連接 DbSet 的 IQueryable 實作，它們只是委派給可與 List < T > 搭配運作的 LINQ to Objects 提供者。

然後，我們可以根據測試雙精度浮點數建立 BlogService，並確定我們從 GetAllBlogs 取得的資料會依名稱排序。

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;

namespace TestingDemo
{
    [TestClass]
    public class QueryTests
    {
        [TestMethod]
        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 = new Mock<DbSet<Blog>>();
            mockSet.As<IQueryable<Blog>>().Setup(m => m.Provider).Returns(data.Provider);
            mockSet.As<IQueryable<Blog>>().Setup(m => m.Expression).Returns(data.Expression);
            mockSet.As<IQueryable<Blog>>().Setup(m => m.ElementType).Returns(data.ElementType);
            mockSet.As<IQueryable<Blog>>().Setup(m => m.GetEnumerator()).Returns(() => data.GetEnumerator());

            var mockContext = new Mock<BloggingContext>();
            mockContext.Setup(c => c.Blogs).Returns(mockSet.Object);

            var service = new BlogService(mockContext.Object);
            var blogs = service.GetAllBlogs();

            Assert.AreEqual(3, blogs.Count);
            Assert.AreEqual("AAA", blogs[0].Name);
            Assert.AreEqual("BBB", blogs[1].Name);
            Assert.AreEqual("ZZZ", blogs[2].Name);
        }
    }
}

使用非同步查詢進行測試

Entity Framework 6 引進了一組擴充方法，可用來非同步執行查詢。這些方法的範例包括 ToListAsync、FirstAsync、ForEachAsync 等。

因為 Entity Framework 查詢會使用 LINQ，因此擴充方法會在 IQueryable 和 IEnumerable 上定義。不過，由於它們只設計成與 Entity Framework 搭配使用，所以如果您嘗試在不是 Entity Framework 查詢的 LINQ 查詢上使用它們，您可能會收到下列錯誤：

來源 IQueryable 不會實作 IDbAsyncEnumerable {0} 。只有實作 IDbAsyncEnumerable 的來源可用於 Entity Framework 非同步作業。如需詳細資訊，請參閱 http://go.microsoft.com/fwlink/?LinkId=287068 。

雖然非同步方法只有在針對 EF 查詢執行時才支援，但針對 DbSet 的記憶體中測試雙精度浮點數執行時，您可能會想要在單元測試中使用它們。

為了使用非同步方法，我們需要建立記憶體內部 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 方法撰寫單元測試。

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
{
    [TestClass]
    public class AsyncQueryTests
    {
        [TestMethod]
        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 = new Mock<DbSet<Blog>>();
            mockSet.As<IDbAsyncEnumerable<Blog>>()
                .Setup(m => m.GetAsyncEnumerator())
                .Returns(new TestDbAsyncEnumerator<Blog>(data.GetEnumerator()));

            mockSet.As<IQueryable<Blog>>()
                .Setup(m => m.Provider)
                .Returns(new TestDbAsyncQueryProvider<Blog>(data.Provider));

            mockSet.As<IQueryable<Blog>>().Setup(m => m.Expression).Returns(data.Expression);
            mockSet.As<IQueryable<Blog>>().Setup(m => m.ElementType).Returns(data.ElementType);
            mockSet.As<IQueryable<Blog>>().Setup(m => m.GetEnumerator()).Returns(() => data.GetEnumerator());

            var mockContext = new Mock<BloggingContext>();
            mockContext.Setup(c => c.Blogs).Returns(mockSet.Object);

            var service = new BlogService(mockContext.Object);
            var blogs = await service.GetAllBlogsAsync();

            Assert.AreEqual(3, blogs.Count);
            Assert.AreEqual("AAA", blogs[0].Name);
            Assert.AreEqual("BBB", blogs[1].Name);
            Assert.AreEqual("ZZZ", blogs[2].Name);
        }
    }
}

共用方式為