C#单元测试框架xUnit与Moq模拟实战

1. 认识 xUnit 和 Moq

1.1 xUnit 简介

xUnit 是一个广泛用于 .NET 平台的单元测试框架。它提供了一种简洁且高效的方式来编写和执行单元测试。xUnit 遵循单元测试的最佳实践，例如测试的独立性、可重复性等。与其他测试框架（如 NUnit）相比，xUnit 具有轻量级、灵活的特点，并且支持并行测试，这在提高测试执行效率方面具有很大优势。

xUnit 框架提供了一系列特性和约定来帮助开发人员编写单元测试。例如，它使用特性（Attributes）来标记测试方法，这些特性可以控制测试的执行行为，如 [Fact] 用于标记简单的测试方法，[Theory] 用于标记参数化测试方法。

1.2 Moq 简介

Moq 是一个用于 .NET 的流行的模拟框架。在单元测试中，模拟对象用于代替系统中的真实依赖。通过创建模拟对象，开发人员可以隔离被测试的单元，使其不受外部依赖的影响，从而更专注地测试单元的核心逻辑。

Moq 提供了一种简洁而强大的方式来创建模拟对象，并设置其行为。它基于动态代理技术，允许开发人员快速生成模拟对象，并对其方法进行配置，以返回预定义的值或执行特定的操作。例如，在测试一个依赖数据库访问的服务时，可以使用 Moq 创建一个模拟的数据库访问对象，这样就不需要实际连接数据库，避免了数据库相关的复杂操作和潜在的错误。

2. 环境搭建

2.1 创建项目

首先，我们需要创建一个新的 C# 项目来演示 xUnit 和 Moq 的使用。打开 Visual Studio，选择创建一个新的类库项目（Class Library）。这里我们将创建一个简单的示例项目，假设我们要开发一个计算器服务，它提供基本的加、减、乘、除运算。

在项目中创建一个 Calculator.cs 文件，代码如下：

public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }

    public int Subtract(int a, int b)
    {
        return a - b;
    }

    public int Multiply(int a, int b)
    {
        return a * b;
    }

    public double Divide(int a, int b)
    {
        if (b == 0)
        {
            throw new DivideByZeroException();
        }
        return (double)a / b;
    }
}

2.2 安装 xUnit 和 Moq 包

为了在项目中使用 xUnit 和 Moq，我们需要安装相应的 NuGet 包。在 Visual Studio 中，右键点击项目，选择“管理 NuGet 包”。在 NuGet 包管理器中，搜索并安装 xunit 和 xunit.runner.visualstudio 包，这两个包分别用于编写测试代码和在 Visual Studio 中运行测试。

对于 Moq，同样在 NuGet 包管理器中搜索并安装 Moq 包。安装完成后，项目的 Dependencies 节点下会显示这些包，表明安装成功。

3. 使用 xUnit 进行基本单元测试

3.1 简单测试方法（[Fact]）

在项目中创建一个新的测试项目，右键点击解决方案，选择“添加” -> “新建项目”，然后选择“xUnit 测试项目”。将新创建的测试项目命名为 Calculator.Tests。

在 Calculator.Tests 项目中，创建一个 CalculatorTests.cs 文件。编写以下测试代码来测试 Calculator 类的 Add 方法：

using Xunit;

public class CalculatorTests
{
    [Fact]
    public void Add_ShouldReturnCorrectSum()
    {
        // Arrange
        var calculator = new Calculator();
        int a = 2;
        int b = 3;

        // Act
        int result = calculator.Add(a, b);

        // Assert
        Assert.Equal(5, result);
    }
}

在上述代码中，使用 [Fact] 特性标记了一个测试方法 Add_ShouldReturnCorrectSum。在测试方法中，首先创建了 Calculator 类的实例（Arrange 阶段），然后调用 Add 方法并获取结果（Act 阶段），最后使用 Assert.Equal 方法来验证结果是否符合预期（Assert 阶段）。

3.2 参数化测试（[Theory]）

参数化测试允许我们使用不同的输入值来运行同一个测试逻辑。这对于测试一些具有多种输入情况的方法非常有用。例如，我们可以对 Calculator 类的 Multiply 方法进行参数化测试：

using Xunit;

public class CalculatorTests
{
    [Theory]
    [InlineData(2, 3, 6)]
    [InlineData(0, 5, 0)]
    [InlineData(-2, 4, -8)]
    public void Multiply_ShouldReturnCorrectProduct(int a, int b, int expected)
    {
        // Arrange
        var calculator = new Calculator();

        // Act
        int result = calculator.Multiply(a, b);

        // Assert
        Assert.Equal(expected, result);
    }
}

在上述代码中，使用 [Theory] 特性标记了 Multiply_ShouldReturnCorrectProduct 方法，该方法接受三个参数 a、b 和 expected。通过 [InlineData] 特性提供了多组测试数据，每一组数据都会使测试方法运行一次，从而验证 Multiply 方法在不同输入情况下的正确性。

4. 引入 Moq 进行模拟测试

4.1 场景假设

假设我们现在要对一个更复杂的服务进行测试，这个服务依赖于另一个外部服务。例如，我们有一个 OrderService，它依赖于一个 ProductService 来获取产品价格，以便计算订单总价。ProductService 可能会涉及到数据库查询或网络调用等复杂操作。为了隔离 OrderService 的测试，我们使用 Moq 来模拟 ProductService。

首先，定义 ProductService 接口和 OrderService 类：

public interface IProductService
{
    double GetProductPrice(int productId);
}

public class OrderService
{
    private readonly IProductService _productService;

    public OrderService(IProductService productService)
    {
        _productService = productService;
    }

    public double CalculateOrderTotal(int[] productIds)
    {
        double total = 0;
        foreach (var productId in productIds)
        {
            total += _productService.GetProductPrice(productId);
        }
        return total;
    }
}

4.2 使用 Moq 创建模拟对象

在测试项目中，编写测试 OrderService 的代码：

using Moq;
using Xunit;

public class OrderServiceTests
{
    [Fact]
    public void CalculateOrderTotal_ShouldReturnCorrectTotal()
    {
        // Arrange
        var mockProductService = new Mock<IProductService>();
        mockProductService.Setup(ps => ps.GetProductPrice(1)).Returns(10.0);
        mockProductService.Setup(ps => ps.GetProductPrice(2)).Returns(20.0);

        var orderService = new OrderService(mockProductService.Object);
        int[] productIds = { 1, 2 };

        // Act
        double result = orderService.CalculateOrderTotal(productIds);

        // Assert
        Assert.Equal(30.0, result);
    }
}

在上述代码中，首先使用 Mock<IProductService> 创建了一个 IProductService 的模拟对象 mockProductService。然后使用 Setup 方法来配置模拟对象的行为，当调用 GetProductPrice 方法并传入 1 时，返回 10.0；传入 2 时，返回 20.0。接着创建 OrderService 的实例，并将模拟对象传递给它。最后调用 CalculateOrderTotal 方法并验证结果。

4.3 验证方法调用

Moq 还允许我们验证模拟对象的方法是否被正确调用。例如，我们可以验证 OrderService 在计算订单总价时是否正确调用了 ProductService 的 GetProductPrice 方法。修改测试代码如下：

using Moq;
using Xunit;

public class OrderServiceTests
{
    [Fact]
    public void CalculateOrderTotal_ShouldCallGetProductPrice()
    {
        // Arrange
        var mockProductService = new Mock<IProductService>();
        mockProductService.Setup(ps => ps.GetProductPrice(1)).Returns(10.0);
        mockProductService.Setup(ps => ps.GetProductPrice(2)).Returns(20.0);

        var orderService = new OrderService(mockProductService.Object);
        int[] productIds = { 1, 2 };

        // Act
        orderService.CalculateOrderTotal(productIds);

        // Assert
        mockProductService.Verify(ps => ps.GetProductPrice(1), Times.Once);
        mockProductService.Verify(ps => ps.GetProductPrice(2), Times.Once);
    }
}

在上述代码中，使用 Verify 方法来验证 GetProductPrice 方法是否被调用了一次，并且传入的参数是否正确。Times.Once 表示方法应该被调用一次，如果方法没有被调用或者调用次数不符合预期，测试将会失败。

5. 高级 Moq 特性

5.1 顺序验证

在某些情况下，我们可能需要验证模拟对象的方法调用顺序。例如，假设 OrderService 在计算订单总价之前需要先调用 ProductService 的 CheckProductAvailability 方法，并且只有在产品可用时才会调用 GetProductPrice 方法。我们可以使用 Moq 的顺序验证功能来测试这种情况。

首先，修改 IProductService 接口和 OrderService 类：

public interface IProductService
{
    bool CheckProductAvailability(int productId);
    double GetProductPrice(int productId);
}

public class OrderService
{
    private readonly IProductService _productService;

    public OrderService(IProductService productService)
    {
        _productService = productService;
    }

    public double CalculateOrderTotal(int[] productIds)
    {
        double total = 0;
        foreach (var productId in productIds)
        {
            if (_productService.CheckProductAvailability(productId))
            {
                total += _productService.GetProductPrice(productId);
            }
        }
        return total;
    }
}

然后编写测试代码：

using Moq;
using Xunit;

public class OrderServiceTests
{
    [Fact]
    public void CalculateOrderTotal_ShouldCallMethodsInCorrectOrder()
    {
        // Arrange
        var mockProductService = new Mock<IProductService>();
        mockProductService.Setup(ps => ps.CheckProductAvailability(1)).Returns(true);
        mockProductService.Setup(ps => ps.GetProductPrice(1)).Returns(10.0);

        var orderService = new OrderService(mockProductService.Object);
        int[] productIds = { 1 };

        // Act
        orderService.CalculateOrderTotal(productIds);

        // Assert
        var order = new MockSequence();
        mockProductService.InSequence(order).Setup(ps => ps.CheckProductAvailability(1));
        mockProductService.InSequence(order).Setup(ps => ps.GetProductPrice(1));
    }
}

在上述代码中，首先创建了一个 MockSequence 对象 order。然后使用 InSequence 方法将 CheckProductAvailability 和 GetProductPrice 方法的设置放入同一个顺序序列中。这样就可以验证 OrderService 在计算订单总价时是否按照正确的顺序调用了 ProductService 的方法。

5.2 回调函数

有时候，我们可能需要在模拟对象的方法被调用时执行一些额外的操作。Moq 提供了回调函数（Callback）功能来满足这种需求。例如，假设我们要记录 ProductService 的 GetProductPrice 方法被调用的次数。

修改测试代码如下：

using Moq;
using Xunit;

public class OrderServiceTests
{
    [Fact]
    public void CalculateOrderTotal_ShouldRecordGetProductPriceCalls()
    {
        // Arrange
        int callCount = 0;
        var mockProductService = new Mock<IProductService>();
        mockProductService.Setup(ps => ps.GetProductPrice(It.IsAny<int>()))
           .Returns(10.0)
           .Callback(() => callCount++);

        var orderService = new OrderService(mockProductService.Object);
        int[] productIds = { 1, 2 };

        // Act
        orderService.CalculateOrderTotal(productIds);

        // Assert
        Assert.Equal(2, callCount);
    }
}

在上述代码中，通过 Callback 方法注册了一个回调函数，当 GetProductPrice 方法被调用时，callCount 变量会自增。最后验证 callCount 的值是否等于产品 ID 的数量，从而确认 GetProductPrice 方法被正确调用的次数。

6. 处理异步方法

6.1 xUnit 中的异步测试

在 C# 中，很多方法都是异步的。xUnit 对异步测试提供了很好的支持。假设 Calculator 类有一个异步的 DivideAsync 方法：

public class Calculator
{
    // 其他方法...

    public async Task<double> DivideAsync(int a, int b)
    {
        if (b == 0)
        {
            throw new DivideByZeroException();
        }
        await Task.Delay(100); // 模拟一些异步操作
        return (double)a / b;
    }
}

在测试项目中，编写异步测试方法：

using Xunit;
using System.Threading.Tasks;

public class CalculatorTests
{
    [Fact]
    public async Task DivideAsync_ShouldReturnCorrectResult()
    {
        // Arrange
        var calculator = new Calculator();
        int a = 4;
        int b = 2;

        // Act
        double result = await calculator.DivideAsync(a, b);

        // Assert
        Assert.Equal(2.0, result);
    }
}

在上述代码中，测试方法 DivideAsync_ShouldReturnCorrectResult 被标记为 async，并且使用 await 关键字等待异步方法 DivideAsync 完成。这样就可以像测试同步方法一样测试异步方法。

6.2 Moq 中的异步模拟

当模拟的接口方法是异步时，Moq 也提供了相应的支持。假设 IProductService 中的 GetProductPriceAsync 方法是异步的：

public interface IProductService
{
    Task<double> GetProductPriceAsync(int productId);
}

public class OrderService
{
    private readonly IProductService _productService;

    public OrderService(IProductService productService)
    {
        _productService = productService;
    }

    public async Task<double> CalculateOrderTotalAsync(int[] productIds)
    {
        double total = 0;
        foreach (var productId in productIds)
        {
            total += await _productService.GetProductPriceAsync(productId);
        }
        return total;
    }
}

在测试项目中，编写测试代码：

using Moq;
using Xunit;
using System.Threading.Tasks;

public class OrderServiceTests
{
    [Fact]
    public async Task CalculateOrderTotalAsync_ShouldReturnCorrectTotal()
    {
        // Arrange
        var mockProductService = new Mock<IProductService>();
        mockProductService.Setup(ps => ps.GetProductPriceAsync(1)).ReturnsAsync(10.0);
        mockProductService.Setup(ps => ps.GetProductPriceAsync(2)).ReturnsAsync(20.0);

        var orderService = new OrderService(mockProductService.Object);
        int[] productIds = { 1, 2 };

        // Act
        double result = await orderService.CalculateOrderTotalAsync(productIds);

        // Assert
        Assert.Equal(30.0, result);
    }
}

在上述代码中，使用 ReturnsAsync 方法来设置异步模拟方法的返回值。测试方法同样使用 async 和 await 来处理异步操作，从而对依赖异步方法的服务进行测试。

7. 集成测试与单元测试的结合

虽然单元测试主要关注单个单元的逻辑，但在实际项目中，我们也需要进行集成测试，以验证多个单元之间的协作是否正常。例如，我们可以结合 xUnit 和 Moq 来测试 OrderService 与真实的数据库访问层（假设使用 Entity Framework Core）的集成。

首先，假设我们有一个基于 Entity Framework Core 的 ProductRepository 实现 IProductService 接口：

using Microsoft.EntityFrameworkCore;
using System.Threading.Tasks;

public class ProductRepository : IProductService
{
    private readonly AppDbContext _dbContext;

    public ProductRepository(AppDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public async Task<double> GetProductPriceAsync(int productId)
    {
        var product = await _dbContext.Products.FindAsync(productId);
        if (product == null)
        {
            throw new ProductNotFoundException();
        }
        return product.Price;
    }
}

然后，我们可以编写一个集成测试，在测试中使用真实的 ProductRepository，但使用 Moq 来模拟数据库上下文（因为实际的数据库操作可能会影响测试的独立性和速度）：

using Moq;
using Xunit;
using System.Threading.Tasks;

public class OrderServiceIntegrationTests
{
    [Fact]
    public async Task CalculateOrderTotalAsync_WithRealRepository_ShouldReturnCorrectTotal()
    {
        // Arrange
        var mockDbContext = new Mock<AppDbContext>();
        var mockSet = new Mock<DbSet<Product>>();
        mockSet.Setup(m => m.FindAsync(1)).ReturnsAsync(new Product { Price = 10.0 });
        mockSet.Setup(m => m.FindAsync(2)).ReturnsAsync(new Product { Price = 20.0 });
        mockDbContext.Setup(c => c.Products).Returns(mockSet.Object);

        var productRepository = new ProductRepository(mockDbContext.Object);
        var orderService = new OrderService(productRepository);
        int[] productIds = { 1, 2 };

        // Act
        double result = await orderService.CalculateOrderTotalAsync(productIds);

        // Assert
        Assert.Equal(30.0, result);
    }
}

在上述代码中，使用 Moq 模拟了 AppDbContext 和 DbSet<Product>，然后创建了真实的 ProductRepository 和 OrderService 实例进行集成测试。这样既可以测试 OrderService 与 ProductRepository 的协作，又避免了实际的数据库操作对测试的影响。

通过以上详细的介绍和示例，我们深入了解了 C# 中 xUnit 单元测试框架与 Moq 模拟框架的实战应用，从基本的单元测试编写到复杂的模拟场景，以及异步方法测试和集成测试的结合，希望这些内容能帮助开发人员更好地进行软件测试，提高代码质量。