.NET on 纪伟的个人博客

.NET 单元测试（七）：测试工程化

Thu, 21 May 2026 10:00:00 +0800

写在前面

本文是 .NET 单元测试系列的最后一篇，介绍测试的工程化实践：命名规范、项目组织、代码覆盖率、TDD 工作流和 CI/CD 集成。前置知识：集成测试（第六篇）。

一、命名规范

1.1 测试方法命名

推荐格式：MethodName_Scenario_Expected

示例：
Add_TwoPositiveNumbers_ReturnsSum
Divide_ByZero_ThrowsDivideByZeroException
CreateOrder_EmptyItems_ThrowsArgumentException
GetUser_NonExistingId_ReturnsNull
ProcessPayment_InsufficientFunds_ReturnsFailed

1.2 测试类命名

被测类 + Tests
UserService → UserServiceTests
OrderService → OrderServiceTests
Calculator → CalculatorTests

1.3 测试项目命名

1
2
3

MyApp.Services        → MyApp.Services.Tests          （单元测试）
MyApp.Services        → MyApp.Services.IntegrationTests（集成测试）
MyApp.Web             → MyApp.Web.Tests

1.4 文件组织

tests/
├── MyApp.Services.Tests/
│   ├── Services/
│   │   ├── UserServiceTests.cs
│   │   ├── OrderServiceTests.cs
│   │   └── PaymentServiceTests.cs
│   ├── Validators/
│   │   ├── UserValidatorTests.cs
│   │   └── OrderValidatorTests.cs
│   └── Helpers/
│       └── TestDataBuilder.cs
├── MyApp.Services.IntegrationTests/
│   ├── Repository/
│   │   └── UserRepositoryTests.cs
│   └── Infrastructure/
│       └── DatabaseMigrationTests.cs
└── MyApp.Web.Tests/
    ├── Controllers/
    │   └── UserControllerTests.cs
    └── Middleware/
        └── ExceptionHandlingMiddlewareTests.cs

二、测试分类

2.1 按速度分类

单元测试（Unit）        — 毫秒级，不依赖外部
集成测试（Integration） — 秒级，依赖数据库/文件
端到端测试（E2E）       — 十秒级，完整用户流程

按比例：70% 单元 / 20% 集成 / 10% E2E

2.2 用 Trait 标记分类

[Trait("Category", "Unit")]
public class CalculatorTests
{
    [Fact, Trait("Category", "Unit")]
    public void Add_ReturnsSum() { }
}

[Trait("Category", "Integration")]
public class UserRepositoryTests
{
    [Fact, Trait("Category", "Integration")]
    public void Save_WritesToDatabase() { }
}

[Trait("Category", "Slow")]
public class PerformanceTests
{
    [Fact, Trait("Category", "Slow")]
    public void LargeDataset_ProcessesWithinTimeout() { }
}

2.3 按分类运行

# 只跑单元测试
dotnet test --filter "Category=Unit"

# 只跑集成测试
dotnet test --filter "Category=Integration"

# 排除慢测试
dotnet test --filter "Category!=Slow"

# 组合条件
dotnet test --filter "Category=Unit&FullyQualifiedName~UserService"

2.4 分项目组织

src/
├── MyApp.Core/
├── MyApp.Services/
└── MyApp.Web/

tests/
├── MyApp.Core.Tests/                 # 单元测试
├── MyApp.Services.Tests/             # 单元测试
├── MyApp.Services.IntegrationTests/  # 集成测试
└── MyApp.Web.IntegrationTests/       # API 集成测试

<!-- 目录结构约定：让单元测试和集成测试分开 -->
<!-- Unit Tests csproj -->
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.*" />
    <PackageReference Include="xunit" Version="2.*" />
    <PackageReference Include="xunit.runner.visualstudio" Version="2.*" />
    <PackageReference Include="Moq" Version="4.*" />
  </ItemGroup>
</Project>

<!-- Integration Tests csproj -->
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.*" />
    <PackageReference Include="xunit" Version="2.*" />
    <PackageReference Include="xunit.runner.visualstudio" Version="2.*" />
    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="8.*" />
  </ItemGroup>
</Project>

三、测试数据构建

3.1 Builder 模式

public class UserBuilder
{
    private int _id = 1;
    private string _name = "测试用户";
    private string _email = "test@example.com";
    private int _age = 25;
    private MemberLevel _level = MemberLevel.Regular;

    public UserBuilder WithId(int id) { _id = id; return this; }
    public UserBuilder WithName(string name) { _name = name; return this; }
    public UserBuilder WithEmail(string email) { _email = email; return this; }
    public UserBuilder WithAge(int age) { _age = age; return this; }
    public UserBuilder AsVIP() { _level = MemberLevel.VIP; return this; }

    public User Build() => new()
    {
        Id = _id,
        Name = _name,
        Email = _email,
        Age = _age,
        Level = _level
    };

    // 静态工厂方法
    public static UserBuilder Typical() => new();
    public static UserBuilder VIP() => new UserBuilder().AsVIP();
}

// 使用
[Fact]
public void Test()
{
    var user = UserBuilder.Typical()
        .WithName("张三")
        .WithAge(30)
        .Build();

    var vip = UserBuilder.VIP()
        .WithEmail("vip@test.com")
        .Build();
}

3.2 Order Builder

public class OrderBuilder
{
    private readonly List<OrderItem> _items = new();
    private string _customerEmail = "customer@test.com";
    private PaymentMethod _payment = PaymentMethod.CreditCard;

    public OrderBuilder WithItem(decimal price, int quantity = 1)
    {
        _items.Add(new OrderItem { Price = price, Quantity = quantity });
        return this;
    }

    public OrderBuilder WithCustomerEmail(string email)
    {
        _customerEmail = email;
        return this;
    }

    public OrderBuilder WithPayment(PaymentMethod payment)
    {
        _payment = payment;
        return this;
    }

    public OrderBuilder Empty()
    {
        _items.Clear();
        return this;
    }

    public Order Build() => new()
    {
        Id = Guid.NewGuid(),
        CustomerEmail = _customerEmail,
        PaymentMethod = _payment,
        Items = _items.ToList()
    };
}

// 使用
[Fact]
public void CalculateTotal_MultipleItems_SumsCorrectly()
{
    var order = new OrderBuilder()
        .WithItem(100, 2)   // 200
        .WithItem(50, 1)    // 50
        .Build();

    var total = service.CalculateTotal(order);

    Assert.Equal(250m, total);
}

[Fact]
public void CreateOrder_EmptyOrder_ThrowsException()
{
    var order = new OrderBuilder().Empty().Build();

    Assert.Throws<ArgumentException>(() => service.CreateOrder(order));
}

3.3 Object Mother 模式

// 预定义的常用测试数据
public static class TestData
{
    public static User TypicalUser => new()
    {
        Id = 1, Name = "张三", Email = "zhang@test.com", Age = 25
    };

    public static User VIPUser => new()
    {
        Id = 2, Name = "李四", Email = "li@test.com", Age = 30, Level = MemberLevel.VIP
    };

    public static Order TypicalOrder => new OrderBuilder()
        .WithItem(100, 2)
        .Build();

    public static Order EmptyOrder => new OrderBuilder().Empty().Build();
}

// 使用
[Fact]
public void Test() => service.Process(TestData.TypicalUser);

四、代码覆盖率

4.1 收集覆盖率

# 安装工具
dotnet tool install --global dotnet-coverage

# 收集覆盖率
dotnet-coverage collect "dotnet test" --output-format cobertura --output coverage.xml

# 或者用 coverlet.msbuild
dotnet test --collect:"XPlat Code Coverage"

4.2 添加 coverlet 包

<ItemGroup>
  <PackageReference Include="coverlet.collector" Version="6.*">
    <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
    <PrivateAssets>all</PrivateAssets>
  </PackageReference>
</ItemGroup>

1
2

# 收集并生成报告
dotnet test --collect:"XPlat Code Coverage" --results-directory ./coverage

4.3 生成可视化报告

# 安装 ReportGenerator
dotnet tool install --global dotnet-reportgenerator-globaltool

# 生成 HTML 报告
reportgenerator \
  -reports:coverage/**/coverage.cobertura.xml \
  -targetdir:coverage/report \
  -reporttypes:Html

4.4 覆盖率配置

<!-- 在 csproj 或 runsettings 中配置 -->
<!-- runsettings.xml -->
<?xml version="1.0" encoding="utf-8"?>
<RunSettings>
  <DataCollectionRunSettings>
    <DataCollectors>
      <DataCollector friendlyName="XPlat code coverage">
        <Configuration>
          <Format>cobertura</Format>
          <Include>[MyApp.*]*</Include>              <!-- 只统计自己的代码 -->
          <Exclude>[MyApp.*Tests]*</Exclude>         <!-- 排除测试代码 -->
          <ExcludeByAttribute>ObsoleteAttribute</Exclude>
          <ExcludeByFile>**/Migrations/**</Exclude>  <!-- 排除迁移文件 -->
          <Threshold>80</Threshold>                  <!-- 覆盖率低于 80% 失败 -->
        </Configuration>
      </DataCollector>
    </DataCollectors>
  </DataCollectionRunSettings>
</RunSettings>

`1`	`dotnet test --settings runsettings.xml`

4.5 覆盖率的意义和误区

覆盖率的意义：
  ✓ 发现未测试的代码路径
  ✓ 衡量测试充分度的参考指标
  ✓ CI 中设置最低门槛

覆盖率的误区：
  ✗ 100% 覆盖率 ≠ 没有Bug
  ✗ 只说明代码被执行了，不说明测试有效
  ✗ 不要为了数字而写无意义测试
  ✗ getter/setter 不需要测

五、TDD 简介

5.1 红-绿-重构

TDD 流程：
1. 红（Red）    — 先写一个失败的测试
2. 绿（Green）  — 写最少的代码让测试通过
3. 重构（Refactor）— 优化代码，保持测试通过

循环往复，逐步完善功能。

5.2 TDD 实战示例

需求：实现一个密码验证器
- 长度至少8位
- 包含大写字母
- 包含小写字母
- 包含数字
- 包含特殊字符

// 第1轮：测试长度
[Fact]
public void Validate_ShortPassword_ReturnsFalse()
{
    var result = PasswordValidator.Validate("Ab1!");
    Assert.False(result.IsValid);
    Assert.Contains("长度至少8位", result.Errors);
}

// 实现最简代码
public static class PasswordValidator
{
    public static ValidationResult Validate(string password)
    {
        var errors = new List<string>();
        if (password.Length < 8) errors.Add("长度至少8位");
        return new ValidationResult { IsValid = errors.Count == 0, Errors = errors };
    }
}

// 第2轮：测试大写字母
[Fact]
public void Validate_NoUpperCase_ReturnsFalse()
{
    var result = PasswordValidator.Validate("abcdefg1!");
    Assert.False(result.IsValid);
    Assert.Contains("需包含大写字母", result.Errors);
}

// 补充实现
if (!password.Any(char.IsUpper)) errors.Add("需包含大写字母");

// 第3轮：测试小写字母
// ... 逐步添加测试和实现

// 第4轮：测试数字
// ...

// 第5轮：测试特殊字符
// ...

// 最终：测试有效密码
[Fact]
public void Validate_ValidPassword_ReturnsTrue()
{
    var result = PasswordValidator.Validate("Abcdefg1!");
    Assert.True(result.IsValid);
    Assert.Empty(result.Errors);
}

5.3 TDD 的优缺点

优点：
  - 迫使你先想清楚接口设计
  - 测试覆盖率高
  - 代码天然可测试
  - 重构有安全感

缺点：
  - 上手门槛高，需要练习
  - 开发初期速度慢
  - 需求频繁变化时维护成本高
  - 不是所有场景都适合（如 UI、探索性代码）

建议：
  - 核心/复杂业务逻辑用 TDD
  - 简单 CRUD 不需要 TDD
  - 先学会写测试，再学 TDD

六、测试坏味道

6.1 常见坏味道和修复

// 坏味道1：测试之间有依赖（顺序敏感）
[Fact]
public void Test1_Insert() { /* 插入数据 */ }
[Fact]
public void Test2_Query() { /* 查询 Test1 插入的数据 */ }
// 修复：每个测试独立准备数据

// 坏味道2：一个测试测太多
[Fact]
public void UserTest()
{
    // 测试创建
    // 测试查询
    // 测试更新
    // 测试删除
    // 一次测试全部 CRUD
}
// 修复：拆分为多个独立的测试方法

// 坏味道3：魔法数字
Assert.Equal(200m, order.Total); // 200 是怎么来的？
// 修复：用有意义的变量
var expectedTotal = 100m * 2; // 单价 * 数量
Assert.Equal(expectedTotal, order.Total);

// 坏味道4：过度 Mock
mockRepo.Setup(r => r.GetAll()).Returns(users);
mockRepo.Setup(r => r.GetById(1)).Returns(user);
mockRepo.Setup(r => r.Save(It.IsAny<User>()));
mockRepo.Setup(r => r.Delete(It.IsAny<int>()));
// 用了 10 个 Setup，但只测了一个方法
// 修复：只 Mock 当前测试需要的

// 坏味道5：测试不确定性（随机失败）
[Fact]
public void RandomTest()
{
    var result = service.GetRandomUser();
    // 有时通过有时不通过
}
// 修复：固定输入，断言确定的输出

// 坏味道6：sleep 等待
[Fact]
public async Task BadSleep()
{
    service.Start();
    Thread.Sleep(5000); // 等待5秒
    Assert.True(service.IsReady);
}
// 修复：用轮询 + 超时
[Fact]
public async Task GoodPolling()
{
    service.Start();
    await WaitUntil(() => service.IsReady, timeout: TimeSpan.FromSeconds(10));
    Assert.True(service.IsReady);
}

6.2 坏味道速查

测试代码重复         → 提取公共方法或基类
测试太长             → 拆分为多个测试
测试太慢             → 减少 I/O，多用 Mock
测试脆弱（经常挂）   → 减少对实现细节的依赖
测试名不清晰         → 用 MethodName_Scenario_Expected 格式
断言不足             → 每个 Act 至少一个 Assert
断言太多             → 可能在测多件事，考虑拆分

七、CI/CD 中的测试

7.1 GitHub Actions

name: Test

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: 8.0.x

      - name: Restore
        run: dotnet restore

      - name: Build
        run: dotnet build --no-restore

      - name: Unit Tests
        run: dotnet test --no-build --filter "Category=Unit" --logger "trx"

      - name: Integration Tests
        run: dotnet test --no-build --filter "Category=Integration"

      - name: Coverage
        run: |
          dotnet test --collect:"XPlat Code Coverage" \
            --settings runsettings.xml \
            --results-directory ./coverage

      - name: Coverage Report
        uses: danielpalme/ReportGenerator-GitHub-Action@5
        with:
          reports: coverage/**/coverage.cobertura.xml
          targetdir: coverage/report
          reporttypes: 'HtmlInline;Cobertura'

      - name: Upload Coverage
        uses: actions/upload-artifact@v4
        with:
          name: coverage-report
          path: coverage/report

7.2 分层运行策略

# 快速反馈：PR 提交时跑单元测试（秒级）
- name: Unit Tests
  run: dotnet test --filter "Category=Unit"

# 完整验证：合并到 main 时跑所有测试（分钟级）
- name: All Tests
  if: github.ref == 'refs/heads/main'
  run: dotnet test

7.3 测试报告

# 生成 TRX 报告（Visual Studio 格式）
dotnet test --logger "trx;LogFileName=test_results.trx"

# 生成 JUnit 格式报告（CI 兼容）
dotnet test --logger "junit;LogFileName=test_results.xml"

八、dotnet test 常用命令

# 基本运行
dotnet test

# 详细输出
dotnet test --verbosity normal

# 只跑某个项目
dotnet test tests/MyApp.Services.Tests

# 按名称过滤
dotnet test --filter "FullyQualifiedName~UserService"

# 按分类过滤
dotnet test --filter "Category=Unit"
dotnet test --filter "Category!=Slow"

# 组合过滤
dotnet test --filter "Category=Unit&FullyQualifiedName~Add"

# 运行指定方法
dotnet test --filter "FullyQualifiedName=MyApp.Tests.CalculatorTests.Add_TwoNumbers_ReturnsSum"

# 监视模式（文件变化自动重跑）
dotnet test --watch

# 不构建直接跑（需要先构建）
dotnet test --no-build

# 指定运行设置
dotnet test --settings runsettings.xml

# 指定框架
dotnet test --framework net8.0

# 并行运行
dotnet test --parallel

# 超时控制
dotnet test --blame-hang --blame-hang-timeout 60s

九、开发者测试工作流

9.1 日常开发流程

写新功能：
  1. 先写测试用例（至少覆盖正常和异常）
  2. 运行测试 → 红色（失败）
  3. 写实现代码
  4. 运行测试 → 绿色（通过）
  5. 重构代码
  6. 再跑一遍测试 → 仍然绿色

修 Bug：
  1. 先写一个复现 Bug 的测试 → 红色
  2. 修复代码
  3. 测试变绿 → Bug 确认修复
  4. 回归测试

重构：
  1. 确保现有测试全绿
  2. 重构代码
  3. 跑测试确认没有破坏
  4. 如有必要更新测试

9.2 什么时候写测试

必须写：
  - 核心业务逻辑
  - 复杂算法和计算
  - 支付/金额相关
  - 权限和安全检查

建议写：
  - Service 层的公开方法
  - 数据验证逻辑
  - 状态转换逻辑

可以不写：
  - 简单的 CRUD
  - 纯 UI 代码
  - 第三方库的包装（没有自定义逻辑）
  - getter/setter

十、系列总结

10.1 知识体系回顾

第一篇：单元测试基础
  - xUnit 环境搭建、AAA 模式、断言详解

第二篇：xUnit 进阶
  - 数据驱动测试、共享上下文、并行控制

第三篇：Mock 与隔离
  - Moq 框架、Test Double 分类、Mock 反模式

第四篇：依赖注入与可测试性
  - 接口设计、构造函数注入、重构不可测代码

第五篇：难测场景实战
  - 数据库、HTTP、时间、文件系统、配置

第六篇：集成测试
  - WebApplicationFactory、认证授权、中间件测试

第七篇：测试工程化
  - 命名规范、覆盖率、TDD、CI/CD

10.2 核心原则

1. 测行为，不测实现
2. 隔离外部依赖
3. 每个测试只测一件事
4. 测试命名就是文档
5. 保持测试简单可读
6. 不要为了覆盖率写无意义测试
7. 先学会写测试，再学 TDD
8. 把测试当作投资，不是负担

10.3 检查清单

代码质量：
  □ 所有公共方法有测试覆盖
  □ 正常路径和异常路径都测了
  □ 边界条件有测试

测试质量：
  □ 测试之间互相独立
  □ 测试命名清晰
  □ 测试运行快速（秒级）

工程化：
  □ 测试在 CI 中自动运行
  □ 覆盖率有门槛
  □ 测试失败能快速定位问题

.NET 单元测试（六）：集成测试

Wed, 20 May 2026 10:00:00 +0800

写在前面

本文是 .NET 单元测试系列的第六篇，介绍 ASP.NET Core 应用的集成测试：WebApplicationFactory、真实数据库测试、中间件和认证测试。前置知识：难测场景实战（第五篇）。

一、为什么需要集成测试

1.1 单元测试的局限

单元测试：
  ✓ 逻辑正确性
  ✗ 组件协作是否正确
  ✗ 配置是否正确
  ✗ 中间件是否生效
  ✗ 数据库查询是否正确
  ✗ 依赖注入注册是否正确

1.2 集成测试的范围

验证多个组件协作：
  Controller → Service → Repository → Database
  Middleware → Controller → Response
  配置注入 → 实际使用

二、WebApplicationFactory

2.1 基本用法

// 被测 API 项目：MyApp.Web
[Program]  // 让测试项目能访问 Program 类
public partial class TestProgram { }

// 测试项目
public class CustomWebApplicationFactory : WebApplicationFactory<Program>
{
    protected override void ConfigureWebHost(IWebHostBuilder builder)
    {
        builder.ConfigureServices(services =>
        {
            // 替换数据库为 InMemory
            var descriptor = services.SingleOrDefault(
                d => d.ServiceType == typeof(DbContextOptions<AppDbContext>));
            if (descriptor != null)
                services.Remove(descriptor);

            services.AddDbContext<AppDbContext>(options =>
                options.UseInMemoryDatabase("TestDb"));

            // 替换外部服务为 Mock
            services.AddScoped<IEmailService>(_ =>
            {
                var mock = new Mock<IEmailService>();
                mock.Setup(e => e.SendAsync(It.IsAny<string>(), It.IsAny<string>()))
                    .Returns(Task.CompletedTask);
                return mock.Object;
            });
        });
    }
}

2.2 测试基类

public abstract class IntegrationTestBase : IClassFixture<CustomWebApplicationFactory>
{
    protected readonly HttpClient Client;
    protected readonly CustomWebApplicationFactory Factory;

    protected IntegrationTestBase(CustomWebApplicationFactory factory)
    {
        Factory = factory;
        Client = factory.CreateClient();
    }

    protected async Task ResetDatabaseAsync()
    {
        using var scope = Factory.Services.CreateScope();
        var context = scope.ServiceProvider.GetRequiredService<AppDbContext>();
        context.Database.EnsureDeleted();
        context.Database.EnsureCreated();
    }

    protected async Task SeedDataAsync(params object[] entities)
    {
        using var scope = Factory.Services.CreateScope();
        var context = scope.ServiceProvider.GetRequiredService<AppDbContext>();

        foreach (var entity in entities)
        {
            context.Add(entity);
        }
        await context.SaveChangesAsync();
    }
}

2.3 基本 API 测试

public class UserControllerTests : IntegrationTestBase
{
    public UserControllerTests(CustomWebApplicationFactory factory) : base(factory) { }

    [Fact]
    public async Task GetUserById_ExistingUser_ReturnsOk()
    {
        // 准备数据
        await SeedDataAsync(new User { Id = 1, Name = "张三", Email = "zhang@test.com" });

        // 调用 API
        var response = await Client.GetAsync("/api/users/1");

        // 验证
        response.EnsureSuccessStatusCode();
        var user = await response.Content.ReadFromJsonAsync<UserDto>();
        Assert.Equal("张三", user!.Name);
    }

    [Fact]
    public async Task CreateUser_ValidInput_ReturnsCreated()
    {
        var request = new CreateUserRequest
        {
            Name = "李四",
            Email = "li@test.com"
        };

        var response = await Client.PostAsJsonAsync("/api/users", request);

        Assert.Equal(HttpStatusCode.Created, response.StatusCode);
        var user = await response.Content.ReadFromJsonAsync<UserDto>();
        Assert.Equal("李四", user!.Name);
        Assert.True(user.Id > 0);
    }

    [Fact]
    public async Task CreateUser_DuplicateEmail_ReturnsConflict()
    {
        await SeedDataAsync(new User { Name = "张三", Email = "dup@test.com" });

        var request = new CreateUserRequest { Name = "李四", Email = "dup@test.com" };

        var response = await Client.PostAsJsonAsync("/api/users", request);

        Assert.Equal(HttpStatusCode.Conflict, response.StatusCode);
    }

    [Fact]
    public async Task GetUserById_NonExisting_ReturnsNotFound()
    {
        var response = await Client.GetAsync("/api/users/999");

        Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
    }
}

三、数据库集成测试

3.1 用 Testcontainers 跑真实数据库

1
2

dotnet add package Testcontainers.MsSql
dotnet add package Testcontainers.Redis

public class RealDatabaseTests : IAsyncLifetime
{
    private MsSqlContainer _container = null!;
    private HttpClient _client = null!;

    public async Task InitializeAsync()
    {
        // 启动 SQL Server 容器
        _container = new MsSqlBuilder()
            .WithImage("mcr.microsoft.com/mssql/server:2022-latest")
            .Build();
        await _container.StartAsync();

        // 用真实数据库创建 WebApplicationFactory
        var factory = new CustomWebApplicationFactory(builder =>
        {
            builder.ConfigureServices(services =>
            {
                var descriptor = services.SingleOrDefault(
                    d => d.ServiceType == typeof(DbContextOptions<AppDbContext>));
                if (descriptor != null)
                    services.Remove(descriptor);

                services.AddDbContext<AppDbContext>(options =>
                    options.UseSqlServer(_container.GetConnectionString()));
            });
        });

        _client = factory.CreateClient();

        // 运行迁移
        using var scope = factory.Services.CreateScope();
        var context = scope.ServiceProvider.GetRequiredService<AppDbContext>();
        await context.Database.MigrateAsync();
    }

    [Fact]
    public async Task CreateUser_WithRealDb_Succeeds()
    {
        var request = new CreateUserRequest { Name = "张三", Email = "zhang@test.com" };

        var response = await _client.PostAsJsonAsync("/api/users", request);

        Assert.Equal(HttpStatusCode.Created, response.StatusCode);
    }

    public async Task DisposeAsync()
    {
        await _container.DisposeAsync();
    }
}

3.2 事务回滚模式

// 每个测试用事务包裹，测试完回滚，数据不残留
public class TransactionTestBase : IntegrationTestBase, IDisposable
{
    private readonly AppDbContext _context;
    private readonly IDbContextTransaction _transaction;

    public TransactionTestBase(CustomWebApplicationFactory factory) : base(factory)
    {
        var scope = factory.Services.CreateScope();
        _context = scope.ServiceProvider.GetRequiredService<AppDbContext>();
        _transaction = _context.Database.BeginTransaction();
    }

    public void Dispose()
    {
        _transaction.Rollback();
        _transaction.Dispose();
        _context.Dispose();
    }
}

四、测试中间件

4.1 测试自定义中间件

// 被测中间件：请求日志
public class RequestLoggingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<RequestLoggingMiddleware> _logger;

    public RequestLoggingMiddleware(RequestDelegate next, ILogger<RequestLoggingMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        _logger.LogInformation("请求：{Method} {Path}",
            context.Request.Method, context.Request.Path);

        await _next(context);

        _logger.LogInformation("响应：{StatusCode}", context.Response.StatusCode);
    }
}

// 测试
[Fact]
public async Task RequestLoggingMiddleware_LogsRequestAndResponse()
{
    // 手动构建 HttpContext
    var mockLogger = new Mock<ILogger<RequestLoggingMiddleware>>();
    var mockNext = new Mock<RequestDelegate>();
    mockNext.Setup(next => next(It.IsAny<HttpContext>()))
            .Returns(Task.CompletedTask);

    var middleware = new RequestLoggingMiddleware(mockNext.Object, mockLogger.Object);

    var context = new DefaultHttpContext();
    context.Request.Method = "GET";
    context.Request.Path = "/api/test";
    context.Response.StatusCode = 200;

    await middleware.InvokeAsync(context);

    mockNext.Verify(n => n(context), Times.Once);
}

4.2 测试异常处理中间件

public class ExceptionHandlingMiddleware
{
    private readonly RequestDelegate _next;

    public ExceptionHandlingMiddleware(RequestDelegate next) => _next = next;

    public async Task InvokeAsync(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch (ValidationException ex)
        {
            context.Response.StatusCode = 400;
            await context.Response.WriteAsJsonAsync(new { error = ex.Message });
        }
        catch (NotFoundException ex)
        {
            context.Response.StatusCode = 404;
            await context.Response.WriteAsJsonAsync(new { error = ex.Message });
        }
        catch (Exception)
        {
            context.Response.StatusCode = 500;
            await context.Response.WriteAsJsonAsync(new { error = "服务器内部错误" });
        }
    }
}

[Fact]
public async Task ExceptionMiddleware_ValidationException_Returns400()
{
    var mockNext = new Mock<RequestDelegate>();
    mockNext.Setup(n => n(It.IsAny<HttpContext>()))
            .Throws(new ValidationException("名称不能为空"));

    var middleware = new ExceptionHandlingMiddleware(mockNext.Object);
    var context = new DefaultHttpContext();
    context.Response.Body = new MemoryStream();

    await middleware.InvokeAsync(context);

    Assert.Equal(400, context.Response.StatusCode);
}

[Fact]
public async Task ExceptionMiddleware_UnhandledException_Returns500()
{
    var mockNext = new Mock<RequestDelegate>();
    mockNext.Setup(n => n(It.IsAny<HttpContext>()))
            .Throws(new Exception("未知错误"));

    var middleware = new ExceptionHandlingMiddleware(mockNext.Object);
    var context = new DefaultHttpContext();
    context.Response.Body = new MemoryStream();

    await middleware.InvokeAsync(context);

    Assert.Equal(500, context.Response.StatusCode);
}

五、认证和授权测试

5.1 测试需要认证的接口

public class AuthenticatedApiTests : IntegrationTestBase
{
    public AuthenticatedApiTests(CustomWebApplicationFactory factory) : base(factory)
    {
        // 方式一：配置工厂不使用认证（简化测试）
    }

    [Fact]
    public async Task GetProfile_WithoutAuth_Returns401()
    {
        var response = await Client.GetAsync("/api/users/profile");

        Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
    }

    [Fact]
    public async Task GetProfile_WithAuth_ReturnsProfile()
    {
        // 模拟已认证用户
        var token = GenerateTestToken("user-1", "张三");
        Client.DefaultRequestHeaders.Authorization =
            new AuthenticationHeaderValue("Bearer", token);

        var response = await Client.GetAsync("/api/users/profile");

        response.EnsureSuccessStatusCode();
    }
}

5.2 模拟认证用户

// 自定义 WebApplicationFactory，跳过真实认证
public class AuthenticatedWebApplicationFactory : WebApplicationFactory<Program>
{
    protected override void ConfigureWebHost(IWebHostBuilder builder)
    {
        builder.ConfigureServices(services =>
        {
            // 替换认证方案为测试用
            services.AddAuthentication(defaultScheme: "TestScheme")
                .AddScheme<AuthenticationSchemeOptions, TestAuthHandler>(
                    "TestScheme", _ => { });
        });
    }
}

// 测试认证 Handler
public class TestAuthHandler : AuthenticationHandler<AuthenticationSchemeOptions>
{
    public const string TestUserId = "test-user-1";

    public TestAuthHandler(
        IOptionsMonitor<AuthenticationSchemeOptions> options,
        ILoggerFactory logger,
        UrlEncoder encoder) : base(options, logger, encoder) { }

    protected override Task<AuthenticateResult> HandleAuthenticateAsync()
    {
        var claims = new[]
        {
            new Claim(ClaimTypes.NameIdentifier, TestUserId),
            new Claim(ClaimTypes.Name, "测试用户"),
            new Claim(ClaimTypes.Role, "Admin"),
        };

        var identity = new ClaimsIdentity(claims, "TestScheme");
        var principal = new ClaimsPrincipal(identity);
        var ticket = new AuthenticationTicket(principal, "TestScheme");

        return Task.FromResult(AuthenticateResult.Success(ticket));
    }
}

// 使用
public class AdminApiTests : IClassFixture<AuthenticatedWebApplicationFactory>
{
    private readonly HttpClient _client;

    public AdminApiTests(AuthenticatedWebApplicationFactory factory)
    {
        _client = factory.CreateClient();
        // 所有请求自动带认证信息
    }

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

        response.EnsureSuccessStatusCode();
    }
}

5.3 测试 RBAC 授权

// 模拟不同角色
public class RoleBasedTestAuthHandler : AuthenticationHandler<AuthenticationSchemeOptions>
{
    private readonly string _role;

    public RoleBasedTestAuthHandler(
        IOptionsMonitor<AuthenticationSchemeOptions> options,
        ILoggerFactory logger,
        UrlEncoder encoder,
        string role = "User") : base(options, logger, encoder)
    {
        _role = role;
    }

    protected override Task<AuthenticateResult> HandleAuthenticateAsync()
    {
        var claims = new[]
        {
            new Claim(ClaimTypes.NameIdentifier, "test-user"),
            new Claim(ClaimTypes.Role, _role),
        };
        var identity = new ClaimsIdentity(claims, "TestScheme");
        var principal = new ClaimsPrincipal(identity);
        var ticket = new AuthenticationTicket(principal, "TestScheme");

        return Task.FromResult(AuthenticateResult.Success(ticket));
    }
}

// 测试
[Theory]
[InlineData("Admin", HttpStatusCode.OK)]
[InlineData("User", HttpStatusCode.Forbidden)]
public async Task AdminEndpoint_RoleCheck(string role, HttpStatusCode expectedStatus)
{
    var factory = new RoleBasedWebApplicationFactory(role);
    var client = factory.CreateClient();

    var response = await client.GetAsync("/api/admin/settings");

    Assert.Equal(expectedStatus, response.StatusCode);
}

六、Snapshot 测试

6.1 响应结构验证

[Fact]
public async Task GetUserById_ReturnsExpectedStructure()
{
    await SeedDataAsync(new User { Id = 1, Name = "张三", Email = "zhang@test.com" });

    var response = await Client.GetAsync("/api/users/1");
    var body = await response.Content.ReadAsStringAsync();

    // 验证 JSON 结构包含预期字段
    using var doc = JsonDocument.Parse(body);
    var root = doc.RootElement;

    Assert.True(root.TryGetProperty("id", out _));
    Assert.True(root.TryGetProperty("name", out _));
    Assert.True(root.TryGetProperty("email", out _));
    Assert.Equal("张三", root.GetProperty("name").GetString());
}

七、集成测试最佳实践

7.1 测试隔离

每个测试有独立数据：
  - 用不同的数据库（每个测试 new 一个 InMemory 实例）
  - 或者用事务回滚
  - 或者测试前后清理数据

7.2 性能优化

WebApplicationFactory 很重：
  - 用 IClassFixture 共享 Factory
  - 用 CollectionFixture 跨类共享
  - 不要每个测试方法都 new Factory

数据库操作：
  - 用 InMemory 代替真实数据库（快速验证流程）
  - Testcontainers 跑少量关键路径

7.3 测试分类

// 用 Trait 分类
[Fact, Trait("Category", "Integration")]
public void IntegrationTest1() { }

[Fact, Trait("Category", "Unit")]
public void UnitTest1() { }

// 运行指定类别
// dotnet test --filter "Category=Integration"
// dotnet test --filter "Category=Unit"

八、小结

本文学习了 ASP.NET Core 集成测试：

WebApplicationFactory 的使用和配置
API 测试（GET/POST/PUT/DELETE）
数据库集成测试（InMemory、Testcontainers、事务回滚）
中间件测试
认证和授权测试
测试隔离和最佳实践

下一篇将学习测试工程化：命名规范、覆盖率、TDD 和 CI/CD 集成。

.NET 单元测试（五）：难测场景实战

Tue, 19 May 2026 10:00:00 +0800

写在前面

本文是 .NET 单元测试系列的第五篇，逐个击破实际开发中最常见的难测场景：数据库、HTTP 调用、时间、文件系统、配置和静态方法。前置知识：依赖注入与可测试性（第四篇）。

一、数据库测试

1.1 测试策略选择

方案1：Mock IRepository          — 单元测试，不碰数据库
方案2：EF Core InMemory          — 集成测试，内存数据库
方案3：SQLite InMemory           — 集成测试，更接近真实 SQL
方案4：Testcontainers + 真实数据库 — 集成测试，最真实

选择建议：
- 测业务逻辑（Service 层）→ Mock Repository
- 测 Repository 实现本身  → InMemory 或真实数据库

1.2 方案一：Mock Repository（推荐）

// Repository 接口
public interface IUserRepository
{
    User GetById(int id);
    IEnumerable<User> GetAll();
    void Add(User user);
    void Update(User user);
    void Delete(int id);
    Task<User> GetByIdAsync(int id);
}

// Service 测试
public class UserServiceTests
{
    private readonly Mock<IUserRepository> _mockRepo;
    private readonly UserService _service;

    public UserServiceTests()
    {
        _mockRepo = new Mock<IUserRepository>();
        _service = new UserService(_mockRepo.Object);
    }

    [Fact]
    public void GetUser_ExistingId_ReturnsUser()
    {
        var user = new User { Id = 1, Name = "张三" };
        _mockRepo.Setup(r => r.GetById(1)).Returns(user);

        var result = _service.GetUser(1);

        Assert.Equal("张三", result.Name);
    }

    [Fact]
    public void GetUser_NonExistingId_ThrowsNotFoundException()
    {
        _mockRepo.Setup(r => r.GetById(999)).Returns((User?)null);

        Assert.Throws<NotFoundException>(() => _service.GetUser(999));
    }

    [Fact]
    public void CreateUser_ValidUser_SavesToRepo()
    {
        var user = new User { Name = "张三", Email = "zhang@test.com" };

        _service.CreateUser(user);

        _mockRepo.Verify(r => r.Add(It.Is<User>(
            u => u.Name == "张三" && u.Email == "zhang@test.com")), Times.Once);
    }
}

1.3 方案二：EF Core InMemory

// 测试 Repository 实现本身
public class EfUserRepositoryTests : IDisposable
{
    private readonly AppDbContext _context;
    private readonly EfUserRepository _repo;

    public EfUserRepositoryTests()
    {
        var options = new DbContextOptionsBuilder<AppDbContext>()
            .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
            .Options;

        _context = new AppDbContext(options);
        _repo = new EfUserRepository(_context);
    }

    [Fact]
    public async Task AddAsync_ValidUser_SavesToDatabase()
    {
        var user = new User { Name = "张三", Email = "zhang@test.com" };

        await _repo.AddAsync(user);

        var saved = await _context.Users.FirstOrDefaultAsync(u => u.Name == "张三");
        Assert.NotNull(saved);
        Assert.Equal("zhang@test.com", saved.Email);
    }

    [Fact]
    public async Task GetByIdAsync_ExistingUser_ReturnsUser()
    {
        _context.Users.Add(new User { Id = 1, Name = "张三" });
        await _context.SaveChangesAsync();

        var result = await _repo.GetByIdAsync(1);

        Assert.Equal("张三", result!.Name);
    }

    [Fact]
    public async Task DeleteAsync_ExistingUser_RemovesFromDatabase()
    {
        var user = new User { Id = 1, Name = "张三" };
        _context.Users.Add(user);
        await _context.SaveChangesAsync();

        await _repo.DeleteAsync(1);

        Assert.Empty(_context.Users);
    }

    public void Dispose() => _context.Dispose();
}

1.4 方案三：SQLite InMemory（更接近真实）

public class SqliteUserRepositoryTests : IDisposable
{
    private readonly AppDbContext _context;
    private readonly SqliteConnection _connection;

    public SqliteUserRepositoryTests()
    {
        // SQLite InMemory 需要保持连接打开
        _connection = new SqliteConnection("Filename=:memory:");
        _connection.Open();

        var options = new DbContextOptionsBuilder<AppDbContext>()
            .UseSqlite(_connection)
            .Options;

        _context = new AppDbContext(options);
        _context.Database.EnsureCreated(); // 创建表结构
    }

    [Fact]
    public async Task AddAsync_WithConstraints_EnforcesUniqueEmail()
    {
        // SQLite 会执行真实的约束检查，InMemory 不会
        _context.Users.Add(new User { Email = "test@example.com", Name = "A" });
        await _context.SaveChangesAsync();

        _context.Users.Add(new User { Email = "test@example.com", Name = "B" });

        await Assert.ThrowsAsync<DbUpdateException>(
            () => _context.SaveChangesAsync());
    }

    public void Dispose()
    {
        _context.Dispose();
        _connection.Dispose();
    }
}

1.5 InMemory vs SQLite 对比

EF Core InMemory：
  + 速度最快
  + 配置最简单
  - 不执行真实 SQL（没有约束检查、没有级联删除）
  - 行为可能和真实数据库不一致

SQLite InMemory：
  + 执行真实 SQL
  + 有约束检查、级联等
  + 更接近生产环境
  - 稍慢
  - SQLite 特有语法和 SQL Server/MySQL 不完全一样

建议：
  快速验证 Repository 逻辑 → InMemory
  需要验证约束和 SQL 行为 → SQLite
  需要完全真实环境 → Testcontainers

二、HTTP 调用测试

2.1 Mock HttpMessageHandler

// 被测服务
public class WeatherClient
{
    private readonly HttpClient _client;

    public WeatherClient(HttpClient client) => _client = client;

    public async Task<WeatherInfo> GetWeatherAsync(string city)
    {
        var response = await _client.GetAsync($"/api/weather?city={Uri.EscapeDataString(city)}");

        response.EnsureSuccessStatusCode();

        var json = await response.Content.ReadAsStringAsync();
        return JsonSerializer.Deserialize<WeatherInfo>(json)!;
    }
}

// Mock Handler
public class MockHttpMessageHandler : HttpMessageHandler
{
    private readonly Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> _handler;

    public MockHttpMessageHandler(
        Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> handler)
    {
        _handler = handler;
    }

    public List<HttpRequestMessage> SentRequests { get; } = new();

    protected override Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken cancellationToken)
    {
        SentRequests.Add(request);
        return _handler(request, cancellationToken);
    }
}

// 测试
public class WeatherClientTests
{
    [Fact]
    public async Task GetWeatherAsync_ReturnsWeatherInfo()
    {
        var handler = new MockHttpMessageHandler((req, ct) =>
        {
            var json = """{"city":"北京","temperature":25,"description":"晴"}""";
            return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new StringContent(json, Encoding.UTF8, "application/json")
            });
        });

        var client = new HttpClient(handler) { BaseAddress = new Uri("https://api.weather.com") };
        var weatherClient = new WeatherClient(client);

        var result = await weatherClient.GetWeatherAsync("北京");

        Assert.Equal("北京", result.City);
        Assert.Equal(25, result.Temperature);
    }

    [Fact]
    public async Task GetWeatherAsync_SendsCorrectRequest()
    {
        HttpRequestMessage? sentRequest = null;
        var handler = new MockHttpMessageHandler((req, ct) =>
        {
            sentRequest = req;
            return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new StringContent("{}")
            });
        });

        var client = new HttpClient(handler) { BaseAddress = new Uri("https://api.weather.com") };
        var weatherClient = new WeatherClient(client);

        await weatherClient.GetWeatherAsync("北京");

        Assert.NotNull(sentRequest);
        Assert.Equal(HttpMethod.Get, sentRequest.Method);
        Assert.Contains("/api/weather?city=", sentRequest.RequestUri!.ToString());
    }

    [Fact]
    public async Task GetWeatherAsync_ServerError_ThrowsException()
    {
        var handler = new MockHttpMessageHandler((req, ct) =>
            Task.FromResult(new HttpResponseMessage(HttpStatusCode.InternalServerError)));

        var client = new HttpClient(handler) { BaseAddress = new Uri("https://api.weather.com") };
        var weatherClient = new WeatherClient(client);

        await Assert.ThrowsAsync<HttpRequestException>(
            () => weatherClient.GetWeatherAsync("北京"));
    }
}

2.2 简化版 Mock Handler

// 通用简化版
public class StubHttpMessageHandler : HttpMessageHandler
{
    private readonly HttpStatusCode _statusCode;
    private readonly string _content;

    public StubHttpMessageHandler(HttpStatusCode statusCode, string content)
    {
        _statusCode = statusCode;
        _content = content;
    }

    protected override Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken cancellationToken)
    {
        return Task.FromResult(new HttpResponseMessage(_statusCode)
        {
            Content = new StringContent(_content, Encoding.UTF8, "application/json")
        });
    }
}

// 使用
var handler = new StubHttpMessageHandler(HttpStatusCode.OK, """{"id":1,"name":"张三"}""");
var client = new HttpClient(handler) { BaseAddress = new Uri("https://api.example.com") };

三、时间相关测试

3.1 问题：DateTime.Now 不可控

// 不可测
public class SubscriptionService
{
    public bool IsExpired(Subscription sub)
    {
        return sub.ExpiryDate < DateTime.UtcNow;  // 每次运行结果不同
    }
}

3.2 方案一：TimeProvider（.NET 8+）

public class SubscriptionService
{
    private readonly TimeProvider _timeProvider;

    public SubscriptionService(TimeProvider timeProvider)
    {
        _timeProvider = timeProvider;
    }

    public bool IsExpired(Subscription sub)
    {
        return sub.ExpiryDate < _timeProvider.GetUtcNow();
    }
}

// 测试
[Fact]
public void IsExpired_ExpiredDate_ReturnsTrue()
{
    // 用 FakeTimeProvider 控制时间
    var fakeTime = new FakeTimeProvider(new DateTimeOffset(2026, 5, 1, 12, 0, 0, TimeSpan.Zero));
    var service = new SubscriptionService(fakeTime);

    var sub = new Subscription { ExpiryDate = new DateTime(2026, 4, 30) };

    Assert.True(service.IsExpired(sub));
}

[Fact]
public void IsExpired_FutureDate_ReturnsFalse()
{
    var fakeTime = new FakeTimeProvider(new DateTimeOffset(2026, 5, 1, 12, 0, 0, TimeSpan.Zero));
    var service = new SubscriptionService(fakeTime);

    var sub = new Subscription { ExpiryDate = new DateTime(2026, 6, 1) };

    Assert.False(service.IsExpired(sub));
}

// 推进时间
[Fact]
public void Subscription_ExpiresAfterTimeAdvance()
{
    var fakeTime = new FakeTimeProvider(new DateTimeOffset(2026, 5, 1, 12, 0, 0, TimeSpan.Zero));
    var service = new SubscriptionService(fakeTime);

    var sub = new Subscription { ExpiryDate = new DateTime(2026, 5, 10) };
    Assert.False(service.IsExpired(sub));

    // 推进时间到过期之后
    fakeTime.Advance(TimeSpan.FromDays(15));
    Assert.True(service.IsExpired(sub));
}

FakeTimeProvider 在 Microsoft.Extensions.TimeProvider.Testing 包中。

3.3 方案二：自定义接口

// 适用于 .NET 8 以下版本
public interface IDateTimeProvider
{
    DateTime UtcNow { get; }
    DateTime Now { get; }
}

public class SystemDateTimeProvider : IDateTimeProvider
{
    public DateTime UtcNow => DateTime.UtcNow;
    public DateTime Now => DateTime.Now;
}

// 测试时注入可控实现
public class TestDateTimeProvider : IDateTimeProvider
{
    public DateTime UtcNowValue { get; set; }
    public DateTime NowValue { get; set; }

    public DateTime UtcNow => UtcNowValue;
    public DateTime Now => NowValue;
}

四、文件系统测试

4.1 方案一：注入路径 + 临时目录

public class ReportGenerator
{
    private readonly string _outputDir;

    public ReportGenerator(string outputDir)
    {
        _outputDir = outputDir;
        Directory.CreateDirectory(outputDir);
    }

    public string GenerateReport(string content)
    {
        var fileName = $"report_{Guid.NewGuid():N}.txt";
        var filePath = Path.Combine(_outputDir, fileName);
        File.WriteAllText(filePath, content);
        return filePath;
    }

    public string ReadReport(string filePath) => File.ReadAllText(filePath);
}

// 测试
public class ReportGeneratorTests : IDisposable
{
    private readonly string _tempDir;
    private readonly ReportGenerator _generator;

    public ReportGeneratorTests()
    {
        _tempDir = Path.Combine(Path.GetTempPath(), $"test_{Guid.NewGuid():N}");
        _generator = new ReportGenerator(_tempDir);
    }

    [Fact]
    public void GenerateReport_CreatesFile()
    {
        var path = _generator.GenerateReport("测试内容");

        Assert.True(File.Exists(path));
        Assert.Equal("测试内容", File.ReadAllText(path));
    }

    [Fact]
    public void ReadReport_ReturnsContent()
    {
        var path = _generator.GenerateReport("Hello");
        var content = _generator.ReadReport(path);

        Assert.Equal("Hello", content);
    }

    public void Dispose()
    {
        if (Directory.Exists(_tempDir))
            Directory.Delete(_tempDir, true);
    }
}

4.2 方案二：注入 Stream 抽象

public class CsvExporter
{
    public void Export(IEnumerable<User> users, Stream output)
    {
        using var writer = new StreamWriter(output, leaveOpen: true);
        writer.WriteLine("Id,Name,Email");

        foreach (var user in users)
        {
            writer.WriteLine($"{user.Id},{user.Name},{user.Email}");
        }
    }
}

// 测试：用 MemoryStream，不需要真实文件
[Fact]
public void Export_WritesCsvFormat()
{
    var users = new List<User>
    {
        new() { Id = 1, Name = "张三", Email = "zhang@test.com" },
        new() { Id = 2, Name = "李四", Email = "li@test.com" },
    };
    var exporter = new CsvExporter();

    using var stream = new MemoryStream();
    exporter.Export(users, stream);

    stream.Position = 0;
    using var reader = new StreamReader(stream);
    var csv = reader.ReadToEnd();

    Assert.Contains("Id,Name,Email", csv);
    Assert.Contains("1,张三,zhang@test.com", csv);
    Assert.Contains("2,李四,li@test.com", csv);
}

4.3 方案三：System.IO.Abstractions（全面抽象）

1
2

dotnet add package System.IO.Abstractions
dotnet add package System.IO.Abstractions.TestingHelpers

// 生产代码：注入 IFileSystem
public class ConfigManager
{
    private readonly IFileSystem _fs;
    private readonly string _configPath;

    public ConfigManager(IFileSystem fs, string configPath)
    {
        _fs = fs;
        _configPath = configPath;
    }

    public bool ConfigExists() => _fs.File.Exists(_configPath);

    public string ReadConfig() => _fs.File.ReadAllText(_configPath);

    public void WriteConfig(string content)
    {
        var dir = _fs.Path.GetDirectoryName(_configPath)!;
        _fs.Directory.CreateDirectory(dir);
        _fs.File.WriteAllText(_configPath, content);
    }
}

// 测试：用 MockFileSystem，不需要真实磁盘
[Fact]
public void ConfigExists_FileExists_ReturnsTrue()
{
    var fs = new MockFileSystem();
    fs.AddFile("/app/config.json", new MockFileData("""{"key":"value"}"""));

    var manager = new ConfigManager(fs, "/app/config.json");

    Assert.True(manager.ConfigExists());
}

[Fact]
public void WriteConfig_CreatesFile()
{
    var fs = new MockFileSystem();
    var manager = new ConfigManager(fs, "/app/config.json");

    manager.WriteConfig("""{"key":"new_value"}""");

    Assert.True(fs.File.Exists("/app/config.json"));
    Assert.Contains("new_value", fs.File.ReadAllText("/app/config.json"));
}

[Fact]
public void ReadConfig_FileNotFound_Throws()
{
    var fs = new MockFileSystem();  // 空文件系统
    var manager = new ConfigManager(fs, "/app/not-exist.json");

    Assert.Throws<FileNotFoundException>(() => manager.ReadConfig());
}

五、配置测试

5.1 Mock IOptions

public class DatabaseService
{
    private readonly DatabaseSettings _settings;

    public DatabaseService(IOptions<DatabaseSettings> options)
    {
        _settings = options.Value;
    }

    public string GetConnectionString() => _settings.ConnectionString;
}

// 测试
[Fact]
public void GetConnectionString_ReturnsConfiguredValue()
{
    var mockOptions = new Mock<IOptions<DatabaseSettings>>();
    mockOptions.Setup(o => o.Value).Returns(new DatabaseSettings
    {
        ConnectionString = "Server=test;Database=testdb"
    });

    var service = new DatabaseService(mockOptions.Object);
    Assert.Equal("Server=test;Database=testdb", service.GetConnectionString());
}

// 更简洁的方式：不用 Mock，直接创建 OptionsWrapper
[Fact]
public void GetConnectionString_WithOptionsWrapper()
{
    var options = new OptionsWrapper<DatabaseSettings>(new DatabaseSettings
    {
        ConnectionString = "Server=test;Database=testdb"
    });

    var service = new DatabaseService(options);
    Assert.Equal("Server=test;Database=testdb", service.GetConnectionString());
}

5.2 Mock IConfiguration

[Fact]
public void GetConfigValue_FromConfiguration()
{
    var config = new ConfigurationBuilder()
        .AddInMemoryCollection(new Dictionary<string, string?>
        {
            ["App:Name"] = "TestApp",
            ["App:Version"] = "2.0"
        })
        .Build();

    Assert.Equal("TestApp", config["App:Name"]);
    Assert.Equal("2.0", config["App:Version"]);
}

六、多线程和并发测试

6.1 基本并发测试

[Fact]
public async Task ConcurrentAccess_ThreadSafe()
{
    var counter = new ThreadSafeCounter();
    var tasks = Enumerable.Range(0, 1000)
        .Select(_ => Task.Run(() => counter.Increment()));

    await Task.WhenAll(tasks);

    Assert.Equal(1000, counter.Count);
}

[Fact]
public async Task ConcurrentAccess_NotThreadSafe_DetectsIssue()
{
    var counter = new Counter(); // 非线程安全
    var tasks = Enumerable.Range(0, 1000)
        .Select(_ => Task.Run(() => counter.Increment()));

    await Task.WhenAll(tasks);

    // 大概率不等于 1000（竞态条件）
    // 注意：这个测试不稳定，仅用于演示
    Assert.NotEqual(1000, counter.Count);
}

6.2 AsyncLocal 测试

public class TenantContext
{
    private static readonly AsyncLocal<string?> _tenantId = new();

    public static string? CurrentTenant
    {
        get => _tenantId.Value;
        set => _tenantId.Value = value;
    }
}

[Fact]
public async Task AsyncLocal_FlowsAcrossAsyncCalls()
{
    TenantContext.CurrentTenant = "tenant-1";

    await Task.Yield();

    Assert.Equal("tenant-1", TenantContext.CurrentTenant);
}

七、私有方法测试

7.1 不建议直接测私有方法

1
2

私有方法应该通过公共方法间接测试。
如果私有方法复杂到需要单独测，说明应该提取为独立的类。

7.2 如果必须测

// 方案一：internal + InternalsVisibleTo
// 生产代码
internal decimal CalculateTax(decimal amount) => amount * 0.13m;

// AssemblyInfo.cs 或 csproj
[assembly: InternalsVisibleTo("MyApp.Services.Tests")]

// 测试代码（可以访问 internal 方法）
[Fact]
public void CalculateTax_ReturnsCorrectAmount()
{
    var service = new OrderService(repo, email);
    Assert.Equal(13m, service.CalculateTax(100m));
}

// 方案二：通过反射（最后手段）
[Fact]
public void PrivateMethod_Reflection()
{
    var service = new OrderService(repo, email);
    var method = typeof(OrderService).GetMethod("CalculateTax",
        BindingFlags.NonPublic | BindingFlags.Instance);

    var result = (decimal)method!.Invoke(service, new object[] { 100m })!;
    Assert.Equal(13m, result);
}

八、场景选择速查

数据库      → Mock Repository（单元测试）
                EF Core InMemory（Repository 集成测试）
                SQLite InMemory（约束验证）

HTTP 调用   → Mock HttpMessageHandler

时间        → TimeProvider / FakeTimeProvider（.NET 8+）
                自定义 IDateTimeProvider（旧版本）

文件系统    → 临时目录 + IDisposable
                Stream 注入
                System.IO.Abstractions

配置        → OptionsWrapper<T>
                ConfigurationBuilder + AddInMemoryCollection

多线程      → Task.WhenAll 并发执行

私有方法    → 通过公共方法间接测试
                internal + InternalsVisibleTo

九、小结

本文学习了常见难测场景的解决方案：

数据库：Mock Repository、EF Core InMemory、SQLite InMemory
HTTP 调用：Mock HttpMessageHandler
时间：TimeProvider + FakeTimeProvider
文件系统：临时目录、Stream 注入、System.IO.Abstractions
配置：OptionsWrapper、ConfigurationBuilder
多线程和并发测试
私有方法测试策略

下一篇将学习集成测试：WebApplicationFactory、真实数据库和中间件测试。

.NET 单元测试（四）：依赖注入与可测试性

Mon, 18 May 2026 10:00:00 +0800

写在前面

本文是 .NET 单元测试系列的第四篇，介绍如何通过依赖注入设计可测试的代码，以及如何重构不可测的代码。前置知识：Mock 与隔离（第三篇）。

一、可测试性原则

1.1 什么是可测试性

可测试性是指代码容易被自动化测试的程度。

容易测试的代码：
✓ 依赖通过构造函数注入
✓ 方法是纯函数（相同输入 → 相同输出）
✓ 没有隐藏的静态调用
✓ 没有直接 new 具体实现
✓ 可以控制所有输入

难测试的代码：
✗ 在方法内部 new 依赖
✗ 调用 DateTime.Now、File.Read 等静态方法
✗ 依赖单例或静态状态
✗ 方法做太多事（上帝方法）
✗ 密封类、静态方法

1.2 依赖倒置原则（DIP）

1
2

高层模块不应该依赖低层模块，两者都应该依赖抽象。
抽象不应该依赖细节，细节应该依赖抽象。

// 不可测：直接依赖具体实现
public class OrderService
{
    private readonly SqlOrderRepository _repo = new();         // 硬编码
    private readonly SmtpEmailService _email = new();          // 硬编码

    public void CreateOrder(Order order)
    {
        _repo.Save(order);
        _email.Send(order.CustomerEmail, "订单已创建");
    }
}

// 可测：依赖抽象（接口）
public class OrderService
{
    private readonly IOrderRepository _repo;
    private readonly IEmailService _email;

    public OrderService(IOrderRepository repo, IEmailService email)
    {
        _repo = repo;
        _email = email;
    }

    public void CreateOrder(Order order)
    {
        _repo.Save(order);
        _email.Send(order.CustomerEmail, "订单已创建");
    }
}

二、接口设计

2.1 什么时候该抽接口

需要抽接口：
- 涉及外部系统（数据库、HTTP、文件、消息队列）
- 有多种实现的业务逻辑（不同策略、不同租户）
- 需要在测试中 Mock 的依赖

不需要抽接口：
- 纯内存的数据处理（直接用真实对象测）
- 只有一个实现且不会有第二个
- 简单的值对象和数据类

2.2 接口粒度

// 反模式：一个巨大的接口（违反接口隔离原则）
public interface IRepository
{
    User GetUser(int id);
    void SaveUser(User user);
    void DeleteUser(int id);
    Order GetOrder(int id);
    void SaveOrder(Order order);
    void DeleteOrder(int id);
    // ... 50 个方法
}

// 好的做法：小而专注的接口
public interface IUserRepository
{
    User GetById(int id);
    void Save(User user);
    void Delete(int id);
    IEnumerable<User> GetAll();
}

public interface IOrderRepository
{
    Order GetById(int id);
    void Save(Order order);
    IEnumerable<Order> GetByUserId(int userId);
}

2.3 接口命名规范

1
2
3

I + 名词              — IRepository、IUserService
I + 动词 + able       — IDisposable、IComparable
I + 描述 + Provider   — ITimeProvider、IFileProvider

三、构造函数注入

3.1 基本模式

public class PaymentService
{
    private readonly IPaymentGateway _gateway;
    private readonly IOrderRepository _repo;
    private readonly ILogger<PaymentService> _logger;

    // 所有依赖通过构造函数注入
    public PaymentService(
        IPaymentGateway gateway,
        IOrderRepository repo,
        ILogger<PaymentService> logger)
    {
        _gateway = gateway ?? throw new ArgumentNullException(nameof(gateway));
        _repo = repo ?? throw new ArgumentNullException(nameof(repo));
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
    }

    public PaymentResult ProcessPayment(Order order)
    {
        _logger.LogInformation("处理支付：{OrderId}", order.Id);

        var result = _gateway.Charge(order.Total, order.PaymentMethod);

        if (result.Success)
        {
            order.Status = OrderStatus.Paid;
            _repo.Save(order);
        }

        return result;
    }
}

3.2 测试时注入 Mock

public class PaymentServiceTests
{
    private readonly Mock<IPaymentGateway> _mockGateway;
    private readonly Mock<IOrderRepository> _mockRepo;
    private readonly Mock<ILogger<PaymentService>> _mockLogger;
    private readonly PaymentService _service;

    public PaymentServiceTests()
    {
        _mockGateway = new Mock<IPaymentGateway>();
        _mockRepo = new Mock<IOrderRepository>();
        _mockLogger = new Mock<ILogger<PaymentService>>();
        _service = new PaymentService(_mockGateway.Object, _mockRepo.Object, _mockLogger.Object);
    }

    [Fact]
    public void ProcessPayment_Success_UpdatesOrderStatus()
    {
        var order = new Order { Total = 100, PaymentMethod = "CreditCard" };
        _mockGateway.Setup(g => g.Charge(100, "CreditCard"))
                    .Returns(new PaymentResult { Success = true });

        _service.ProcessPayment(order);

        Assert.Equal(OrderStatus.Paid, order.Status);
        _mockRepo.Verify(r => r.Save(order), Times.Once);
    }
}

3.3 依赖太多怎么办

// 反模式：构造函数参数太多（通常说明类做了太多事）
public class OrderService
{
    public OrderService(
        IOrderRepository repo,
        IUserRepository userRepo,
        IProductRepository productRepo,
        IEmailService email,
        ISmsService sms,
        IPaymentGateway payment,
        ILogger logger,
        ICacheService cache,
        IConfiguration config)
    {
        // 9 个依赖 → 这个类一定做了太多事
    }
}

// 解决：拆分职责
// OrderValidationService — 验证逻辑
// OrderPricingService   — 定价计算
// OrderNotificationService — 通知
// OrderService           — 编排（只依赖上面几个服务）

四、重构不可测代码

4.1 场景一：方法内部 new 依赖

// 不可测
public class ReportService
{
    public string GenerateReport(int userId)
    {
        var repo = new SqlUserRepository();    // 内部 new，测试无法替换
        var user = repo.GetById(userId);
        return $"报告：{user.Name}";
    }
}

// 重构：通过构造函数注入
public class ReportService
{
    private readonly IUserRepository _repo;

    public ReportService(IUserRepository repo)
    {
        _repo = repo;
    }

    public string GenerateReport(int userId)
    {
        var user = _repo.GetById(userId);
        return $"报告：{user.Name}";
    }
}

// 测试
[Fact]
public void GenerateReport_ReturnsUserName()
{
    var mockRepo = new Mock<IUserRepository>();
    mockRepo.Setup(r => r.GetById(1))
            .Returns(new User { Id = 1, Name = "张三" });

    var service = new ReportService(mockRepo.Object);
    var result = service.GenerateReport(1);

    Assert.Equal("报告：张三", result);
}

4.2 场景二：直接调用静态方法

// 不可测
public class GreetingService
{
    public string GetGreeting(string name)
    {
        var hour = DateTime.Now.Hour;   // 静态调用，无法控制
        var greeting = hour switch
        {
            < 6 => "凌晨好",
            < 12 => "早上好",
            < 18 => "下午好",
            _ => "晚上好"
        };
        return $"{greeting}，{name}";
    }
}

// 重构：注入 TimeProvider（.NET 8 内置）
public class GreetingService
{
    private readonly TimeProvider _timeProvider;

    public GreetingService(TimeProvider timeProvider)
    {
        _timeProvider = timeProvider;
    }

    public string GetGreeting(string name)
    {
        var hour = _timeProvider.GetLocalNow().Hour;
        var greeting = hour switch
        {
            < 6 => "凌晨好",
            < 12 => "早上好",
            < 18 => "下午好",
            _ => "晚上好"
        };
        return $"{greeting}，{name}";
    }
}

// 测试
[Fact]
public void GetGreeting_Morning_ReturnsMorningGreeting()
{
    // 控制时间为早上 9 点
    var mockTime = new Mock<TimeProvider>();
    mockTime.Setup(t => t.GetLocalNow())
            .Returns(new DateTimeOffset(2026, 5, 1, 9, 0, 0, TimeSpan.FromHours(8)));

    var service = new GreetingService(mockTime.Object);
    var result = service.GetGreeting("张三");

    Assert.Equal("早上好，张三", result);
}

4.3 场景三：隐藏的文件操作

// 不可测
public class ConfigLoader
{
    public AppConfig Load()
    {
        var json = File.ReadAllText("config.json");  // 硬编码文件路径
        return JsonSerializer.Deserialize<AppConfig>(json);
    }
}

// 重构方式1：注入路径，测试时指向临时文件
public class ConfigLoader
{
    private readonly string _configPath;

    public ConfigLoader(string configPath)
    {
        _configPath = configPath;
    }

    public AppConfig Load()
    {
        var json = File.ReadAllText(_configPath);
        return JsonSerializer.Deserialize<AppConfig>(json)!;
    }
}

// 重构方式2：注入 Stream（更灵活）
public class ConfigLoader
{
    public AppConfig Load(Stream stream)
    {
        using var reader = new StreamReader(stream);
        var json = reader.ReadToEnd();
        return JsonSerializer.Deserialize<AppConfig>(json)!;
    }
}

// 测试
[Fact]
public void Load_ValidJson_ReturnsConfig()
{
    var json = """{"AppName":"TestApp","Version":"1.0"}""";
    var stream = new MemoryStream(Encoding.UTF8.GetBytes(json));
    var loader = new ConfigLoader();

    var config = loader.Load(stream);

    Assert.Equal("TestApp", config.AppName);
    Assert.Equal("1.0", config.Version);
}

4.4 场景四：静态 HttpClient

// 不可测
public class WeatherService
{
    private static readonly HttpClient _client = new();

    public async Task<string> GetWeatherAsync(string city)
    {
        return await _client.GetStringAsync($"https://api.weather.com?city={city}");
    }
}

// 重构：注入 HttpClient（通过 IHttpClientFactory）
public class WeatherService
{
    private readonly HttpClient _client;

    public WeatherService(HttpClient client)
    {
        _client = client;
    }

    public async Task<string> GetWeatherAsync(string city)
    {
        return await _client.GetStringAsync($"/weather?city={city}");
    }
}

// 测试：用 HttpMessageHandler Mock
public class WeatherServiceTests
{
    [Fact]
    public async Task GetWeatherAsync_ReturnsWeatherData()
    {
        var handler = new MockHttpMessageHandler(
            """{"city":"北京","temp":25}""");
        var client = new HttpClient(handler)
        {
            BaseAddress = new Uri("https://api.weather.com")
        };

        var service = new WeatherService(client);
        var result = await service.GetWeatherAsync("北京");

        Assert.Contains("北京", result);
    }
}

// 辅助类：Mock HttpMessageHandler
public class MockHttpMessageHandler : HttpMessageHandler
{
    private readonly string _response;

    public MockHttpMessageHandler(string response) => _response = response;

    public List<HttpRequestMessage> SentRequests { get; } = new();

    protected override Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken cancellationToken)
    {
        SentRequests.Add(request);
        var response = new HttpResponseMessage(HttpStatusCode.OK)
        {
            Content = new StringContent(_response, Encoding.UTF8, "application/json")
        };
        return Task.FromResult(response);
    }
}

五、工厂模式与多实现选择

5.1 问题：运行时选择不同实现

// 场景：不同租户使用不同的短信服务商
public interface ISmsProvider
{
    string Name { get; }
    Task SendAsync(string phone, string message);
}

public class AliyunSmsProvider : ISmsProvider
{
    public string Name => "aliyun";
    public Task SendAsync(string phone, string message) { /* ... */ }
}

public class TencentSmsProvider : ISmsProvider
{
    public string Name => "tencent";
    public Task SendAsync(string phone, string message) { /* ... */ }
}

5.2 工厂模式

public class SmsProviderFactory
{
    private readonly Dictionary<string, ISmsProvider> _providers;

    public SmsProviderFactory(IEnumerable<ISmsProvider> providers)
    {
        _providers = providers.ToDictionary(p => p.Name);
    }

    public ISmsProvider GetProvider(string name)
    {
        return _providers.TryGetValue(name, out var provider)
            ? provider
            : throw new ArgumentException($"未知的短信服务商：{name}");
    }
}

// 注册
// builder.Services.AddTransient<ISmsProvider, AliyunSmsProvider>();
// builder.Services.AddTransient<ISmsProvider, TencentSmsProvider>();
// builder.Services.AddTransient<SmsProviderFactory>();

5.3 使用和测试

public class SmsService
{
    private readonly SmsProviderFactory _factory;

    public SmsService(SmsProviderFactory factory)
    {
        _factory = factory;
    }

    public Task SendAsync(string tenantId, string phone, string message)
    {
        var providerName = GetProviderNameForTenant(tenantId);
        var provider = _factory.GetProvider(providerName);
        return provider.SendAsync(phone, message);
    }

    private string GetProviderNameForTenant(string tenantId) => /* 从配置读取 */;
}

// 测试
[Fact]
public async Task SendAsync_UsesCorrectProvider()
{
    var mockAliyun = new Mock<ISmsProvider>();
    mockAliyun.SetupGet(p => p.Name).Returns("aliyun");

    var mockTencent = new Mock<ISmsProvider>();
    mockTencent.SetupGet(p => p.Name).Returns("tencent");

    var factory = new SmsProviderFactory(new[] { mockAliyun.Object, mockTencent.Object });
    var service = new SmsService(factory);

    await service.SendAsync("tenant-aliyun", "13800138000", "验证码");

    mockAliyun.Verify(p => p.SendAsync("13800138000", "验证码"), Times.Once);
    mockTencent.Verify(p => p.SendAsync(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
}

六、DI 容器在测试中的角色

6.1 单元测试不用 DI 容器

// 单元测试：手动创建和注入
[Fact]
public void Test()
{
    var mockRepo = new Mock<IUserRepository>();
    var mockEmail = new Mock<IEmailService>();
    var service = new UserService(mockRepo.Object, mockEmail.Object);

    // 直接测试
}

// 不要在单元测试中用 ServiceCollection
// 那是集成测试的事

6.2 集成测试可以用 DI 容器

// 集成测试：用真实的 DI 容器，替换部分依赖
public class IntegrationTests
{
    private readonly IServiceProvider _services;

    public IntegrationTests()
    {
        var services = new ServiceCollection();
        services.AddMyAppServices(); // 注册生产代码的服务

        // 替换外部依赖为 Mock
        services.AddScoped<IEmailService>(_ =>
        {
            var mock = new Mock<IEmailService>();
            return mock.Object;
        });

        _services = services.BuildServiceProvider();
    }
}

七、设计模式与可测试性

7.1 策略模式

// 不同折扣策略
public interface IDiscountStrategy
{
    decimal Calculate(decimal total);
}

public class NoDiscount : IDiscountStrategy
{
    public decimal Calculate(decimal total) => 0;
}

public class PercentDiscount : IDiscountStrategy
{
    private readonly decimal _percent;
    public PercentDiscount(decimal percent) => _percent = percent;
    public decimal Calculate(decimal total) => total * _percent;
}

public class FixedDiscount : IDiscountStrategy
{
    private readonly decimal _amount;
    public FixedDiscount(decimal amount) => _amount = amount;
    public decimal Calculate(decimal total) => Math.Min(_amount, total);
}

// 使用
public class PricingService
{
    private readonly IDiscountStrategy _discount;

    public PricingService(IDiscountStrategy discount) => _discount = discount;

    public decimal GetFinalPrice(decimal total) => total - _discount.Calculate(total);
}

// 测试
[Fact]
public void GetFinalPrice_WithPercentDiscount()
{
    var service = new PricingService(new PercentDiscount(0.2m));
    Assert.Equal(80m, service.GetFinalPrice(100m));
}

7.2 模板方法模式

public abstract class DataProcessor
{
    public ProcessResult Process(string input)
    {
        var validated = Validate(input);
        var transformed = Transform(validated);
        var result = Save(transformed);
        return result;
    }

    protected abstract string Validate(string input);
    protected abstract string Transform(string input);
    protected abstract ProcessResult Save(string data);
}

// 测试具体实现
public class TestableDataProcessor : DataProcessor
{
    public Func<string, string> ValidateFn { get; set; } = s => s;
    public Func<string, string> TransformFn { get; set; } = s => s;
    public Func<string, ProcessResult> SaveFn { get; set; } = _ => new ProcessResult { Success = true };

    protected override string Validate(string input) => ValidateFn(input);
    protected override string Transform(string input) => TransformFn(input);
    protected override ProcessResult Save(string data) => SaveFn(data);
}

八、可测试性检查清单

依赖注入：
  □ 所有外部依赖通过构造函数注入
  □ 不在方法内部 new 具体实现
  □ 依赖接口不依赖具体类

静态依赖：
  □ DateTime.Now → TimeProvider
  □ File/Directory → 注入路径或 Stream
  □ HttpClient → IHttpClientFactory 或注入 HttpClient
  □ Console → 注入 TextWriter
  □ Environment → 注入或包装

设计原则：
  □ 单一职责（一个类做一件事）
  □ 方法短小（一个方法做一件事）
  □ 接口小而专注
  □ 避免上帝类和上帝方法

可测试代码特征：
  □ 可以控制所有输入
  □ 可以观察所有输出
  □ 可以隔离外部依赖
  □ 每次运行结果一致

九、小结

本文学习了依赖注入与可测试性：

可测试性原则和依赖倒置
接口设计和命名
构造函数注入模式
重构不可测代码（4 个实战场景）
工厂模式与多实现选择
DI 容器在测试中的角色
设计模式提升可测试性

下一篇将逐个击破常见的难测场景：数据库、HTTP、时间、文件系统等。

.NET 单元测试（三）：Mock 与隔离

Sun, 17 May 2026 10:00:00 +0800

写在前面

本文是 .NET 单元测试系列的第三篇，介绍如何使用 Mock 隔离外部依赖，让测试只关注业务逻辑。前置知识：xUnit 进阶（第二篇）。

一、为什么要隔离

1.1 问题场景

// 一个依赖数据库和邮件的服务
public class OrderService
{
    private readonly IOrderRepository _repo;
    private readonly IEmailService _email;

    public OrderService(IOrderRepository repo, IEmailService email)
    {
        _repo = repo;
        _email = email;
    }

    public OrderResult CreateOrder(Order order)
    {
        // 业务逻辑
        if (order.Items.Count == 0)
            throw new ArgumentException("订单不能为空");

        order.Total = order.Items.Sum(i => i.Price * i.Quantity);
        order.CreatedAt = DateTime.UtcNow;

        // 依赖1：保存到数据库
        _repo.Save(order);

        // 依赖2：发送邮件
        _email.SendOrderConfirmation(order);

        return new OrderResult { Success = true, OrderId = order.Id };
    }
}

如果不隔离依赖：
- 测试需要真实数据库 → 慢、不稳定、难搭建
- 测试需要真实邮件服务 → 会发垃圾邮件
- 数据库挂了测试就挂了 → 不是业务逻辑的问题
- 无法模拟异常场景 → 数据库超时怎么测？

1.2 隔离的好处

快速       — 不需要真实的外部服务
稳定       — 不受外部环境影响
可控       — 可以模拟任何场景（成功、失败、超时）
聚焦       — 只测业务逻辑，不测依赖

二、Test Double 分类

2.1 四种 Test Double

Stub（桩）    — 提供预设的返回值，让测试能跑下去
Mock（模拟）  — 验证交互行为（是否调用了？调了几次？参数对不对？）
Fake（伪造）  — 有真实逻辑的轻量实现（如内存数据库）
Spy（间谍）   — 记录调用信息，同时使用真实逻辑

2.2 举例说明

// 接口定义
public interface IOrderRepository
{
    Order GetById(int id);
    void Save(Order order);
}

// Stub — 只要返回数据，让测试能继续
// "调用 GetById(1) 就返回这个 Order"
// 不关心是否真的调用了

// Mock — 验证行为
// "我预期 Save 方法被调用了一次，参数是这个 order"
// 如果没调用或者参数不对 → 测试失败

// Fake — 真实但轻量的实现
public class FakeOrderRepository : IOrderRepository
{
    private readonly Dictionary<int, Order> _orders = new();

    public Order GetById(int id) => _orders.GetValueOrDefault(id);
    public void Save(Order order) => _orders[order.Id] = order;
}

// Spy — 记录 + 真实逻辑
public class SpyEmailService : IEmailService
{
    public List<string> SentEmails { get; } = new();

    public void SendOrderConfirmation(Order order)
    {
        SentEmails.Add(order.CustomerEmail); // 记录
        // 实际不发送，但做了真实逻辑
    }
}

2.3 什么时候用什么

只需要返回值             → Stub
需要验证是否调用了       → Mock
需要轻量级替代实现       → Fake
需要记录调用但保留逻辑   → Spy

三、Moq 框架详解

Moq 是 .NET 最流行的 Mock 框架。

3.1 安装

`1`	`dotnet add package Moq`

3.2 基本 Setup（Stub 行为）

[Fact]
public void GetUser_ExistingId_ReturnsUser()
{
    // Arrange
    var mockRepo = new Mock<IUserRepository>();

    // Setup：当调用 GetById(1) 时返回这个 User
    mockRepo.Setup(r => r.GetById(1))
            .Returns(new User { Id = 1, Name = "张三" });

    var service = new UserService(mockRepo.Object);

    // Act
    var result = service.GetUser(1);

    // Assert
    Assert.Equal("张三", result.Name);
}

3.3 参数匹配

// 精确匹配
mockRepo.Setup(r => r.GetById(42)).Returns(user42);

// 任意参数
mockRepo.Setup(r => r.GetById(It.IsAny<int>())).Returns(user);

// 条件匹配
mockRepo.Setup(r => r.GetById(It.Is<int>(id => id > 0)))
        .Returns(user);

// 范围匹配
mockRepo.Setup(r => r.GetUsers(It.IsInRange(1, 100, Range.Inclusive)))
        .Returns(users);

// 正则匹配（字符串）
mockRepo.Setup(r => r.FindByName(It.IsRegex("^张")))
        .Returns(users);

// 空值匹配
mockRepo.Setup(r => r.FindByName(It.IsNull<string>()))
        .Throws<ArgumentException>();

3.4 返回值

// 固定返回值
mockRepo.Setup(r => r.GetById(1)).Returns(user);

// 动态返回值（根据参数计算）
mockRepo.Setup(r => r.GetById(It.IsAny<int>()))
        .Returns<int>(id => new User { Id = id, Name = $"用户{id}" });

// 返回 Task（异步方法）
mockRepo.Setup(r => r.GetByIdAsync(1))
        .ReturnsAsync(user);

// 返回 ValueTask
mockRepo.Setup(r => r.GetByIdAsync(1))
        .Returns(new ValueTask<User>(user));

3.5 验证行为（Mock 行为）

[Fact]
public void CreateOrder_SavesToRepo()
{
    // Arrange
    var mockRepo = new Mock<IOrderRepository>();
    var mockEmail = new Mock<IEmailService>();
    var service = new OrderService(mockRepo.Object, mockEmail.Object);
    var order = new Order { Items = new List<OrderItem> { new() } };

    // Act
    service.CreateOrder(order);

    // Assert — 验证 Save 被调用了一次
    mockRepo.Verify(r => r.Save(It.IsAny<Order>()), Times.Once);
}

[Fact]
public void CreateOrder_SendsEmail()
{
    var mockRepo = new Mock<IOrderRepository>();
    var mockEmail = new Mock<IEmailService>();
    var service = new OrderService(mockRepo.Object, mockEmail.Object);
    var order = new Order
    {
        CustomerEmail = "test@example.com",
        Items = new List<OrderItem> { new() }
    };

    service.CreateOrder(order);

    // 验证邮件发送的参数
    mockEmail.Verify(
        e => e.SendOrderConfirmation(
            It.Is<Order>(o => o.CustomerEmail == "test@example.com")),
        Times.Once);
}

3.6 Verify 的 Times 选项

mockRepo.Verify(r => r.Save(order), Times.Once);       // 恰好一次
mockRepo.Verify(r => r.Save(order), Times.Never);      // 没调用过
mockRepo.Verify(r => r.Save(order), Times.Exactly(3)); // 恰好三次
mockRepo.Verify(r => r.Save(order), Times.AtLeast(2)); // 至少两次
mockRepo.Verify(r => r.Save(order), Times.AtMost(5));  // 最多五次

3.7 Callback — 捕获参数和副作用

[Fact]
public void CreateOrder_SetsCreatedAtBeforeSaving()
{
    var mockRepo = new Mock<IOrderRepository>();
    var mockEmail = new Mock<IEmailService>();
    var service = new OrderService(mockRepo.Object, mockEmail.Object);

    Order? savedOrder = null;
    mockRepo.Setup(r => r.Save(It.IsAny<Order>()))
            .Callback<Order>(o => savedOrder = o);  // 捕获保存的 Order

    var order = new Order { Items = new List<OrderItem> { new() } };
    service.CreateOrder(order);

    // 验证保存前设置了 CreatedAt
    Assert.NotNull(savedOrder);
    Assert.True(savedOrder.CreatedAt <= DateTime.UtcNow);
}

3.8 Throws — 模拟异常

[Fact]
public void CreateOrder_DatabaseDown_ThrowsException()
{
    var mockRepo = new Mock<IOrderRepository>();
    mockRepo.Setup(r => r.Save(It.IsAny<Order>()))
            .Throws(new SQLException("连接超时"));

    var mockEmail = new Mock<IEmailService>();
    var service = new OrderService(mockRepo.Object, mockEmail.Object);

    Assert.Throws<SQLException>(
        () => service.CreateOrder(new Order { Items = new List<OrderItem> { new() } }));
}

[Fact]
public async Task GetUserAsync_Timeout_ThrowsException()
{
    var mockRepo = new Mock<IUserRepository>();
    mockRepo.Setup(r => r.GetByIdAsync(It.IsAny<int>()))
            .ThrowsAsync(new TimeoutException("请求超时"));

    var service = new UserService(mockRepo.Object);

    await Assert.ThrowsAsync<TimeoutException>(
        () => service.GetUserAsync(1));
}

3.9 属性 Mock

// 自动实现所有属性（StubProperties）
var mock = new Mock<IOptions<DatabaseSettings>>();
mock.SetupGet(o => o.Value).Returns(new DatabaseSettings
{
    ConnectionString = "Server=.;Database=Test"
});

// 或者
var mockOptions = new Mock<IOptions<DatabaseSettings>>();
mockOptions.Setup(o => o.Value).Returns(new DatabaseSettings
{
    ConnectionString = "Test"
});

3.10 Loose vs Strict Mock

// Loose（默认）— 没有 Setup 的方法返回默认值（null、0、false）
var looseMock = new Mock<IUserRepository>();
looseMock.Object.GetById(1); // 返回 null，不报错

// Strict — 没有 Setup 的方法被调用时抛异常
var strictMock = new Mock<IUserRepository>(MockBehavior.Strict);
strictMock.Object.GetById(1); // 抛出 MockException！

// Strict 适合：确保测试明确声明了所有预期行为
// Loose 适合：只关心部分方法，其他忽略

3.11 VerifyAll 和 VerifyNoOtherCalls

[Fact]
public void CreateOrder_AllInteractionsVerified()
{
    var mockRepo = new Mock<IOrderRepository>(MockBehavior.Strict);
    var mockEmail = new Mock<IEmailService>(MockBehavior.Strict);
    var service = new OrderService(mockRepo.Object, mockEmail.Object);

    // Setup 所有预期行为
    mockRepo.Setup(r => r.Save(It.IsAny<Order>()));
    mockEmail.Setup(e => e.SendOrderConfirmation(It.IsAny<Order>()));

    service.CreateOrder(new Order { Items = new List<OrderItem> { new() } });

    // 验证所有 Setup 都被调用了
    mockRepo.VerifyAll();
    mockEmail.VerifyAll();

    // 验证没有其他未预期的调用
    mockRepo.VerifyNoOtherCalls();
    mockEmail.VerifyNoOtherCalls();
}

四、Mock 的实战示例

4.1 完整的 Service 测试

public class OrderServiceTests
{
    private readonly Mock<IOrderRepository> _mockRepo;
    private readonly Mock<IEmailService> _mockEmail;
    private readonly Mock<ILogger<OrderService>> _mockLogger;
    private readonly OrderService _service;

    public OrderServiceTests()
    {
        _mockRepo = new Mock<IOrderRepository>();
        _mockEmail = new Mock<IEmailService>();
        _mockLogger = new Mock<ILogger<OrderService>>();
        _service = new OrderService(_mockRepo.Object, _mockEmail.Object, _mockLogger.Object);
    }

    [Fact]
    public void CreateOrder_ValidOrder_SavesAndSendsEmail()
    {
        var order = new Order
        {
            CustomerEmail = "test@example.com",
            Items = new List<OrderItem>
            {
                new() { Price = 100, Quantity = 2 }
            }
        };

        var result = _service.CreateOrder(order);

        Assert.True(result.Success);
        Assert.Equal(200, order.Total); // 100 * 2

        _mockRepo.Verify(r => r.Save(It.Is<Order>(
            o => o.Total == 200)), Times.Once);
        _mockEmail.Verify(e => e.SendOrderConfirmation(
            It.IsAny<Order>()), Times.Once);
    }

    [Fact]
    public void CreateOrder_EmptyItems_ThrowsException()
    {
        var order = new Order { Items = new List<OrderItem>() };

        var ex = Assert.Throws<ArgumentException>(
            () => _service.CreateOrder(order));

        Assert.Equal("订单不能为空", ex.Message);

        // 确保没有保存和发邮件
        _mockRepo.Verify(r => r.Save(It.IsAny<Order>()), Times.Never);
        _mockEmail.Verify(e => e.SendOrderConfirmation(It.IsAny<Order>()), Times.Never);
    }

    [Fact]
    public void CreateOrder_EmailFails_StillSavesOrder()
    {
        var order = new Order
        {
            CustomerEmail = "test@example.com",
            Items = new List<OrderItem> { new() { Price = 50, Quantity = 1 } }
        };

        // 邮件发送失败
        _mockEmail.Setup(e => e.SendOrderConfirmation(It.IsAny<Order>()))
                  .Throws(new SmtpException("邮件服务器不可用"));

        // 不应该影响订单保存
        var result = _service.CreateOrder(order);

        Assert.True(result.Success);
        _mockRepo.Verify(r => r.Save(It.IsAny<Order>()), Times.Once);
    }
}

4.2 Mock ILogger

// ILogger 的 Log 方法参数复杂，直接 Mock 很麻烦
// 推荐用扩展方法验证

public static class LoggerExtensions
{
    public static void VerifyLog<T>(
        this Mock<ILogger<T>> logger,
        LogLevel level,
        string message,
        Times times)
    {
        logger.Verify(
            x => x.Log(
                level,
                It.IsAny<EventId>(),
                It.Is<It.IsAnyType>((v, _) => v.ToString()!.Contains(message)),
                It.IsAny<Exception?>(),
                It.IsAny<Func<It.IsAnyType, Exception?, string>>()),
            times);
    }
}

// 使用
[Fact]
public void CreateOrder_LogsInfo()
{
    _service.CreateOrder(new Order { Items = new List<OrderItem> { new() } });

    _mockLogger.VerifyLog(
        LogLevel.Information,
        "订单已创建",
        Times.Once);
}

五、常见 Mock 反模式

5.1 过度 Mock

// 反模式：Mock 所有东西
[Fact]
public void Bad_OverMocking()
{
    var mockMapper = new Mock<IMapper>();
    var mockValidator = new Mock<IValidator<Order>>();
    var mockCalculator = new Mock<IPriceCalculator>();
    var mockRepo = new Mock<IOrderRepository>();
    var mockEmail = new Mock<IEmailService>();
    var mockLogger = new Mock<ILogger<OrderService>>();

    // 全是 Mock，测试的是 Mock 之间的交互，不是业务逻辑
    // 这种测试价值很低
}

// 好的做法：只 Mock 外部依赖，内部逻辑用真实对象
[Fact]
public void Good_MockOnlyExternalDeps()
{
    // 内部逻辑用真实对象
    var validator = new OrderValidator();
    var calculator = new PriceCalculator();

    // 只 Mock 外部依赖
    var mockRepo = new Mock<IOrderRepository>();
    var mockEmail = new Mock<IEmailService>();

    var service = new OrderService(validator, calculator, mockRepo.Object, mockEmail.Object);
}

5.2 Mock 被测类本身

// 反模式：Mock 被测类的方法
[Fact]
public void Bad_MockSystemUnderTest()
{
    var mockService = new Mock<OrderService> { CallBase = true };
    mockService.Setup(s => s.ValidateOrder(It.IsAny<Order>()))
               .Returns(true); // 跳过了验证逻辑

    // 你在测 Mock，不是测真正的代码
}

// 好的做法：直接实例化被测类
[Fact]
public void Good_TestRealImplementation()
{
    var service = new OrderService(repo, email);
    // 测试真实行为
}

5.3 验证实现细节

// 反模式：验证内部实现
[Fact]
public void Bad_VerifyInternalDetails()
{
    service.CreateOrder(order);

    // 谁关心你先调 Save 还是先发邮件？
    mockRepo.Verify(r => r.Save(It.IsAny<Order>()), Times.Once);
    mockEmail.Verify(e => e.SendOrderConfirmation(It.IsAny<Order>()), Times.Once);
    // 顺序验证更过分
}

// 好的做法：只验证可观察的行为（结果）
[Fact]
public void Good_VerifyObservableResult()
{
    var result = service.CreateOrder(order);

    Assert.True(result.Success);
    Assert.NotEqual(Guid.Empty, result.OrderId);
}

六、NSubstitute（替代方案）

如果你觉得 Moq 的 Setup/Verify 语法太繁琐，可以试试 NSubstitute。

6.1 安装

`1`	`dotnet add package NSubstitute`

6.2 对比 Moq

// Moq
var mockRepo = new Mock<IUserRepository>();
mockRepo.Setup(r => r.GetById(1)).Returns(user);
mockRepo.Verify(r => r.Save(It.IsAny<User>()), Times.Once);

// NSubstitute
var repo = Substitute.For<IUserRepository>();
repo.GetById(1).Returns(user);
repo.Received(1).Save(Arg.Any<User>());

6.3 常用语法

// 返回值
repo.GetById(1).Returns(user);
repo.GetAll().Returns(new List<User> { user1, user2 });

// 异步返回
repo.GetByIdAsync(1).Returns(user);

// 参数匹配
repo.FindByName(Arg.Is<string>(n => n.StartsWith("张"))).Returns(users);
repo.FindByName(Arg.Any<string>()).Returns(users);

// 验证调用
repo.Received().Save(Arg.Any<User>());       // 被调用了
repo.DidNotReceive().Delete(Arg.Any<int>()); // 没被调用
repo.Received(2).Save(Arg.Any<User>());      // 被调用了2次

// 抛异常
repo.When(r => r.Save(null!)).Throw<ArgumentNullException>();

// 事件
repo.UserAdded += Raise.Event<UserEventHandler>(user);

6.4 选择建议

Moq           — 最主流，社区资料多，功能最全
NSubstitute   — 语法更简洁，学习曲线低
两者都能完成任务，选团队熟悉的即可
本系列后续使用 Moq

七、小结

本文学习了 Mock 与隔离：

为什么需要隔离外部依赖
Test Double 分类（Stub、Mock、Fake、Spy）
Moq 框架详解（Setup、Verify、Callback、Throws）
实战示例和 Mock ILogger
Mock 反模式（过度 Mock、Mock 被测类、验证实现细节）
NSubstitute 简介和选择建议

下一篇将学习依赖注入与可测试性：如何设计代码让它容易测试。

.NET 单元测试（二）：xUnit 进阶

Sat, 16 May 2026 10:00:00 +0800

写在前面

本文是 .NET 单元测试系列的第二篇，深入 xUnit 的高级特性：数据驱动测试、共享上下文、并行控制和自定义扩展。前置知识：单元测试基础（第一篇）。

一、数据驱动测试

上一篇的 [Fact] 只能测固定数据。当你需要用多组数据验证同一个逻辑时，用 [Theory]。

1.1 InlineData — 少量固定数据

[Theory]
[InlineData(1, 2, 3)]
[InlineData(0, 0, 0)]
[InlineData(-1, 1, 0)]
[InlineData(100, 200, 300)]
public void Add_TwoNumbers_ReturnsSum(int a, int b, int expected)
{
    var calculator = new Calculator();
    var result = calculator.Add(a, b);

    Assert.Equal(expected, result);
}

1
2
3

优势：一个测试方法覆盖多组数据
每个 [InlineData] 生成一个独立的测试用例
测试资源管理器中可以看到每组数据

1.2 MemberData — 从属性/方法获取数据

public static IEnumerable<object[]> AdditionData =>
    new List<object[]>
    {
        new object[] { 1, 2, 3 },
        new object[] { -1, 1, 0 },
        new object[] { 100, 200, 300 },
        new object[] { int.MaxValue, 0, int.MaxValue },
    };

[Theory]
[MemberData(nameof(AdditionData))]
public void Add_TwoNumbers_ReturnsSum(int a, int b, int expected)
{
    var calculator = new Calculator();
    var result = calculator.Add(a, b);

    Assert.Equal(expected, result);
}

1.3 MemberData 从其他类获取

// 集中管理测试数据
public static class CalculatorTestData
{
    public static IEnumerable<object[]> DivisionData =>
        new List<object[]>
        {
            new object[] { 10, 2, 5.0 },
            new object[] { 9, 3, 3.0 },
            new object[] { 7, 2, 3.5 },
            new object[] { -10, 2, -5.0 },
        };

    public static IEnumerable<object[]> EdgeCaseData =>
        new List<object[]>
        {
            new object[] { 0, 1, 0.0 },
            new object[] { 1, 1, 1.0 },
        };
}

[Theory]
[MemberData(nameof(CalculatorTestData.DivisionData), MemberType = typeof(CalculatorTestData))]
[MemberData(nameof(CalculatorTestData.EdgeCaseData), MemberType = typeof(CalculatorTestData))]
public void Divide_TwoNumbers_ReturnsQuotient(int a, int b, double expected)
{
    var calculator = new Calculator();
    var result = calculator.Divide(a, b);

    Assert.Equal(expected, result);
}

1.4 ClassData — 从类获取数据

public class AdditionTestData : IEnumerable<object[]>
{
    public IEnumerator<object[]> GetEnumerator()
    {
        yield return new object[] { 1, 2, 3 };
        yield return new object[] { -1, 1, 0 };
        yield return new object[] { 100, 200, 300 };
    }

    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

[Theory]
[ClassData(typeof(AdditionTestData))]
public void Add_TwoNumbers_ReturnsSum(int a, int b, int expected)
{
    var calculator = new Calculator();
    Assert.Equal(expected, calculator.Add(a, b));
}

1.5 TheoryData — 强类型数据

// TheoryData<T1, T2, ...> 提供类型安全
public static TheoryData<string, int, bool> UserValidationData =>
    new()
    {
        { "张三", 25, true },          // 正常
        { "", 25, false },             // 名字为空
        { null!, 25, false },          // 名字为 null
        { "李四", 17, false },         // 未成年
        { "王五", 150, false },        // 年龄不合理
    };

[Theory]
[MemberData(nameof(UserValidationData))]
public void ValidateUser_VariousInputs_ReturnsExpected(
    string name, int age, bool expected)
{
    var result = UserValidator.Validate(name, age);
    Assert.Equal(expected, result);
}

1.6 自定义 DataAttribute — 从数据库/CSV/JSON 加载

// 从 CSV 文件加载测试数据
[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public class CsvDataAttribute : DataAttribute
{
    private readonly string _filePath;

    public CsvDataAttribute(string filePath) => _filePath = filePath;

    public override IEnumerable<object[]> GetData(MethodInfo testMethod)
    {
        var lines = File.ReadAllLines(_filePath);
        foreach (var line in lines.Skip(1)) // 跳过标题行
        {
            var parts = line.Split(',');
            yield return parts.Select(p => (object)int.Parse(p)).ToArray();
        }
    }
}

[Theory]
[CsvData("TestData/addition.csv")]
public void Add_FromCsv_ReturnsSum(int a, int b, int expected)
{
    Assert.Equal(expected, new Calculator().Add(a, b));
}

1.7 数据驱动测试的选择

InlineData    — 3-5 组简单数据，直接写在方法上
MemberData    — 中等数量，需要代码生成或复用
ClassData     — 大量数据，需要复杂初始化逻辑
TheoryData    — 强类型，编译期检查
自定义         — 从文件/数据库加载（慎用，测试不应依赖外部）

二、共享上下文

测试经常需要共享昂贵的资源（数据库连接、文件系统、大对象）。xUnit 提供了三种级别的共享。

2.1 三种共享级别

1
2
3

无共享（默认）         — 每个测试方法创建新的测试类实例
ClassFixture           — 同一个测试类中所有测试共享一个实例
CollectionFixture      — 多个测试类共享一个实例

2.2 默认行为（无共享）

// xUnit 默认：每个 [Fact] 方法执行前都会 new 一个新的测试类实例
// 这保证了测试之间完全隔离

public class ExampleTests
{
    private int _counter = 0;  // 每个测试方法看到的是不同的实例

    [Fact]
    public void Test1() => Assert.Equal(0, _counter++);

    [Fact]
    public void Test2() => Assert.Equal(0, _counter++);  // 也是 0，不是 1
}

2.3 ClassFixture — 类级别共享

适用于：创建代价大但只读的共享对象。

// 1. 定义 Fixture
public class DatabaseFixture : IDisposable
{
    public SqlConnection Connection { get; }

    public DatabaseFixture()
    {
        // 所有测试方法执行前，只执行一次
        Connection = new SqlConnection("Server=.;Database=TestDb;Trusted_Connection=true;");
        Connection.Open();

        // 初始化测试数据
        InitTestData();
    }

    private void InitTestData()
    {
        using var cmd = Connection.CreateCommand();
        cmd.CommandText = "INSERT INTO Users (Name, Age) VALUES ('测试用户', 25)";
        cmd.ExecuteNonQuery();
    }

    public void Dispose()
    {
        // 所有测试方法执行完后，清理资源
        Connection?.Dispose();
    }
}

// 2. 测试类实现 IClassFixture<T>
public class UserRepositoryTests : IClassFixture<DatabaseFixture>
{
    private readonly DatabaseFixture _fixture;

    public UserRepositoryTests(DatabaseFixture fixture)
    {
        _fixture = fixture;  // 通过构造函数注入
    }

    [Fact]
    public void GetUserById_ExistingUser_ReturnsUser()
    {
        var repo = new UserRepository(_fixture.Connection);
        var user = repo.GetById(1);

        Assert.NotNull(user);
        Assert.Equal("测试用户", user.Name);
    }

    [Fact]
    public void GetAll_ReturnsUsers()
    {
        var repo = new UserRepository(_fixture.Connection);
        var users = repo.GetAll();

        Assert.NotEmpty(users);
    }
}

2.4 CollectionFixture — 集合级别共享

适用于：多个测试类需要共享同一个 Fixture。

// 1. 定义 Fixture
public class SharedContext : IDisposable
{
    public StringWriter LogOutput { get; }

    public SharedContext()
    {
        LogOutput = new StringWriter();
    }

    public void Dispose()
    {
        LogOutput?.Dispose();
    }
}

// 2. 定义 Collection Definition（注意不能有构造函数）
[CollectionDefinition("SharedContextCollection")]
public class SharedContextCollection : ICollectionFixture<SharedContext>
{
    // 空类，只用来标记 Collection 名称
}

// 3. 使用 Collection 的测试类
[Collection("SharedContextCollection")]
public class OrderServiceTests
{
    private readonly SharedContext _context;

    public OrderServiceTests(SharedContext context)
    {
        _context = context;
    }

    [Fact]
    public void CreateOrder_WritesLog()
    {
        var service = new OrderService(_context.LogOutput);
        service.CreateOrder(new Order());

        Assert.Contains("订单已创建", _context.LogOutput.ToString());
    }
}

[Collection("SharedContextCollection")]
public class PaymentServiceTests
{
    private readonly SharedContext _context;

    public PaymentServiceTests(SharedContext context)
    {
        _context = context;
    }

    [Fact]
    public void ProcessPayment_WritesLog()
    {
        var service = new PaymentService(_context.LogOutput);
        service.ProcessPayment(new Payment());

        Assert.Contains("支付已处理", _context.LogOutput.ToString());
    }
}

2.5 共享级别选择

1
2
3

不需要共享          → 默认行为（最简单，最安全）
同一类中共享        → ClassFixture
跨多个类共享        → CollectionFixture

三、构造函数和 Dispose

3.1 构造函数 = TestInitialize

public class UserServiceTests : IDisposable
{
    private readonly UserService _service;
    private readonly string _testDir;

    public UserServiceTests()
    {
        // 每个测试方法执行前都会调用
        _testDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
        Directory.CreateDirectory(_testDir);
        _service = new UserService(_testDir);
    }

    [Fact]
    public void SaveUser_CreatesFile()
    {
        _service.SaveUser(new User { Name = "张三" });

        Assert.True(File.Exists(Path.Combine(_testDir, "张三.json")));
    }

    [Fact]
    public void LoadUser_ReturnsSavedUser()
    {
        _service.SaveUser(new User { Name = "张三", Age = 25 });
        var user = _service.LoadUser("张三");

        Assert.Equal(25, user.Age);
    }

    public void Dispose()
    {
        // 每个测试方法执行后都会调用
        if (Directory.Exists(_testDir))
            Directory.Delete(_testDir, true);
    }
}

3.2 生命周期总结

xUnit 生命周期：
┌──────────────────────────────────┐
│ ClassFixture 构造函数（一次）      │
│ ┌──────────────────────────────┐ │
│ │ 测试类构造函数（每个方法前）   │ │
│ │ 执行测试方法                  │ │
│ │ 测试类 Dispose（每个方法后）  │ │
│ └──────────────────────────────┘ │
│ ClassFixture Dispose（一次）      │
└──────────────────────────────────┘

四、并行测试

4.1 xUnit 并行策略

默认行为：
- 不同测试类并行执行
- 同一测试类内串行执行
- 同一 Collection 内串行执行

4.2 控制并行

// 程序集级别：禁止并行
[assembly: CollectionBehavior(DisableTestParallelization = true)]

// 程序集级别：设置最大并行度
[assembly: CollectionBehavior(MaxParallelThreads = 4)]

// 类级别：禁止并行（测试类内串行）
// 默认就是串行，不需要额外设置

// 标记不互相干扰的测试类可以并行
[Collection("Sequential")]
public class TestClass1 { }

[Collection("Sequential")]
public class TestClass2 { }
// 同一个 Collection 的测试类不会并行执行

4.3 并行测试注意事项

1. 测试之间不能有共享可变状态
2. 不要依赖文件系统的固定路径
3. 不要依赖数据库的固定数据
4. 需要并行的测试类不要放在同一个 Collection

五、跳过测试

5.1 条件跳过

[Fact(Skip = "Bug #123 未修复，暂时跳过")]
public void BrokenTest()
{
    // 这个测试不会运行
}

[Fact]
public void OnlyOnWindows()
{
    if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
        return; // 或者用 Skip

    // Windows 专属测试
}

5.2 条件编译

// 只在 Debug 模式下运行
[Fact]
public void DebugOnlyTest()
{
#if DEBUG
    // 测试代码
#else
    Assert.True(true); // Release 模式下直接通过
#endif
}

六、自定义 xUnit 扩展

6.1 自定义 FactAttribute

// 只在特定条件下运行测试
public class WindowsOnlyFactAttribute : FactAttribute
{
    public WindowsOnlyFactAttribute()
    {
        if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            Skip = "只在 Windows 上运行";
    }
}

// 使用
[WindowsOnlyFact]
public void RegistryTest()
{
    // Windows 专属测试
}

6.2 自定义 TheoryAttribute

// 只在 CI 环境运行
public class CiOnlyTheoryAttribute : TheoryAttribute
{
    public CiOnlyTheoryAttribute()
    {
        if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable("CI")))
            Skip = "只在 CI 环境运行";
    }
}

七、FluentAssertions（可选增强）

虽然 xUnit 自带的 Assert 够用，但 FluentAssertions 让断言更易读。

7.1 安装

`1`	`dotnet add package FluentAssertions`

7.2 使用对比

// xUnit 原生
Assert.Equal(5, result);
Assert.True(list.Contains(3));
Assert.Throws<ArgumentException>(() => method());

// FluentAssertions
result.Should().Be(5);
list.Should().Contain(3);
Action act = () => method();
act.Should().Throw<ArgumentException>();

7.3 更多示例

// 字符串
name.Should().StartWith("张").And.EndWith("三");
name.Should().NotBeNullOrEmpty();

// 集合
numbers.Should().HaveCount(5).And.ContainInOrder(1, 2, 3);
numbers.Should().OnlyContain(n => n > 0);
numbers.Should().BeInAscendingOrder();

// 异常
var act = () => calculator.Divide(10, 0);
act.Should().Throw<DivideByZeroException>()
   .WithMessage("除数不能为零*");

// 对象
user.Should().BeEquivalentTo(new { Name = "张三", Age = 25 });

// 日期
date.Should().BeCloseTo(DateTime.Now, TimeSpan.FromSeconds(1));

八、小结

本文学习了 xUnit 的进阶特性：

数据驱动测试（Theory + InlineData/MemberData/ClassData/TheoryData）
共享上下文（ClassFixture、CollectionFixture）
测试生命周期（构造函数、Dispose）
并行测试控制
自定义扩展
FluentAssertions 增强

下一篇将学习 Mock 与隔离：如何隔离外部依赖，专注测试业务逻辑。

.NET 单元测试（一）：基础入门

Fri, 15 May 2026 10:00:00 +0800

写在前面

本文是 .NET 单元测试系列的第一篇，介绍单元测试的基本概念和 xUnit 框架入门。无论你之前有没有写过测试，读完这篇都能开始动手写。

一、什么是单元测试

1.1 定义

单元测试是对软件中最小可测试单元（通常是一个方法）进行验证的自动化测试。

核心特征：
1. 自动化 — 不需要人工干预，一条命令就能跑
2. 快速 — 毫秒级完成，不能依赖外部服务
3. 隔离 — 只测试目标方法，不连带测试依赖项
4. 可重复 — 每次运行结果一致
5. 自我检查 — 不需要人工判断结果对不对

1.2 为什么要写单元测试

尽早发现 Bug          — 写代码时就能发现问题，不是等到测试同学提
重构的安全网           — 有测试在，改代码不怕改坏
文档作用              — 测试用例就是最好的使用文档
设计反馈              — 难写的测试说明代码设计有问题
提升信心              — 上线前跑一遍全绿，心里踏实

1.3 测试金字塔

1
2
3

        /  E2E 测试  \           少量，慢，覆盖完整流程
       / 集成测试     \          适量，中速，覆盖组件交互
      /   单元测试     \         大量，快速，覆盖业务逻辑

1
2
3

单元测试   — 数量最多，速度最快，只测一个方法
集成测试   — 测多个组件协作（如服务 + 数据库）
E2E 测试   — 从用户视角测完整流程

本系列重点讲单元测试和集成测试。E2E 测试一般用 Playwright 等工具，不在本系列范围内。

1.4 .NET 测试框架对比

xUnit        — 最流行，社区推荐，ASP.NET Core 团队使用
NUnit        — 老牌框架，功能丰富，类似 JUnit
MSTest       — 微软官方，集成好但功能少

推荐：xUnit（本系列全程使用 xUnit）

二、环境准备

2.1 创建解决方案结构

MyApp/
├── src/
│   └── MyApp.Services/           # 业务代码
│       ├── MyApp.Services.csproj
│       └── Calculator.cs
├── tests/
│   └── MyApp.Services.Tests/     # 测试代码
│       ├── MyApp.Services.Tests.csproj
│       └── CalculatorTests.cs
└── MyApp.sln

2.2 创建项目

# 创建解决方案
dotnet new sln -n MyApp

# 创建业务类库
dotnet new classlib -n MyApp.Services -o src/MyApp.Services

# 创建测试项目（xUnit 模板）
dotnet new xunit -n MyApp.Services.Tests -o tests/MyApp.Services.Tests

# 添加引用
dotnet add tests/MyApp.Services.Tests reference src/MyApp.Services

# 添加到解决方案
dotnet sln add src/MyApp.Services
dotnet sln add tests/MyApp.Services.Tests

2.3 测试项目 csproj

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <IsPackable>false</IsPackable>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.*" />
    <PackageReference Include="xunit" Version="2.*" />
    <PackageReference Include="xunit.runner.visualstudio" Version="2.*" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="..\..\src\MyApp.Services\MyApp.Services.csproj" />
  </ItemGroup>

</Project>

2.4 运行测试

# 运行所有测试
dotnet test

# 运行并显示详细输出
dotnet test --verbosity normal

# 只运行某个项目
dotnet test tests/MyApp.Services.Tests

# 持续运行（文件变化自动重跑）
dotnet test --watch

三、第一个测试

3.1 被测代码

// src/MyApp.Services/Calculator.cs
namespace MyApp.Services;

public class Calculator
{
    public int Add(int a, int b) => a + b;

    public int Subtract(int a, int b) => a - b;

    public int Multiply(int a, int b) => a * b;

    public double Divide(int a, int b)
    {
        if (b == 0)
            throw new DivideByZeroException("除数不能为零");

        return (double)a / b;
    }
}

3.2 编写测试

// tests/MyApp.Services.Tests/CalculatorTests.cs
using MyApp.Services;

namespace MyApp.Services.Tests;

public class CalculatorTests
{
    [Fact]
    public void Add_TwoNumbers_ReturnsSum()
    {
        // Arrange（准备）
        var calculator = new Calculator();

        // Act（执行）
        var result = calculator.Add(2, 3);

        // Assert（断言）
        Assert.Equal(5, result);
    }
}

3.3 关键概念

1
2
3

[Fact]       — 标记一个无参数的测试方法
AAA 模式     — Arrange（准备）→ Act（执行）→ Assert（断言）
Assert       — 验证结果是否符合预期

四、断言详解

4.1 相等性断言

[Fact]
public void EqualityAssertions()
{
    // 相等
    Assert.Equal(5, 2 + 3);                    // 数值
    Assert.Equal("hello", "hello");             // 字符串

    // 不等
    Assert.NotEqual(5, 2 + 4);

    // 浮点数精度
    Assert.Equal(3.14, 3.141, precision: 2);    // 精确到小数点后2位
}

4.2 布尔断言

[Fact]
public void BooleanAssertions()
{
    Assert.True(1 > 0);
    Assert.False(1 < 0);
}

4.3 集合断言

[Fact]
public void CollectionAssertions()
{
    var numbers = new List<int> { 1, 2, 3, 4, 5 };

    // 包含
    Assert.Contains(3, numbers);
    Assert.DoesNotContain(6, numbers);

    // 集合相等（顺序也要一致）
    Assert.Equal(new[] { 1, 2, 3, 4, 5 }, numbers);

    // 集合相等（不关心顺序）
    Assert.Equal(new[] { 5, 4, 3, 2, 1 }, numbers.OrderBy(_ => _));

    // 空集合
    Assert.Empty(new List<string>());
    Assert.NotEmpty(numbers);

    // 单个元素
    Assert.Single(new[] { 1 });

    // 所有元素满足条件
    Assert.All(numbers, n => Assert.True(n > 0));
}

4.4 异常断言

[Fact]
public void Divide_ByZero_ThrowsDivideByZeroException()
{
    var calculator = new Calculator();

    // 断言抛出异常
    var ex = Assert.Throws<DivideByZeroException>(
        () => calculator.Divide(10, 0));

    Assert.Equal("除数不能为零", ex.Message);
}

[Fact]
public void Constructor_NullName_ThrowsArgumentNullException()
{
    // 也可以用 Record.Exception
    var ex = Record.Exception(() => new User(null!));

    Assert.NotNull(ex);
    Assert.IsType<ArgumentNullException>(ex);
}

4.5 类型断言

[Fact]
public void TypeAssertions()
{
    object obj = "hello";

    // 是某类型
    Assert.IsType<string>(obj);

    // 可以赋值给某类型（包含子类）
    Assert.IsAssignableFrom<object>(obj);

    // 不是某类型
    Assert.NotType<int>(obj);
}

4.6 范围和比较断言

[Fact]
public void RangeAssertions()
{
    // 注意：xUnit 的 Assert 不直接支持范围断言
    // 用 True 断言组合
    var age = 25;
    Assert.True(age >= 18 && age <= 65, $"年龄 {age} 不在 18-65 范围内");
}

4.7 null 断言

[Fact]
public void NullAssertions()
{
    string? name = null;

    Assert.Null(name);
    Assert.NotNull("hello");
}

4.8 事件断言

[Fact]
public void PropertyChanged_Raised()
{
    var user = new User("张三");
    string? changedProperty = null;

    user.PropertyChanged += (_, e) => changedProperty = e.PropertyName;
    user.Name = "李四";

    Assert.Equal("Name", changedProperty);
}

五、AAA 模式详解

5.1 三段式结构

1
2
3

Arrange（准备）— 创建测试数据、Mock 对象、初始化状态
Act（执行）    — 调用被测方法
Assert（断言） — 验证结果、验证副作用

5.2 完整示例

public class DiscountServiceTests
{
    [Fact]
    public void CalculateDiscount_VipMember_Returns20Percent()
    {
        // Arrange
        var member = new Member { Level = MemberLevel.VIP };
        var order = new Order { Total = 1000m };
        var service = new DiscountService();

        // Act
        var discount = service.CalculateDiscount(member, order);

        // Assert
        Assert.Equal(200m, discount);         // 1000 * 20% = 200
        Assert.Equal(800m, order.FinalTotal); // 副作用验证
    }

    [Fact]
    public void CalculateDiscount_RegularMember_Returns5Percent()
    {
        var member = new Member { Level = MemberLevel.Regular };
        var order = new Order { Total = 1000m };
        var service = new DiscountService();

        var discount = service.CalculateDiscount(member, order);

        Assert.Equal(50m, discount);
    }

    [Fact]
    public void CalculateDiscount_NullMember_ThrowsArgumentNullException()
    {
        var order = new Order { Total = 1000m };
        var service = new DiscountService();

        Assert.Throws<ArgumentNullException>(
            () => service.CalculateDiscount(null!, order));
    }
}

5.3 AAA 的注意事项

1. Arrange 要完整 — 不要让读者猜测试前提是什么
2. Act 只有一个 — 一个测试只测一个行为
3. Assert 可以多个 — 但都和同一个行为相关
4. 不要在 Act 和 Assert 之间加逻辑

六、测试命名规范

6.1 常见命名风格

风格1：MethodName_Scenario_Expected（推荐）
  Add_TwoPositiveNumbers_ReturnsSum
  Divide_ByZero_ThrowsDivideByZeroException

风格2：Given_When_Then
  GivenTwoNumbers_WhenAdd_ThenReturnsSum

风格3：中文描述（适合团队内部）
  两个正数相加_返回正确结果

6.2 命名原则

1. 看名字就知道测什么（不用看代码）
2. 看名字就知道期望结果
3. 测试失败时，名字本身就是错误描述
4. 避免用 Test1、Test2 这种无意义名字

七、测试的组织结构

7.1 测试类组织

1
2

一个生产类 → 一个测试类
一个公共方法 → 一组测试（正常、边界、异常）

// 按功能分组
public class CalculatorTests
{
    public class Add
    {
        [Fact] public void ReturnsSum() { }
        [Fact] public void HandlesNegativeNumbers() { }
        [Fact] public void HandlesOverflow() { }
    }

    public class Divide
    {
        [Fact] public void ReturnsQuotient() { }
        [Fact] public void ByZero_ThrowsException() { }
    }
}

7.2 项目结构

tests/
├── MyApp.Services.Tests/
│   ├── CalculatorTests.cs
│   ├── DiscountServiceTests.cs
│   └── UserServiceTests.cs
├── MyApp.Services.IntegrationTests/
│   └── UserRepositoryTests.cs
└── MyApp.Web.Tests/
    └── OrderControllerTests.cs

八、在 Visual Studio 和 VS Code 中运行测试

8.1 Visual Studio

测试资源管理器   — 菜单：测试 → 测试资源管理器
运行全部         — Ctrl+R, A
运行单个         — 右键测试方法 → 运行测试
调试测试         — 右键测试方法 → 调试测试（可以打断点）

8.2 VS Code

1
2
3

安装扩展：C# Dev Kit（自带测试资源管理器）
侧边栏会出现测试图标 → 展开运行
或者在测试方法上方点击 ▶ 运行按钮

8.3 命令行

dotnet test                                    # 运行所有
dotnet test --filter "FullyQualifiedName~Add"  # 按名称过滤
dotnet test --filter "Category=Slow"           # 按分类过滤
dotnet test --logger "console;verbosity=detailed"  # 详细输出

九、常见误区

9.1 什么不是单元测试

✗ 需要数据库的测试        → 集成测试
✗ 需要文件系统的测试      → 集成测试
✗ 需要网络的测试          → 集成测试
✗ 需要手动检查结果的测试  → 不算自动化测试
✗ 顺序依赖的测试          → 设计有问题

9.2 FIRST 原则

Fast         — 快速（毫秒级）
Independent  — 独立（不依赖其他测试）
Repeatable   — 可重复（任何环境结果一致）
SelfValidating — 自我验证（自动判断通过/失败）
Timely       — 及时（最好在写代码时同步写测试）

十、小结

本文学习了单元测试的基础：

什么是单元测试和测试金字塔
xUnit 环境搭建
第一个测试和 AAA 模式
断言详解（相等、布尔、集合、异常、类型）
测试命名和组织规范
FIRST 原则

下一篇将深入学习 xUnit 进阶特性：数据驱动测试、共享上下文和测试生命周期。