测试与质量

测试层次

xUnit：基础单元测试

public class OrderServiceTests
{
    private readonly Mock<IOrderRepository> _repoMock = new();
    private readonly Mock<IEmailService>    _emailMock = new();
    private readonly OrderService           _sut;   // System Under Test

    public OrderServiceTests()
    {
        _sut = new OrderService(_repoMock.Object, _emailMock.Object);
    }

    [Fact]
    public async Task CreateOrder_WithValidRequest_ReturnsOrderWithId()
    {
        // Arrange
        var request = new CreateOrderRequest("user1", [new("product-1", 2, 99.99m)]);
        _repoMock.Setup(r => r.SaveAsync(It.IsAny<Order>(), It.IsAny<CancellationToken>()))
                 .ReturnsAsync((Order o, CancellationToken _) =>
                 {
                     o.Id = 42;
                     return o;
                 });

        // Act
        var result = await _sut.CreateAsync(request);

        // Assert（FluentAssertions）
        result.Should().NotBeNull();
        result.Id.Should().Be(42);
        result.Total.Should().Be(199.98m);

        // 验证邮件发送被调用了一次
        _emailMock.Verify(
            e => e.SendOrderConfirmationAsync("user1", 42, It.IsAny<CancellationToken>()),
            Times.Once()
        );
    }

    [Theory]
    [InlineData("discount10", 100m, 90m)]
    [InlineData("discount20", 100m, 80m)]
    [InlineData("invalid", 100m, 100m)]
    public void ApplyDiscount_WithVariousCodes_ReturnsCorrectTotal(
        string code, decimal original, decimal expected)
    {
        var result = DiscountCalculator.Apply(code, original);
        result.Should().Be(expected);
    }
}

FluentAssertions：可读性极强的断言

// 数值断言
result.Should().BeGreaterThan(0);
result.Should().BeInRange(1, 100);

// 字符串断言
message.Should().StartWith("Hello").And.EndWith("!");
message.Should().Contain("World", Exactly.Once());

// 集合断言
list.Should().HaveCount(3).And.Contain(x => x.IsActive);
list.Should().BeInAscendingOrder(x => x.Name);
list.Should().AllSatisfy(x => x.Age.Should().BePositive());

// 异常断言
var act = () => service.CreateUser(null);
await act.Should().ThrowAsync<ArgumentNullException>()
    .WithMessage("*email*");

// 对象属性匹配
user.Should().BeEquivalentTo(new { Name = "Alice", Age = 30 },
    opts => opts.ExcludingMissingMembers());

WebApplicationFactory：集成测试

WebApplicationFactory<TProgram> 在内存中启动完整的 ASP.NET Core 应用，通过真实 HTTP 客户端发送请求，但不开监听真实端口，速度快且无端口冲突。

public class ProductsApiTests : IClassFixture<WebApplicationFactory<Program>>
{
    private readonly HttpClient _client;

    public ProductsApiTests(WebApplicationFactory<Program> factory)
    {
        _client = factory
            .WithWebHostBuilder(builder =>
            {
                builder.ConfigureServices(services =>
                {
                    // 替换数据库为 SQLite 内存库
                    services.RemoveAll<DbContextOptions<AppDbContext>>();
                    services.AddDbContext<AppDbContext>(opts =>
                        opts.UseInMemoryDatabase("TestDb"));
                });
            })
            .CreateClient();
    }

    [Fact]
    public async Task GetProducts_ReturnsOkWithList()
    {
        var response = await _client.GetAsync("/api/products");

        response.Should().HaveStatusCode(HttpStatusCode.OK);
        var products = await response.Content.ReadFromJsonAsync<List<ProductDto>>();
        products.Should().NotBeNull().And.BeEmpty();
    }

    [Fact]
    public async Task CreateProduct_WithValidData_Returns201()
    {
        var req = new { Name = "Test Product", Price = 9.99m };
        var response = await _client.PostAsJsonAsync("/api/products", req);

        response.Should().HaveStatusCode(HttpStatusCode.Created);
        response.Headers.Location.Should().NotBeNull();
    }
}

TestContainers：真实数据库集成测试

TestContainers 在测试时自动启动 Docker 容器（PostgreSQL、Redis、Kafka 等），使用真实数据库而非模拟。测试结束后自动清理容器。

// 安装: dotnet add package Testcontainers.PostgreSql

public class DatabaseIntegrationTests : IAsyncLifetime
{
    private readonly PostgreSqlContainer _postgres =
        new PostgreSqlBuilder()
            .WithImage("postgres:16")
            .WithDatabase("testdb")
            .Build();

    public async Task InitializeAsync()
    {
        await _postgres.StartAsync();

        // 应用迁移
        var options = new DbContextOptionsBuilder<AppDbContext>()
            .UseNpgsql(_postgres.GetConnectionString())
            .Options;
        await using var db = new AppDbContext(options);
        await db.Database.MigrateAsync();
    }

    public async Task DisposeAsync() => await _postgres.DisposeAsync().AsTask();

    [Fact]
    public async Task SaveAndQuery_User_WorksWithRealPostgres()
    {
        var options = new DbContextOptionsBuilder<AppDbContext>()
            .UseNpgsql(_postgres.GetConnectionString()).Options;

        await using var db = new AppDbContext(options);
        db.Users.Add(new User { Email = "test@example.com", Name = "Test" });
        await db.SaveChangesAsync();

        var user = await db.Users.FirstOrDefaultAsync(u => u.Email == "test@example.com");
        user.Should().NotBeNull();
        user!.Name.Should().Be("Test");
    }
}

BenchmarkDotNet：性能基准测试

// 安装: dotnet add package BenchmarkDotNet
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

[MemoryDiagnoser]      // 显示内存分配
[SimpleJob]             // 单 Job，快速结果
public class StringBenchmarks
{
    private readonly string _input = string.Join(",", Enumerable.Range(1, 1000));

    [Benchmark(Baseline = true)]
    public string[] SplitClassic() => _input.Split(',');

    [Benchmark]
    public List<string> SplitWithSpan()
    {
        var result = new List<string>();
        var remaining = _input.AsSpan();
        int idx;
        while ((idx = remaining.IndexOf(',')) >= 0)
        {
            result.Add(remaining[..idx].ToString());
            remaining = remaining[(idx + 1)..];
        }
        result.Add(remaining.ToString());
        return result;
    }
}

// 运行（必须 Release 模式）
// dotnet run -c Release
BenchmarkRunner.Run<StringBenchmarks>();