Unit Testing on 纪伟的个人博客

设备通信与协议编程（十）：抓包、记录回放与协议契约测试

Tue, 04 Aug 2026 10:00:00 +0800

设备通信问题常常只在现场、特定固件或某个故障窗口出现。若日志只有“通信失败”，开发者只能反复猜测。可维护的通信模块应把原始证据、解析结果、请求关联和设备状态串成一条可回放链路。

1. 先明确要观察哪一层

层次	证据	常用工具
电气信号	电压、边沿、时序、干扰	示波器、逻辑分析仪
总线/链路	UART 字节、CAN 帧、EtherCAT datagram	串口/CAN/工业网络分析仪
网络	TCP 段、连接、重传、TLS 握手	Wireshark、`tcpdump`
应用协议	帧、命令、事务 ID、错误码	内置 dissector（Modbus/TCP、EtherCAT、CAN 等）、专有协议自研 dissector、结构化日志
业务	设备状态、流程步骤、Recipe	业务审计与状态快照

Wireshark 看不到 USB 串口芯片另一侧的真实 RS-485 电气波形；示波器也不知道某个功能码的业务含义。工具必须匹配问题层次。

2. 原始数据日志要可重建

对每个收发块至少记录：

1
2


Timestamp, Direction, DeviceId, ConnectionGeneration,
ChunkSequence, ByteCount, RawBytes, TransportMetadata

随后记录解析事件：

1
2


FrameSequence, Command, TransactionId, ParseResult,
ChecksumResult, PayloadSummary, CorrelationId

“块序号”与“帧序号”必须分开，因为一块可能含多帧，一帧也可能跨多块。时间戳注明来源和精度：墙上时间方便跨系统关联，单调时钟适合计算持续时间，硬件时间戳适合分析总线时序。

3. 十六进制日志的边界

原始字节很有价值，也可能包含 Recipe、序列号、账户或工艺数据。生产日志应：

默认限制每条记录的最大字节数；
对已知敏感字段脱敏，而不是事后搜索字符串；
保留原始总长度与截断标志；
使用二进制归档保存完整证据，并实施访问控制和保留周期；
不在实时回调中同步格式化大型 hex 字符串。

为了可读性，显示层可输出 AA 01 00 02；存储层更适合保存原始 byte 或 Base64，避免文本解析歧义。

4. 网络抓包如何不误判

TCP 抓包中，一个应用帧可能跨多个 TCP segment，也可能多个帧位于同一 segment。分析时应让 Wireshark 重组 TCP 流，再按应用协议长度解析，不能把 packet 边界当 message 边界。

常用流程：

1
2
3
4
5


# Windows 上先列出捕获接口；接口编号因机器而异。
tshark -D

# 只示意捕获过滤器，先替换接口编号、设备地址和端口。
tshark -i 3 -f "host 192.0.2.10 and tcp port 5000" -w device-session.pcapng

Windows 上实时捕获常规网络接口需要安装并加载 Npcap（Wireshark 安装器可一并安装）；否则 tshark -D 可能仍显示部分 extcap 等接口，但无法正常捕获本机常规网卡流量。

192.0.2.0/24 是文档示例网段。真实环境应先确认捕获权限、接口位置和数据合规要求。TLS 会隐藏应用载荷；不要为了抓包在生产环境关闭证书验证或加密。

5. 记录格式要版本化

可回放记录不应只是程序日志。建议文件头包含：

1
2
3
4
5
6
7


FormatVersion
ProtocolName / ProtocolVersion
CaptureStartUtc
ClockFrequency / TimestampOrigin
DeviceIdentity / FirmwareVersion
TransportConfiguration
PayloadEncoding

每条记录使用相对单调时间、方向、连接世代和原始数据。格式版本不兼容时明确拒绝，避免新回放器悄悄误解旧数据。

6. 回放的三种时间模式

模式	行为	用途
Step	测试代码逐条推进	确定性单元测试
Accelerated	保留顺序、压缩间隔	快速回归长会话
Real-time	尽量复现原间隔	超时、拥塞与竞态分析

回放器默认不应连接真实设备或执行真实输出。把传输接口替换为内存端点，并通过显式开关才能进入硬件测试环境。

7. 模拟器不是返回固定成功

有效模拟器应复现协议和状态机，而不是每条命令都返回 OK。至少支持：

正常请求/响应与主动事件；
分片、粘包、乱序事件和迟到响应；
CRC 错误、非法长度、未知命令；
设备 Busy、Faulted、NotReady；
执行后断线、重启和会话世代变化；
可控的虚拟时间。

模拟器越靠近传输层，越能测试真实解析器；越靠近业务能力层，越适合流程测试。两者用途不同，可以同时保留。设备行为模拟器与实机/HIL 测试梯度见《设备软件架构与控制模型（七）：实机、模拟器与 HIL》。

8. 契约测试

同一组协议向量应同时验证编码器、解码器和设备模拟器：

1
2
3
4


请求对象 → 编码 → 期望字节
原始字节 → 解码 → 期望对象
编码结果 → 解码 → 等价对象
错误字节 → 明确的拒绝原因

向量来源按可信度排序：标准规范示例、设备厂商确认样例、经人工标注的实机抓包、人工构造边界样例。不要把一次未知是否正确的现场抓包直接封为“黄金数据”。

9. 模糊测试与不变量

解析器适合做基于属性的测试。对任意 byte 输入，应满足：

不越界、不死循环、不无限分配；
每次返回要么需要更多数据，要么消费至少一个字节；
帧长永不超过契约上限；
错误输入不会产生未经验证的业务命令；
取消和关闭后没有后台任务泄漏。

模糊测试发现崩溃后，把最小化输入加入永久回归语料。

10. 现场问题闭环

一次完整问题包应包含：软件版本、设备身份与固件、配置快照、单调时间线、原始通信记录、解析日志、状态转换和复现步骤。修复后用同一记录回放，并增加一个能在旧版本失败、在新版本通过的自动化测试。

这比“多打一些日志再去现场”更重要：证据必须能驱动可重复验证。

11. 小结

协议诊断的关键是保持层次和可重建性：原始块、完整帧、请求关联和业务状态分别记录，再用版本化回放格式、真实状态模拟器和契约测试形成闭环。这样现场偶发故障才会变成可重复的软件输入。

参考资料

设备软件架构与控制模型（七）：模拟器、集成测试与 HIL

Thu, 16 Jul 2026 10:00:00 +0800

设备软件测试最现实的困难是硬件稀缺：开发机旁没有整机，实验设备不能随时制造故障，运动和加热又会让测试变慢甚至带来风险。结果往往是单元测试只覆盖工具类，真正重要的状态机、恢复流程和设备协同只能等到现场联调。

解决办法不是用 Mock 把所有 SDK 调用设成成功，而是建立逐级增加真实性的测试体系：纯逻辑模型验证规则，行为模拟器提供时间和故障，协议回放保护边界，最后用 Hardware-in-the-Loop（HIL）验证真实接口、时序和接线。

1. 按风险建立测试梯度

设备软件可以采用以下测试层次：

层次	主要对象	速度与环境	擅长发现的问题
纯逻辑测试	转换函数、校验器、计算模型	毫秒级，无 I/O	状态规则、边界值、算法错误
组件测试	流程执行器 + Fake/Simulator	快，可并行	超时、取消、恢复和资源竞争
协议/契约测试	适配器 + 模拟服务或回放	中等	报文解析、兼容性、错误映射
软件集成测试	完整进程 + 虚拟设备	中等	DI、配置、持久化、进程生命周期
HIL	上位机 + 真实控制器/仿真负载	慢，受实验台约束	驱动、接线、时序和真实固件差异
整机验收	完整设备与受控工况	最慢	端到端功能、性能和安全验证

层次越高越接近现场，但覆盖组合越困难。HIL 不应替代低层测试；它应该聚焦只有真实接口才能发现的风险，而不是重复一万组 Recipe 边界值。

2. Fake、Stub、Mock 和 Simulator 各有用途

这些测试替身解决的问题不同：

Stub 为特定输入返回预设结果，适合简单分支；
Mock 重点验证交互是否发生，适合边界协作；
Fake 是可工作的轻量实现，例如内存仓储；
Simulator 模拟状态随命令和时间变化，并能够注入设备故障。

设备流程通常更需要 Simulator。一个始终立即成功的 IAxis 无法发现“移动尚未完成就开始采集”、取消后轴继续移动、回零前误用绝对坐标等问题。

下面的最小模拟轴保留了位置、运动耗时和故障注入：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94


public sealed class SimulatedAxis(TimeProvider timeProvider) : IAxis
{
 private readonly object _sync = new();
 private Millimeters _position = new(0);
 private CancellationTokenSource? _activeMove;

 public bool FailNextMove { get; set; }

 public ValueTask<AxisSnapshot> ReadAsync(
 CancellationToken cancellationToken)
 {
 cancellationToken.ThrowIfCancellationRequested();
 lock (_sync)
 {
 return ValueTask.FromResult(new AxisSnapshot(
 _position,
 IsMoving: _activeMove is not null,
 IsServoOn: true,
 PositiveLimit: false,
 NegativeLimit: false,
 FaultCode: null));
 }
 }

 public async ValueTask MoveAbsoluteAsync(
 Millimeters target,
 MillimetersPerSecond speed,
 CancellationToken cancellationToken)
 {
 if (speed.Value <= 0)
 {
 throw new ArgumentOutOfRangeException(nameof(speed));
 }

 if (FailNextMove)
 {
 FailNextMove = false;
 throw new DeviceFaultException("DriveFault", "SIM-001");
 }

 var moveCancellation =
 CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);

 lock (_sync)
 {
 if (_activeMove is not null)
 {
 moveCancellation.Dispose();
 throw new InvalidOperationException("The axis is already moving.");
 }

 _activeMove = moveCancellation;
 }

 try
 {
 double seconds = Math.Abs(target.Value - _position.Value) /
 speed.Value;
 await Task.Delay(
 TimeSpan.FromSeconds(seconds),
 timeProvider,
 moveCancellation.Token);
 lock (_sync)
 {
 _position = target;
 }
 }
 finally
 {
 lock (_sync)
 {
 if (ReferenceEquals(_activeMove, moveCancellation))
 {
 _activeMove = null;
 }

 moveCancellation.Dispose();
 }
 }
 }

 public ValueTask StopAsync(
 AxisStopMode mode,
 CancellationToken cancellationToken)
 {
 cancellationToken.ThrowIfCancellationRequested();
 lock (_sync)
 {
 _activeMove?.Cancel();
 }

 return ValueTask.CompletedTask;
 }
}

这是教学版：它会阻止并发移动，并把停止简化为取消等待、保持起点位置，并没有模拟加速度、中间位置和停止距离。模拟器不是越逼真越好，而是要忠实实现测试关注的契约；未实现的行为应明确说明，避免团队把它误当数字孪生。

3. 把时间变成可控制依赖

真实等待会让超时和重试测试又慢又不稳定。.NET 8+ 内置 TimeProvider，Microsoft.Extensions.TimeProvider.Testing 包提供 FakeTimeProvider，可以在测试中推进虚拟时间。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


using Microsoft.Extensions.Time.Testing;

var clock = new FakeTimeProvider(
 new DateTimeOffset(2026, 8, 15, 0, 0, 0, TimeSpan.Zero));
var axis = new SimulatedAxis(clock);

ValueTask moving = axis.MoveAbsoluteAsync(
 new Millimeters(100),
 new MillimetersPerSecond(20),
 CancellationToken.None);

clock.Advance(TimeSpan.FromSeconds(5));
await moving;

AxisSnapshot snapshot = await axis.ReadAsync(CancellationToken.None);
if (snapshot.ActualPosition != new Millimeters(100))
{
 throw new InvalidOperationException("Simulation result is incorrect.");
}

包名是 Microsoft.Extensions.TimeProvider.Testing，命名空间是 Microsoft.Extensions.Time.Testing，两者不要混淆。虚拟时间只能控制使用同一个 TimeProvider 的代码；若业务中仍直接调用 DateTime.Now、Task.Delay 或 System.Threading.Timer，测试就会重新依赖真实时间。

4. 用故障脚本描述场景

仅有 FailNextMove 很快不够。可以把故障注入描述成脚本：

1
2
3
4
5
6
7
8


Given 轴已回零，当前位置 10 mm
When 收到移动到 100 mm 的命令
And 运动 40% 时通信中断
Then 上位机进入 PositionUnknown
And 不再接受后续绝对移动
And 保存目标、最后观测位置和控制器错误码
When 通信恢复并重新读取编码器
Then 根据回读和恢复策略决定重新回零或人工确认

脚本应覆盖命令前失败、执行中失败、执行完成但确认丢失这三个关键时间窗口。对于并发场景，还要控制事件顺序、重复和迟到，而不是依赖线程调度“碰巧复现”。

5. 契约测试保护真实与模拟实现

同一个 IAxis 可以有厂商适配器和模拟器，但实现同一接口不等于语义一致。为接口建立一组契约测试，分别运行在每个实现上：

未回零时绝对移动是否被拒绝；
超出软限位时是否在动作前失败；
返回完成时是否满足约定的到位条件；
取消后动作和状态如何变化；
重复停止和关闭是否幂等；
原始错误码是否保留。

真实硬件无法在普通 CI 中运行所有契约时，可以给测试打环境标签，在专用实验台定时执行；模拟器仍需在每次提交中执行相同的通用部分。

6. 记录回放用于协议和现场问题

记录回放（Record/Replay）能够把一次真实交互转成可重复输入。记录内容可包括时间间隔、请求字节、响应字节、连接事件和关键环境版本。回放有三种常见模式：

严格回放：请求必须与记录完全一致，适合协议回归；
状态回放：根据当前模拟状态生成响应，适合流程测试；
扰动回放：在原记录中插入延迟、丢包、断连或坏帧，适合鲁棒性验证。

回放数据要脱敏，特别是序列号、客户 Recipe、生产标识和访问凭据。还要记录协议/固件版本，否则几年后无法判断样本代表哪个实现。

7. HIL 验证软件无法伪造的部分

HIL 将真实控制器、I/O 模块或驱动器接到仿真负载上，让上位机面对真实通信栈和固件（半导体设备的领域化实践见《半导体设备软件（十）：仿真、单元测试与 Hardware-in-the-Loop》）。它适合验证：

驱动安装、位数和 SDK 依赖；
电平、接线、信号极性和抖动；
控制器扫描周期、缓冲和响应时序；
断电、复位、拔线和看门狗行为；
多设备同时运行时的资源与时序边界。

HIL 台必须有物理保护、运动范围和自动复位方案。测试脚本不能因为运行在“实验环境”就绕过急停和联锁。破坏性测试应使用专用工装，并由风险评估决定是否允许自动执行。

8. 测试断言最终事实

“调用过 MoveAbsoluteAsync 一次”只证明编排器发出了意图。更有价值的断言包括：

设备最终状态和实际位置；
Recipe 与校准快照是否绑定到运行记录；
失败后是否拒绝危险的后续命令；
补偿动作是否在正确前提下执行；
报警、诊断证据和审计事件是否完整；
重启后是否从可信检查点恢复。

交互次数仍有用，但它是验证边界协议的手段，不应代替业务结果。

总结

设备软件需要从纯逻辑、行为模拟、协议契约、完整软件、HIL 到整机验收的测试梯度。模拟器应表现时间、状态和失败，TimeProvider 让时间相关测试可控，契约测试防止真实与仿真实现语义漂移，HIL 则专注真实接口和时序风险。

下一篇将完成系列：建立日志、指标、追踪、审计和诊断包，并把软件升级设计成可验证、可回退的设备变更流程。

参考资料

Python 编程基础与工程实践（九）：测试、pyproject.toml 与工程化

Mon, 06 Jul 2026 10:00:00 +0800

能运行的脚本与可维护的项目之间，差的不只是目录数量。可靠项目要让新环境可以重建，让测试证明关键行为，让构建产物来自干净源码，并让本地与 CI 执行同一组命令。

本文以 Python 3.14 为基线，使用 PyPA 标准定义 pyproject.toml，以 pytest 展示测试方法。具体工具可以替换，但项目边界、依赖语义和验证闭环应保持稳定。

1. 从一个可安装项目开始

推荐的基础结构：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


temperature-service/
├── README.md
├── pyproject.toml
├── src/
│ └── temperature_service/
│ ├── __init__.py
│ ├── domain.py
│ └── cli.py
└── tests/
 ├── test_domain.py
 └── test_cli.py

src 布局把可导入包与仓库根目录分开。这样测试更容易针对“已安装的项目”运行，不会因为当前目录恰好在 sys.path 中而导入一份部署时不存在的代码。

包名和发行项目名不是同一个概念：发行名可包含连字符，例如 temperature-service；导入包通常使用下划线，例如 temperature_service。

2. `pyproject.toml` 的三层职责

一个可构建项目的最小配置可以是：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


[build-system]
requires = ["hatchling>=1.26"]
build-backend = "hatchling.build"

[project]
name = "temperature-service-example"
version = "0.1.0"
description = "A small temperature conversion service"
readme = "README.md"
requires-python = ">=3.14"
dependencies = []

[project.scripts]
temperature-service = "temperature_service.cli:main"

[tool.hatch.build.targets.wheel]
packages = ["src/temperature_service"]

三类表不能混为一谈：

[build-system] 告诉构建前端要安装哪个后端来生成发行包；
[project] 是会进入项目元数据的名称、版本、运行时依赖等标准字段；
[tool.<name>] 保存某个工具自己的配置，语义由该工具定义。

Hatchling、Setuptools、Flit 等构建后端都可以生成标准产物。这里选择 Hatchling 只是为了给出完整示例，不代表它是唯一标准。

当前示例的发行名规范化后是 temperature_service_example，与导入包 temperature_service 不同，因此显式告诉 Hatchling 从 src/temperature_service 构建 wheel。若省略这段后端专用配置，Hatchling 的默认名称推断无法找到要打包的目录。其他构建后端有各自的包发现规则，切换后端时要同步调整配置。

脚本入口指向的 src/temperature_service/cli.py 至少要提供对应函数：

1
2
3


def main() -> int:
 print("temperature service ready")
 return 0

3. 运行时依赖、可选依赖和开发依赖

运行项目必需的库放在 project.dependencies：

1
2
3
4


[project]
dependencies = [
 "httpx>=0.28,<1",
]

版本范围应表达已验证的兼容边界。库通常不应把所有传递依赖精确钉死，否则会妨碍宿主解析安全更新；应用为了可重复部署，则需要在单独的锁定结果中确定完整环境。

用户可选择的功能依赖使用 extras：

1
2


[project.optional-dependencies]
cli = ["rich>=15,<16"]

开发、测试和文档依赖不应成为安装库时的运行时依赖。标准化的依赖组可写为：

1
2
3
4
5
6
7


[dependency-groups]
test = [
 "pytest>=9,<10",
 "coverage>=7,<8",
 "mypy>=2,<3",
]
build = ["build>=1,<2"]

依赖组不会写入构建产物的项目依赖元数据。当前 pip 支持从项目根目录安装指定组：

1

python -m pip install --group test --group build

依赖组格式是标准，但不同工具的命令行能力和最低版本仍需核对。面向较旧工具链时，可继续使用 requirements 文件或工具自身的环境管理方案，并在项目文档中写明唯一入口。

4. 建立本地开发环境

从全新检出开始：

1
2
3
4


python -m venv .venv
.\.venv\Scripts\python.exe -m pip install --upgrade pip
.\.venv\Scripts\python.exe -m pip install --group test --group build
.\.venv\Scripts\python.exe -m pip install --editable .

macOS/Linux 把解释器路径换为 .venv/bin/python。可编辑安装让导入指向工作区源码，适合开发；发布验证还要安装并测试真正构建出来的 wheel。

不要把 .venv/、构建目录、缓存或覆盖率文件提交到 Git。应提交的是声明和锁定信息，使环境能够重建。

5. 第一个 pytest 测试

生产代码 src/temperature_service/domain.py：

1
2
3
4


def celsius_to_fahrenheit(celsius: float) -> float:
 if celsius < -273.15:
 raise ValueError("温度不能低于绝对零度")
 return celsius * 9 / 5 + 32

测试 tests/test_domain.py：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


import pytest

from temperature_service.domain import celsius_to_fahrenheit


@pytest.mark.parametrize(
 ("celsius", "expected"),
 [
 (0.0, 32.0),
 (100.0, 212.0),
 (-40.0, -40.0),
 ],
)
def test_celsius_to_fahrenheit(celsius: float, expected: float) -> None:
 assert celsius_to_fahrenheit(celsius) == pytest.approx(expected)


def test_rejects_temperature_below_absolute_zero() -> None:
 with pytest.raises(ValueError, match="绝对零度"):
 celsius_to_fahrenheit(-273.16)

脚本入口也要有最小行为测试。tests/test_cli.py：

1
2
3
4
5
6
7
8


import pytest

from temperature_service.cli import main


def test_main(capsys: pytest.CaptureFixture[str]) -> None:
 assert main() == 0
 assert capsys.readouterr().out == "temperature service ready\n"

运行：

1

python -m pytest

测试名称应表达行为和条件，不要只写 test_1。浮点计算使用 pytest.approx() 表达容差语义，而不是对所有浮点数强行精确比较。

6. Fixture 管理准备与清理

Fixture 适合创建每个测试所需的上下文：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


from collections.abc import Iterator
from pathlib import Path

import pytest


@pytest.fixture
def config_file(tmp_path: Path) -> Iterator[Path]:
 path = tmp_path / "config.toml"
 path.write_text('endpoint = "http://localhost"', encoding="utf-8")
 yield path

tmp_path 为测试提供独立临时目录。yield 后可以写额外清理，但由 tmp_path 管理的目录通常无需手工删除。

Fixture 应按真实生命周期选择作用域。把可变数据库连接、缓存或容器盲目设为 session 级，可能让测试相互污染；每个测试都重建昂贵环境又会拖慢套件。优化前先确认隔离要求和耗时来源。

7. 测试替身与 patch 的边界

最稳定的测试替身来自显式依赖：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


from typing import Protocol


class Clock(Protocol):
 def now(self) -> float: ...


class ExpirationService:
 def __init__(self, clock: Clock) -> None:
 self._clock = clock

测试可传入固定时钟，而不必修改全局时间函数。

确实需要修改环境变量或第三方调用时，pytest 的 monkeypatch 会在测试结束后恢复。假设 config.py 提供 load_settings，从环境变量读取超时设置：

1
2
3
4
5
6
7
8
9


import pytest

from temperature_service.config import load_settings


def test_reads_timeout(monkeypatch: pytest.MonkeyPatch) -> None:
 monkeypatch.setenv("APP_TIMEOUT_SECONDS", "3")
 settings = load_settings()
 assert settings.timeout_seconds == 3.0

Patch 应作用于“被测模块实际查找的名称”，而不是机械修改原始定义位置。如果模块写了 from api import send，就 patch 该模块中的 send 引用。过多 patch 往往说明依赖隐藏在全局状态中，应优先改善设计。

8. 单元测试、集成测试与端到端测试

不同层级回答不同问题：

单元测试：一个函数或对象的规则是否正确；
集成测试：数据库、文件格式、消息系统或 HTTP 适配是否真正兼容；
端到端测试：从外部入口到关键结果的主链路是否可用。

Mock 成功只能证明“代码按模拟器设定运行”，不能证明真实数据库方言、网络超时或序列化格式正确。关键适配器要有集成测试，并在可控环境中验证真实依赖。

测试还应覆盖失败路径：非法输入、部分成功、超时、重试后重复副作用、取消以及清理失败。只覆盖顺利路径的高覆盖率仍可能给出虚假信心。

9. 覆盖率是发现盲区，不是质量分数

使用 coverage.py 记录分支覆盖：

1
2


python -m coverage run --branch -m pytest
python -m coverage report --show-missing

配置可以放在 pyproject.toml：

1
2
3
4
5
6
7


[tool.coverage.run]
branch = true
source = ["temperature_service"]

[tool.coverage.report]
show_missing = true
fail_under = 85

阈值应防止明显倒退，而不是鼓励没有断言价值的测试。覆盖过的代码仍可能断言错误结果；未覆盖的异常分支也可能正是生产风险最高的部分。

10. 统一工具入口

pytest 的稳定 TOML 配置形式是：

1
2
3


[tool.pytest.ini_options]
addopts = "-ra --strict-markers"
testpaths = ["tests"]

开发机和 CI 应运行相同命令：

1
2
3
4
5


python -m pytest
python -m mypy src tests
python -m coverage run --branch -m pytest
python -m coverage report --show-missing
python -m build

构建后还应在新虚拟环境安装 dist/ 中生成的 wheel，再运行至少一组导入和命令行冒烟测试。这能发现包数据遗漏、入口点错误和“只有可编辑安装能工作”的问题。

CI 至少固定：

支持的 Python 版本和操作系统矩阵；
安装依赖的声明或锁定输入；
测试、类型检查和构建命令；
缓存键中的 Python 与依赖文件版本；
产物来源的提交和构建日志。

不要因为依赖缓存命中就跳过依赖解析与环境验证，也不要让发布任务重新构建一份未经测试的不同产物。

11. 依赖锁定的准确边界

project.dependencies 表达项目运行所需的抽象范围，锁文件表达某些目标环境中解析出的具体版本，两者职责不同。

Python 生态已经标准化 pylock.toml（PEP 751）格式，但具体锁定、同步命令以及工具支持范围仍需查阅所选工具文档。项目可以使用标准锁文件，也可能因既有工具链保留专用锁文件；关键要求是：

锁文件由声明生成，不手工拼凑传递依赖；
应用部署使用受控、可重现的具体集合；
库发布保留合理兼容范围，不把开发环境全部精确版本强加给使用者；
自动化更新后重新执行测试和安全审查；
锁定不等于安全，仍需处理撤回版本、漏洞和包索引信任。

12. 小结

src 布局让测试和构建更接近真实安装结果。
pyproject.toml 分别承载构建系统、项目元数据和工具配置，三者语义不同。
运行时依赖、extras、开发依赖组和锁定结果解决不同问题。
pytest 的参数化、Fixture 和 monkeypatch 应服务于行为验证与隔离，而不是堆砌技巧。
覆盖率只能暴露未执行区域，不能证明断言和需求正确。
CI 应测试一次、构建一次，并发布那份已经验证的产物。

最后一篇将把项目带入性能分析和交付：如何先测量、再优化，并正确构建 wheel、部署应用或发布库。

参考资料

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

Wed, 05 Feb 2025 10:00:00 +0800

写在前面

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

一、命名规范

1.1 测试方法命名

1
2
3
4
5
6
7
8


推荐格式：MethodName_Scenario_Expected

示例：
Add_TwoPositiveNumbers_ReturnsSum
Divide_ByZero_ThrowsDivideByZeroException
CreateOrder_EmptyItems_ThrowsArgumentException
GetUser_NonExistingId_ReturnsNull
ProcessPayment_InsufficientFunds_ReturnsFailed

1.2 测试类命名

1
2
3
4


被测类 + 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 文件组织

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


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 按速度分类

1
2
3
4
5
6


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

“70% 单元 / 20% 集成 / 10% E2E”只能作为解释金字塔的示意，不是通用配额。
实际比例应由系统风险、边界数量、反馈速度和维护成本决定。

2.2 用 Trait 标记分类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


[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 按分类运行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


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

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

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

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

2.4 分项目组织

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


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

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


<!-- 目录结构约定：让单元测试和集成测试分开 -->
<!-- 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 模式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60


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 模式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


// 预定义的常用测试数据
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 收集覆盖率

1
2
3
4
5
6
7
8


# 安装工具
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 包

1
2
3
4
5
6


<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 生成可视化报告

1
2
3
4
5
6
7
8


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

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

4.4 覆盖率配置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


<!-- 在 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> <!-- 排除迁移文件 -->
 </Configuration>
 </DataCollector>
 </DataCollectors>
 </DataCollectionRunSettings>
</RunSettings>

1

dotnet test --settings runsettings.xml

XPlat Code Coverage 数据收集器的 runsettings 配置不包含通用的 Threshold 元素；上面的文件负责收集范围与格式。若要让覆盖率不足时构建失败，应使用 CI 平台的质量门禁，或单独引入 coverlet.msbuild，通过 /p:Threshold=80 等 MSBuild 参数执行。

4.5 覆盖率的意义和误区

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


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

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

五、TDD 简介

5.1 红-绿-重构

1
2
3
4
5
6


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

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

5.2 TDD 实战示例

1
2
3
4
5
6


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


// 第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 的优缺点

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


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

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

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

六、测试坏味道

6.1 常见坏味道和修复

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58


// 坏味道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 坏味道速查

1
2
3
4
5
6
7


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

七、CI/CD 中的测试

7.1 GitHub Actions

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


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 分层运行策略

1
2
3
4
5
6
7
8


# 快速反馈：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 测试报告

1
2
3
4
5
6


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

# JUnit 不是 VSTest 内置 logger；先给测试项目安装 JunitXml.TestLogger 等兼容包
dotnet add package JunitXml.TestLogger
dotnet test --logger "junit;LogFileName=test_results.xml"

八、dotnet test 常用命令

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


# 基本运行
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 watch test

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

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

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

# xUnit 默认会并行运行不同测试集合；并行度通过 xunit.runner.json、
# CollectionBehavior 等 runner 配置控制，而不是通用的 dotnet test --parallel 开关

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

九、开发者测试工作流

9.1 日常开发流程

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


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

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

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

9.2 什么时候写测试

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


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

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

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

十、系列总结

10.1 知识体系回顾

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


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

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

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

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

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

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

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

10.2 核心原则

1
2
3
4
5
6
7
8


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

10.3 检查清单

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


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

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

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

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

Mon, 03 Feb 2025 10:00:00 +0800

写在前面

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

一、为什么需要集成测试

1.1 单元测试的局限

1
2
3
4
5
6
7


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

1.2 集成测试的范围

1
2
3
4


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

二、WebApplicationFactory

2.1 基本用法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


// 被测 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 测试基类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


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 测试

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


public class RealDatabaseTests : IAsyncLifetime
{
 private MsSqlContainer _container = null!;
 private WebApplicationFactory<Program> _factory = 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
 _factory = new CustomWebApplicationFactory().WithWebHostBuilder(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()
 {
 _client.Dispose();
 _factory.Dispose();
 await _container.DisposeAsync();
 }
}

3.2 事务回滚模式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


// 每个测试用事务包裹，测试完回滚，数据不残留
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 测试自定义中间件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


// 被测中间件：请求日志
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 测试异常处理中间件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61


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 测试需要认证的接口

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


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 模拟认证用户

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61


// 自定义 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 授权

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


// 模拟不同角色
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 响应结构验证

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


[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 测试隔离

1
2
3
4


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

7.2 性能优化

1
2
3
4
5
6
7
8


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

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

7.3 测试分类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// 用 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 单元测试（五）：难测场景实战

Sat, 01 Feb 2025 10:00:00 +0800

写在前面

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

一、数据库测试

1.1 测试策略选择

1
2
3
4
5
6
7
8


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

选择建议：
- 测业务逻辑（Service 层）→ Mock Repository
- 测 Repository 实现本身 → 优先使用与生产相同的真实数据库；受限场景再评估 SQLite 测试替身

1.2 方案一：Mock Repository（推荐）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53


// 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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53


// 测试 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（更接近真实）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


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 对比

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


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

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

建议：
 EF Core InMemory 不具备关系数据库语义，官方不建议把它当作数据库测试替身
 只验证极受限的 LINQ 流程且明确接受差异 → 可谨慎使用 InMemory
 需要部分关系约束但不依赖生产数据库特性 → SQLite（仍存在方言和行为差异）
 需要验证真实查询、约束、事务与迁移 → Testcontainers 或专用测试数据库

二、HTTP 调用测试

2.1 Mock HttpMessageHandler

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99


// 被测服务
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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


// 通用简化版
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 不可控

1
2
3
4
5
6
7
8


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

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53


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 方案二：自定义接口

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


// 适用于 .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 方案一：注入路径 + 临时目录

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57


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 抽象

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56


// 生产代码：注入 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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


[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 基本并发测试

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


[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 测试

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


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 如果必须测

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


// 方案一：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);
}

八、场景选择速查

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


数据库 → Mock Repository（单元测试）
 EF Core InMemory（仅限明确接受语义差异的窄场景）
 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、真实数据库/Testcontainers，以及受限场景下的 SQLite/InMemory 测试替身
HTTP 调用：Mock HttpMessageHandler
时间：TimeProvider + FakeTimeProvider
文件系统：临时目录、Stream 注入、System.IO.Abstractions
配置：OptionsWrapper、ConfigurationBuilder
多线程和并发测试
私有方法测试策略

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

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

Thu, 30 Jan 2025 10:00:00 +0800

写在前面

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

一、可测试性原则

1.1 什么是可测试性

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


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

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

1.2 依赖倒置原则（DIP）

1
2


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


// 不可测：直接依赖具体实现
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 什么时候该抽接口

1
2
3
4
5
6
7
8
9


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

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

2.2 接口粒度

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


// 反模式：一个巨大的接口（违反接口隔离原则）
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 基本模式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


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 依赖太多怎么办

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


// 反模式：构造函数参数太多（通常说明类做了太多事）
public class OrderService
{
 public OrderService(
 IOrderRepository repo,
 IUserRepository userRepo,
 IProductRepository productRepo,
 IEmailService email,
 ISmsService sms,
 IPaymentGateway payment,
 ILogger logger,
 ICacheService cache,
 IConfiguration config)
 {
 // 依赖很多是职责可能过重的信号，但不是仅凭数量就能下结论
 }
}

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

四、重构不可测代码

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


// 不可测
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 场景二：直接调用静态方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56


// 不可测
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}";
 }
}

// 测试项目先安装：dotnet add package Microsoft.Extensions.TimeProvider.Testing
[Fact]
public void GetGreeting_Morning_ReturnsMorningGreeting()
{
 // FakeTimeProvider 可同时控制 UTC 时间和本地时区；GetLocalNow 本身不是可 Mock 的虚方法
 var fakeTime = new FakeTimeProvider();
 fakeTime.SetLocalTimeZone(TimeZoneInfo.CreateCustomTimeZone(
 "UTC+8", TimeSpan.FromHours(8), "UTC+8", "UTC+8"));
 fakeTime.SetUtcNow(new DateTimeOffset(2026, 5, 1, 1, 0, 0, TimeSpan.Zero));

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

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

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


// 不可测
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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67


// 不可测
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 问题：运行时选择不同实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


// 场景：不同租户使用不同的短信服务商
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 工厂模式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


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 使用和测试

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


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 容器

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


// 单元测试：手动创建和注入
[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 容器

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


// 集成测试：用真实的 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 策略模式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


// 不同折扣策略
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 模板方法模式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


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

八、可测试性检查清单

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


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

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

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

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

九、小结

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

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

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

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

Tue, 28 Jan 2025 10:00:00 +0800

写在前面

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

一、为什么要隔离

1.1 问题场景

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


// 一个依赖数据库和邮件的服务
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
3
4
5


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

1.2 隔离的好处

1
2
3
4


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

二、Test Double 分类

2.1 四种 Test Double

1
2
3
4


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

2.2 举例说明

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


// 接口定义
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 什么时候用什么

1
2
3
4


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

三、Moq 框架详解

Moq 是 .NET 生态中常用的 Mock 框架之一。

3.1 安装

1

dotnet add package Moq

3.2 基本 Setup（Stub 行为）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


[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 参数匹配

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


// 精确匹配
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 返回值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


// 固定返回值
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 行为）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


[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 选项

1
2
3
4
5


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 — 捕获参数和副作用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


[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 — 模拟异常

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


[Fact]
public void CreateOrder_DatabaseDown_ThrowsException()
{
 var mockRepo = new Mock<IOrderRepository>();
 mockRepo.Setup(r => r.Save(It.IsAny<Order>()))
 .Throws(new InvalidOperationException("数据库连接不可用"));

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

 Assert.Throws<InvalidOperationException>(
 () => 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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


// 自动实现所有属性（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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// 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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


[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 测试

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


// 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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


// 反模式：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 被测类本身

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


// 反模式：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 验证实现细节

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


// 反模式：验证内部实现
[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

1
2
3
4
5
6
7
8
9


// 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 常用语法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


// 返回值
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 选择建议

1
2
3
4


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

七、小结

本文学习了 Mock 与隔离：

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

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

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

Sun, 26 Jan 2025 10:00:00 +0800

写在前面

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

一、数据驱动测试

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

1.1 InlineData — 少量固定数据

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


[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 — 从属性/方法获取数据

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


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 从其他类获取

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


// 集中管理测试数据
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 — 从类获取数据

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


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 — 强类型数据

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// 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 加载

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


// 从 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 数据驱动测试的选择

1
2
3
4
5


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

二、共享上下文

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

2.1 三种共享级别

1
2
3


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

2.2 默认行为（无共享）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


// 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
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58


// 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
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63


// 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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


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 生命周期总结

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


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

四、并行测试

4.1 xUnit 并行策略

1
2
3
4


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

4.2 控制并行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


// 程序集级别：禁止并行
[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


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

五、跳过测试

5.1 条件跳过

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


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

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

 // Windows 专属测试
}

5.2 条件编译

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


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

六、自定义 xUnit 扩展

6.1 自定义 FactAttribute

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


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

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

6.2 自定义 TheoryAttribute

1
2
3
4
5
6
7
8
9


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

七、FluentAssertions（可选增强）

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

许可提醒：Fluent Assertions 8 及更高版本对商业使用要求付费许可；版本 7 仍保持开源许可。团队引入或升级前应核对当前许可证，也可以评估 Shouldly 等替代方案。

7.1 安装

1

dotnet add package FluentAssertions

7.2 使用对比

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// 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 更多示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// 字符串
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, 24 Jan 2025 10:00:00 +0800

写在前面

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

一、什么是单元测试

1.1 定义

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

1
2
3
4
5
6


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

1.2 为什么要写单元测试

1
2
3
4
5


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

1.3 测试金字塔

1
2
3


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

1
2
3


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

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

1.4 .NET 测试框架对比

1
2
3
4
5


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

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

二、环境准备

2.1 创建解决方案结构

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


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

2.2 创建项目

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


# 创建解决方案
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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


<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 运行测试

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# 运行所有测试
dotnet test

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

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

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

三、第一个测试

3.1 被测代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// 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 编写测试

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


// 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 相等性断言

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


[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 布尔断言

1
2
3
4
5
6


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

4.3 集合断言

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


[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 异常断言

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


[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 类型断言

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


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

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

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

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

4.6 范围和比较断言

1
2
3
4
5
6
7


[Fact]
public void RangeAssertions()
{
 // xUnit 内置范围断言，边界值也包含在范围内
 var age = 25;
 Assert.InRange(age, 18, 65);
}

4.7 null 断言

1
2
3
4
5
6
7
8


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

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

4.8 事件断言

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


[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 完整示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


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
2
3
4


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

六、测试命名规范

6.1 常见命名风格

1
2
3
4
5
6
7
8
9


风格1：MethodName_Scenario_Expected（推荐）
 Add_TwoPositiveNumbers_ReturnsSum
 Divide_ByZero_ThrowsDivideByZeroException

风格2：Given_When_Then
 GivenTwoNumbers_WhenAdd_ThenReturnsSum

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

6.2 命名原则

1
2
3
4


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

七、测试的组织结构

7.1 测试类组织

1
2


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


// 按功能分组
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 项目结构

1
2
3
4
5
6
7
8
9


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

1
2
3
4


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

8.2 VS Code

1
2
3


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

8.3 命令行

1
2
3
4


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

九、常见误区

9.1 什么不是单元测试

1
2
3
4
5


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

9.2 FIRST 原则

1
2
3
4
5


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

十、小结

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

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

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

Unit Testing on 纪伟的个人博客

设备通信与协议编程（十）：抓包、记录回放与协议契约测试

1. 先明确要观察哪一层

2. 原始数据日志要可重建

3. 十六进制日志的边界

4. 网络抓包如何不误判

5. 记录格式要版本化

6. 回放的三种时间模式

7. 模拟器不是返回固定成功

8. 契约测试

9. 模糊测试与不变量

10. 现场问题闭环

11. 小结

参考资料

设备软件架构与控制模型（七）：模拟器、集成测试与 HIL

1. 按风险建立测试梯度

2. Fake、Stub、Mock 和 Simulator 各有用途

3. 把时间变成可控制依赖

4. 用故障脚本描述场景

5. 契约测试保护真实与模拟实现

6. 记录回放用于协议和现场问题

7. HIL 验证软件无法伪造的部分

8. 测试断言最终事实

总结

参考资料

Python 编程基础与工程实践（九）：测试、pyproject.toml 与工程化

1. 从一个可安装项目开始

2. pyproject.toml 的三层职责

3. 运行时依赖、可选依赖和开发依赖

4. 建立本地开发环境

5. 第一个 pytest 测试

6. Fixture 管理准备与清理

7. 测试替身与 patch 的边界

8. 单元测试、集成测试与端到端测试

9. 覆盖率是发现盲区，不是质量分数

10. 统一工具入口

11. 依赖锁定的准确边界

12. 小结

参考资料

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

写在前面

一、命名规范

1.1 测试方法命名

1.2 测试类命名

1.3 测试项目命名

1.4 文件组织

二、测试分类

2.1 按速度分类

2.2 用 Trait 标记分类

2.3 按分类运行

2.4 分项目组织

三、测试数据构建

3.1 Builder 模式

3.2 Order Builder

3.3 Object Mother 模式

四、代码覆盖率

4.1 收集覆盖率

4.2 添加 coverlet 包

4.3 生成可视化报告

4.4 覆盖率配置

4.5 覆盖率的意义和误区

五、TDD 简介

5.1 红-绿-重构

5.2 TDD 实战示例

5.3 TDD 的优缺点

六、测试坏味道

6.1 常见坏味道和修复

6.2 坏味道速查

七、CI/CD 中的测试

7.1 GitHub Actions

7.2 分层运行策略

7.3 测试报告

八、dotnet test 常用命令

九、开发者测试工作流

9.1 日常开发流程

9.2 什么时候写测试

十、系列总结

10.1 知识体系回顾

10.2 核心原则

10.3 检查清单

2. `pyproject.toml` 的三层职责