工具-04-测试基础
这篇笔记讲什么
自动化测试(automated testing)是「让机器替你确认代码没坏」的工程手段。本篇从为什么必须写测试讲到怎么写才算好测试:测试金字塔、AAA 结构、断言与框架选型、测试替身(test double)、覆盖率、TDD、集成与端到端测试、前端组件测试,以及一条完整的单元测试示例。
读完你应该能:为一个函数写出正常路径 + 边界 + 异常三组用例,能判断某个依赖「该不该 mock」,能解释为什么 100% 覆盖率仍然可能线上崩溃。
是什么
测试就是一段代码,它调用另一段代码,然后断言(assert)结果符合预期。
一个最小的单元测试长这样(Jest / Vitest 风格):
import { expect, test } from 'vitest';
import { sum } from './sum.js';
test('sum(1, 2) 应返回 3', () => {
expect(sum(1, 2)).toBe(3);
});
把测试按「测试对象的范围」分类,得到工程上最重要的三种:
| 类型 | 测试范围 | 是否碰真实依赖(数据库/网络) | 典型耗时 |
|---|---|---|---|
| 单元测试(unit test) | 单个函数 / 类 / 组件 | 否,全部替换为测试替身 | 毫秒级 |
| 集成测试(integration test) | 多个模块 + 真实依赖 | 通常是 | 百毫秒到秒级 |
| 端到端测试(end-to-end test, E2E) | 整个系统,从用户界面到数据库 | 是 | 秒到分钟级 |
术语原文
单元测试 = unit test;集成测试 = integration test;端到端测试 = end-to-end test(E2E);断言 = assertion;测试替身 = test double;覆盖率 = coverage;持续集成 = continuous integration(CI);测试驱动开发 = test-driven development(TDD)。
为什么需要它
1. 重构的安全网
重构(refactoring)的定义是「不改变外部行为的前提下调整内部结构」。没有测试,你根本无法确认「外部行为没变」——只能靠人肉点页面,而人肉点击是不可重复、不可穷尽的。有了测试,重构变成「改代码 → 跑测试 → 全绿 → 提交」,从「胆子活」变成「体力活」。
2. 缺陷修复成本随阶段指数增长
这是软件工程里最经得起检验的经验规律之一。设第 个阶段发现并修复一个缺陷的成本为 ,则大致满足:
其中 是编码期修复成本。取 ,各阶段的相对成本:
| 阶段 | 相对成本 | 典型表现 |
|---|---|---|
| 需求/设计 | 改一句话 | |
| 编码(本地测试发现) | 改几行,跑一下测试 | |
| 提交 / CI 阶段 | 修提交、重跑流水线 | |
| 测试环境 | 查日志、复现、定位 | |
| 生产环境 | 停机、回滚、道歉、补数据 |
结论不是「测试能省钱」这么含糊,而是:越早拦住的缺陷越便宜,而自动化测试是目前最便宜的「早拦住」手段。
3. 测试即活文档(executable documentation)
注释会腐烂,文档会过期,只有测试会被 CI 强制执行——它一旦不真实就会变红。新人读 test('订单金额为 0 时抛异常') 立刻知道业务规则,比读三十行注释快。
4. 真实事故:改一行,修好三处坏五处
一个在真实项目里反复上演的场景:
需求:把「满 200 减 20」改成「满 200 减 30」
改动:一行常量
结果:
✓ 优惠计算修正了
✓ 顺手修好了「优惠叠加」的判断
✓ 顺手修好了发票金额取整
✗ 购物车小计错了(用了优惠后的金额)
✗ 订单列表金额错了
✗ 退款金额错了
✗ 对账接口签名校验失败
✗ 历史订单查询慢查询告警
这正是没有测试的典型形态:改动的爆炸半径(blast radius)不可见。有测试时,四处标红,你在本地五分钟内就知道自己踩了什么;没有测试时,你在生产环境用两小时才知道。
一句话记住
测试不是为了证明代码是对的,而是为了在改动后立刻知道哪里坏了。
核心内容
测试金字塔(test pyramid)
Mike Cohn 提出的经典模型:底层多、上层少。
╱╲ E2E 测试:少量,只覆盖核心用户路径
╱ ╲ 慢、脆、贵、覆盖广
╱────╲
╱ ╲ 集成测试:中等数量,覆盖模块协作与真实依赖
╱────────╲ 中等速度、中等脆弱
╱ ╲
╱────────────╲ 单元测试:大量,覆盖每个分支与边界
╱______________╲ 快、稳、便宜、精准
| 维度 | 单元测试 | 集成测试 | E2E 测试 |
|---|---|---|---|
| 数量占比(经验值) | 约 70% | 约 20% | 约 10% |
| 单条耗时 | ms | ms 数秒 | s 数分钟 |
| 编写成本 | 低 | 中 | 高 |
| 维护成本 | 低(不依赖环境) | 中 | 高(选择器/环境/数据) |
| 定位失败原因的难度 | 低(直指函数) | 中 | 高(不知哪一层坏) |
| 能发现的问题 | 逻辑错误、边界错误 | 接口不匹配、SQL 错误、序列化问题 | 流程断裂、部署配置错误 |
| 是否依赖真实环境 | 否 | 是(可容器化) | 是 |
用耗时估算说明为什么必须分层。设单元测试 条、集成测试 条、E2E 条,串行总耗时为:
代入 ;;:
注意:20 条 E2E 占了总耗时的 88%。若把 E2E 也写成 1000 条,光 E2E 就是 小时——没人会等,于是测试形同废弃。所以「金字塔」的本质是成本与反馈速度的权衡,不是审美偏好。
冰淇淋反模式与测试奖杯
冰淇淋反模式(ice cream cone anti-pattern):手工测试最多 → E2E 一大堆 → 集成一堆 → 单元几乎没有。形状倒过来,后果是测试套件越跑越慢、越跑越红、最后被 --skip 掉。它通常不是被设计出来的,而是逐步长歪的:每次出事故都补一条 E2E,从不补单元测试。
测试奖杯(testing trophy)是 Kent C. Dodds 针对前端提出的补充视角:底座是静态检查(TypeScript / ESLint),中间最厚的一层是集成测试,顶部才是 E2E,单元测试很薄。理由很务实:前端组件的价值大多在「组合与交互」上,纯函数式的单元测试覆盖不到真正的风险,而大量前端单元测试容易退化为「测试实现细节」。
两个模型怎么选
后端业务逻辑(金额、权限、状态机)→ 金字塔,单元测试为主。
前端 UI 组件 → 奖杯,静态检查 + 组件级集成测试为主。
两者不冲突:都是「把测试放在性价比最高的层」。
单元测试结构
AAA 模式(Arrange-Act-Assert)
三段式:准备 → 执行 → 断言。每个测试都应该是这三段,且只有一段 Act。
def test_满减_满200减30():
# Arrange(准备)
cart = ShoppingCart()
cart.add("书", 199)
# Act(执行)——只有一行
cart.add("笔", 1)
# Assert(断言)
assert cart.total == 170
Given-When-Then
同一件事的 BDD(behavior-driven development)说法:Given(给定前置条件)→ When(当发生某操作)→ Then(那么应如此)。测试名可以直接用这个句式,可读性最好。
一个测试只验证一件事
# ❌ 反例:失败了不知道坏在哪
def test_购物车():
cart = ShoppingCart()
cart.add("书", 100)
assert cart.count == 1
assert cart.total == 100
assert cart.discount == 0
cart.clear()
assert cart.count == 0
# ✅ 正例:一个测试一个行为
def test_加入商品后数量为1(): ...
def test_加入商品后金额累加(): ...
def test_清空后数量为0(): ...
「一件事」指一个行为,不是「一个断言」。同一个行为的多个断言(如「返回 200 且 body 含 id」)放一起是合理的。
测试命名规范
| 风格 | 示例 | 适用 |
|---|---|---|
| 中文行为描述 | test_满200减30_金额为200时生效 | 团队中文语境,可读性最高 |
| should 句式 | should_apply_discount_when_total_is_200 | 英文项目常见 |
| Given-When-Then | given_total_200_when_checkout_then_discount_30 | 业务规则复杂时 |
三层 describe/it | describe('购物车') > it('满200减30') | JS 生态,输出分层清晰 |
命名反模式
test1、test_calc、test_works、testFixBug——这类名字在 CI 报告里等于噪声。测试名应该能让没读过代码的人判断这条测试保护的是什么规则。
断言与框架
| 语言 | 主流框架 | 断言库 | 运行命令 |
|---|---|---|---|
| JavaScript / TypeScript | Jest、Vitest | 内置 expect | npx jest / npx vitest run |
| Python | pytest、unittest | 内置 assert / unittest.TestCase.assert* | pytest / python -m unittest |
| C# / .NET | xUnit.net、NUnit、MSTest | xUnit Assert.* / FluentAssertions | dotnet test |
.NET 侧的官方定位:MSTest 是微软官方框架,NUnit 是 .NET Foundation 项目、由 JUnit 移植而来,xUnit.net 由 NUnit v2 原作者编写、是当前社区最常用于新项目的选择;三者都支持 VSTest 与新的 Microsoft.Testing.Platform(MTP)。
参数化测试
同一个逻辑跑多组数据,避免复制粘贴:
// Jest / Vitest
test.each([
[0, 0],
[1, 1],
[200, 180], // 满 200 减 20
[1000, 900], // 满 1000 减 100
])('金额 %i 的优惠后价格应为 %i', (total, expected) => {
expect(applyDiscount(total)).toBe(expected);
});
# pytest
import pytest
@pytest.mark.parametrize("total,expected", [
(0, 0),
(1, 1),
(200, 180),
(1000, 900),
])
def test_优惠后价格(total, expected):
assert apply_discount(total) == expected
参数化测试的价值在「用例名」
失败时输出会是
test_优惠后价格[200-180],一眼看出是哪组数据坏了。给复杂用例加ids=[...]或pytest.param(..., id="满200减20"),报错信息会更好读。
测试替身(test double)
「测试替身」是「用假对象替换真依赖」的统称,共五种。这个词来自电影里的替身演员(stunt double)。
| 类型 | 中文 | 做什么 | 是否验证调用 | 典型用途 |
|---|---|---|---|---|
| Dummy | 占位对象 | 只为了填参数,从不被使用 | 否 | 传一个 null 就能跑通的参数 |
| Stub | 桩 | 返回预设值 | 否 | 让 getUser() 返回固定用户 |
| Spy | 间谍 | 记录调用信息,可透传真实实现 | 是(事后查看) | 确认「发过一封邮件」 |
| Mock | 模拟对象 | 预设期望,未满足即失败 | 是(事前约定) | 确认「必须以 X 参数调用一次」 |
| Fake | 假实现 | 有可工作的简化实现 | 否 | 内存数据库、内存文件系统 |
Stub 与 Mock 的区别(重点)
二者最容易混。区别不在「代码长什么样」,而在谁决定测试成败:
- Stub 是「喂数据」:它的返回值让你的被测代码能继续跑下去。测试的断言针对被测代码的输出。
- Mock 是「查行为」:它自己带着期望(「必须被调用一次」)。测试的断言部分是由替身完成的。
# Stub:邮件服务只是「别真的发邮件」,断言看的是订单状态
def test_下单后订单状态为已支付():
mailer = StubMailer() # 返回 None,不做任何事
service = OrderService(mailer=mailer)
order = service.pay(order_id=1, amount=100)
assert order.status == "PAID" # 断言在被测对象上
# Mock/Spy:断言的是「有没有发通知」这个副作用
def test_下单后必须发送确认邮件():
mailer = SpyMailer()
service = OrderService(mailer=mailer)
service.pay(order_id=1, amount=100)
assert mailer.sent_to == ["user@example.com"] # 断言在替身上
判据
如果一条测试在替身上做断言(调用次数、参数),它是行为验证;如果在返回值/状态上断言,它是状态验证。状态验证更稳,行为验证更准——但更容易碎。
什么时候不该 mock
这是比「怎么 mock」更重要的知识。过度 mock 会产生三类典型病症:
- 测试与实现强耦合:把内部函数名、调用顺序写进断言。重构(不改行为)→ 测试全红 → 团队开始不信任测试。
- 测试通过但线上崩:mock 掉的是「你以为的」依赖行为。真实 API 返回
null而不是空数组、真实数据库有唯一约束——mock 不会告诉你。 - mock 回音室:测试里
when(db.query()).thenReturn([1,2,3]),被测代码assert sum == 6。这只是在验证「加法」,与数据库无关。
经验法则:
| 情况 | 建议 |
|---|---|
| 跨网络的外部服务(支付、短信、第三方 API) | 必须替换(stub/fake) |
| 当前时间、随机数、UUID | 必须替换(可控时钟 / 固定随机源) |
| 数据库 | 优先用真实数据库(容器或内存库),而不是 mock |
| 纯函数、纯计算、你自己的简单值对象 | 不要替换,直接用真的 |
| 同一进程内的另一个业务类 | 通常不要替换——若必须替换才能测,说明设计有问题 |
依赖注入(dependency injection)让代码可测
不可测的代码几乎总是「自己 new 依赖」的代码:
# ❌ 无法测试:内部硬编码了真实 HTTP 与当前时间
class OrderService:
def is_expired(self, order):
now = datetime.now() # 不可控
return order.created + timedelta(days=7) < now
# ✅ 可测试:依赖从外部传入,测试时可注入固定时钟
class OrderService:
def __init__(self, clock=datetime.now, mailer=None):
self.clock = clock
self.mailer = mailer
def is_expired(self, order):
return order.created + timedelta(days=7) < self.clock()
「为了可测而改设计」不是本末倒置:能被注入依赖的代码,通常耦合也更低。
测试独立性(test independence)
测试必须满足:任意顺序、单独运行、重复运行,结果都一样。
破坏独立性的元凶是共享状态:
# ❌ 顺序依赖:单跑 test_b 会失败
state = {"count": 0}
def test_a_增加计数():
state["count"] += 1
assert state["count"] == 1
def test_b_计数为1():
assert state["count"] == 1 # 只有 test_a 先跑才通过
治理手段:
beforeEach/afterEach(pytest 为setup_method/teardown_method,或 fixture)中重建状态,而不是复用;- 每个测试自己创建被测对象(
Arrange段承担这个职责); - 数据库测试用事务回滚或每次重建 schema;
- 打开随机顺序执行,把隐藏的顺序依赖暴露出来:
# Jest:按文件级随机
npx jest --randomize
# Vitest:随机顺序 + 固定种子便于复现
npx vitest run --sequence.shuffle --sequence.seed=42
# pytest:需要插件
pip install pytest-randomly
pytest -p randomly
为什么随机顺序值得开
顺序依赖的测试在 CI 上会以「flaky(时好时坏)」的面目出现,排查成本极高。随机顺序把它变成一条稳定的失败,问题立刻可定位。
异步代码测试
异步测试最常见的 bug 是测试跑完了,异步操作还没结束——于是断言从未执行,测试永远是绿的。
// ❌ 假绿:Jest 不会等这个 Promise
test('获取数据', () => {
fetchData().then(data => {
expect(data).toBe('peanut butter'); // 可能根本没跑
});
});
// ✅ 返回 Promise,让测试框架等你
test('获取数据', () => {
return fetchData().then(data => expect(data).toBe('peanut butter'));
});
// ✅ 或者用 async/await(推荐,更易读)
test('获取数据', async () => {
const data = await fetchData();
expect(data).toBe('peanut butter');
});
// ✅ 断言「Promise 会 reject」,用 rejects
test('请求失败应抛错', async () => {
await expect(fetchData()).rejects.toThrow('网络错误');
});
三条铁律:
- 必须
return或await,否则测试会在异步完成前结束(Jest 官方文档明确警告这一点)。 - 断言 reject 分支时,给测试加
expect.assertions(n),避免「没进 catch 也算通过」。 - 回调风格的 API 用
done参数,但done与返回 Promise 不可混用(Jest 会直接报错)。
用假定时器(fake timers)处理 setTimeout 与防抖节流
真实等待是测试套件的慢性毒药:一个 setTimeout(…, 1000) 就让整个套件多一秒。
// ❌ 真实等待:慢且不稳(CI 机器慢时会偶发失败)
test('防抖 500ms 后只调用一次', async () => {
const fn = vi.fn();
const debounced = debounce(fn, 500);
debounced(); debounced(); debounced();
await new Promise(r => setTimeout(r, 600)); // 真的睡 600ms
expect(fn).toHaveBeenCalledTimes(1);
});
// ✅ 假定时器:瞬间推进虚拟时间
test('防抖 500ms 后只调用一次', () => {
vi.useFakeTimers();
const fn = vi.fn();
const debounced = debounce(fn, 500);
debounced(); debounced(); debounced();
vi.advanceTimersByTime(499);
expect(fn).not.toHaveBeenCalled(); // 还能顺便测边界:499ms 不该触发
vi.advanceTimersByTime(1);
expect(fn).toHaveBeenCalledTimes(1);
vi.useRealTimers(); // 记得还原,避免污染其他测试
});
假定时器的常见坑
- 忘记
useRealTimers()→ 后续测试里所有setTimeout都不再前进,测试挂死。- 假定时器与
await混用:await依赖微任务队列,通常仍工作,但依赖真实定时器的第三方库会卡住。- 测试「节流」时要断言中间状态,只断言最终结果无法区分防抖与节流。
测试覆盖率(code coverage)
覆盖率衡量「测试执行到了多少代码」,四种常见口径:
| 口径 | 含义 | 强度 |
|---|---|---|
| 行覆盖率(line) | 有多少行被执行过 | 最弱,容易被空行/注释抬高 |
| 语句覆盖率(statement) | 有多少语句被执行过 | 略强于行 |
| 分支覆盖率(branch) | 每个 if/三元/switch 的两个方向是否都走过 | 实用主力 |
| 函数覆盖率(function) | 有多少函数被调用过 | 适合粗筛「完全没测的文件」 |
if (user.isVip && order.total > 100) { // 2 个条件 → 分支覆盖要求 4 种组合
discount = 0.2;
}
行覆盖率 100% 只意味着这一行执行过——user.isVip 为 true、order.total 为 101 那一种组合走通了,其余三种可能全错。
覆盖率是必要非充分条件
设某函数有输入空间 ,测试用到的输入集合为 。覆盖率只度量「代码被触碰的比例」,不度量「 对 的代表性」:
它只与执行了哪些代码有关,与断言是否为真完全无关。因此 100% 覆盖率仍可能有 bug:
- 没有断言:
expect(fn()).toBeTruthy()之外还有fn()被调用但结果没被检查; - 断言太弱:
expect(result).toBeDefined()对任何返回值都成立; - 边界未测:
if (n > 0)只测了n = 5,没测n = 0、n = -1; - 组合未测:多个条件的分支组合没覆盖全;
- mock 掩盖了真实行为:见上文 mock 病症。
正确的心态
覆盖率用来找没被测到的代码(漏测线索),不是用来证明测试有效。它是一把手电筒,不是一张成绩单。
覆盖率门禁的合理用法与滥用
// ✅ 合理:防止倒退(ratchet,只升不降),按文件设阈值
coverageThreshold: {
global: { branches: 70, lines: 80 },
'./src/core/': { branches: 90, lines: 95 }, // 核心逻辑要求高
'./src/legacy/': { lines: 0 }, // 遗留代码不设卡
}
滥用形态:
- 全仓库卡 95% → 团队为了让 CI 变绿去写「只调用不断言」的测试 → 覆盖率上涨、质量下降;
- 卡总覆盖率而不看新增代码 → 老代码的高覆盖掩盖新代码的零覆盖;
- 用覆盖率作为绩效指标 → 立刻出现
/ istanbul ignore next /滥用。
推荐做法:对新增/改动代码设门禁(diff coverage,如「新增行覆盖率 ≥ 80%」),对整体只设防止倒退的下限。
TDD(测试驱动开发)
红-绿-重构(Red-Green-Refactor)三步循环:
1. Red 先写一条会失败的测试 → 明确「要什么行为」
2. Green 用最笨的办法让它通过 → 只追求正确,不追求漂亮
3. Refactor 在测试保护下改进设计 → 全绿即可放心改
↑______________________________________|
关键纪律:每次只前进一小步。Red 阶段先跑一遍确认它真的失败了——否则你可能写了条永远不会失败的测试(假绿)。
收益:
- 强制先想清接口与边界,减少返工;
- 天然高覆盖,且每条测试都对应一个需求;
- 小步前进,调试时间显著缩短。
代价:
- 学习曲线陡,前期速度肉眼可见地下降;
- 需求尚不明确时容易写成「测试牵着设计走」的伪需求;
- 对探索性任务几乎无效。
不适合 TDD 的场景
| 场景 | 原因 | 替代做法 |
|---|---|---|
| 探索性原型(spike) | 需求本身在变,测试会全部作废 | 先写代码摸清方案,稳定后再补测试 |
| UI 布局与视觉效果 | 「好看」难以断言 | 目视检查 / 视觉回归测试(截图对比) |
| 与第三方对接的第一次打通 | 对方行为未知 | 先手工打通,摸清契约后再补集成测试 |
| 一次性数据迁移脚本 | 生命周期极短 | 迁移前后校验数据量即可 |
务实建议
不必做「纯 TDD 信徒」。日常更实用的组合是:核心业务逻辑 TDD,胶水代码与 UI 后补测试。
遗留代码如何逐步补测
遗留代码(legacy code)的实用定义是「没有测试的代码」。直接上手写测试通常卡在「依赖太多,构造不出来」。Michael Feathers 的方法论是先找接缝(seam)——即「不改动代码就能替换行为的地方」。
补测顺序建议:
- 从最外层的纯函数开始:工具函数、格式化、金额计算,零依赖,最好测;
- 找接缝:把
new HttpClient()改成构造函数参数(这一步是重构,但极小); - 为「即将修改的地方」补测试,不要追求一次全覆盖;
- 写「特征测试」(characterization test):不断言「应该是什么」,而是记录「当前是什么」——先固定现状,再改;
- 每次改 bug 时,先写一条能复现它的测试,再修——这条测试从此永久防回归。
# 特征测试:不判断对错,只冻结当前行为
def test_遗留的_计算折扣_当前行为():
# 注意:这段逻辑看起来像 bug(先四舍五入再乘),但先锁住现状
assert legacy_discount(199.5) == 19.0
集成测试与端到端测试
数据库测试:事务回滚还是容器
| 方案 | 做法 | 优点 | 缺点 |
|---|---|---|---|
| 事务回滚 | 每个测试开事务,结束回滚 | 最快,隔离干净 | 被测代码若自己提交事务则失效;测不了跨事务行为 |
| 每次重建 schema | 测试前 DROP/CREATE | 语义最真实 | 慢(秒级/次) |
| 容器化数据库 | 测试启动 PostgreSQL/MySQL 容器 | 与生产同款,最真实 | 需要 Docker,启动慢(可用 session 级共享 + 每测试清表) |
| 内存数据库 | SQLite/H2 替代 | 极快 | 方言差异会掩盖真实问题(如外键、并发、类型) |
别用内存数据库替代生产数据库做集成测试
SQLite 与 PostgreSQL 在类型、约束、并发、函数上差异显著。用它跑出来的绿,是假绿。
测试数据工厂与 fixture
硬编码测试数据会随 schema 变化而全面崩坏。用工厂(factory)生成带默认值的对象:
# factory_boy 风格
class UserFactory(factory.Factory):
class Meta:
model = User
name = factory.Sequence(lambda n: f"用户{n}")
email = factory.LazyAttribute(lambda o: f"{o.name}@example.com")
is_vip = False
def test_普通用户不打折():
user = UserFactory() # 只关心默认值
assert calc_discount(user, 100) == 0
def test_VIP用户打九折():
user = UserFactory(is_vip=True) # 只覆盖本测试关心的字段
assert calc_discount(user, 100) == 90
原则:测试里出现的每个值,都应该是「本测试关心的那个维度」;其余一律交给工厂默认值。这样 schema 新增字段时,你只需要改工厂。
Playwright / Cypress 简介
| 对比项 | Playwright | Cypress |
|---|---|---|
| 维护方 | Microsoft | Cypress.io |
| 浏览器支持 | Chromium / Firefox / WebKit | Chromium 系为主,Firefox/WebKit 支持有限 |
| 运行模型 | 进程外驱动浏览器,支持多标签/多域名 | 运行在浏览器内,多域名需额外配置 |
| 语言 | JS/TS、Python、Java、.NET | JS/TS |
| 上手成本 | 略高(需 playwright install 下载浏览器) | 极低,交互式调试体验好 |
| 并行与分片 | 内置 --shard | 需 Cypress Cloud 或自建 |
# Playwright:安装与运行
npm init playwright@latest
npx playwright test # 无头并行跑全部
npx playwright test --ui # UI 模式,可时间旅行调试
npx playwright test --project=chromium # 只跑某个浏览器
npx playwright show-report # 打开 HTML 报告
E2E 只测核心用户路径
E2E 的正确职责不是「覆盖所有分支」,而是验证「系统能跑起来且主干流程通」。典型清单(电商为例):
- 首页能打开、关键商品能搜到;
- 加入购物车 → 结算 → 支付(用测试支付渠道)成功;
- 登录 / 登出;
- 订单列表能看到刚下的单。
四条就够。E2E 的失败原因大部分是环境问题(服务没起、数据被清、选择器漂移),它贵在告诉你「部署坏了」,不在告诉你「逻辑错了」。
flaky 测试的危害与治理
flaky 测试:同一份代码,有时通过有时失败。它的危害是系统性的:
- 团队学会「重跑一次就好了」→ 从此忽略所有失败 → 真 bug 被淹没;
- 分支保护形同虚设;
- 排查 flaky 比写新功能更让人抗拒,士气受损。
治理流程:
- 先隔离:把 flaky 测试标记为
skip或移到单独的 quarantine 套件,恢复主干的可信度; - 记录:建个 issue,写清失败率与报错;
- 定位常见根因:
| 根因 | 表现 | 修法 |
|---|---|---|
| 硬等待 | sleep(2) 偶发超时 | 改成条件等待(waitFor / expect(locator).toBeVisible()) |
| 顺序依赖 | 单独跑通过、全量跑失败 | 清理共享状态,开随机顺序 |
| 时间依赖 | 跨零点/月末失败 | 注入可控时钟 |
| 数据污染 | 并行跑互相改同一行数据 | 每个测试用自己的数据 |
| 动画/异步渲染 | 元素偶尔点不到 | 禁用动画,或用自动等待的定位器 |
| 网络与外部服务 | 偶发超时 | 固定网络 mock,或加大超时并重试 |
- 允许有限重试,但必须上报:
retries: 1可以救急,但要用报告把「重试后才通过」的测试单独列出来,否则重试只是把问题藏起来。
前端组件测试
Testing Library(React Testing Library / Vue Testing Library 等)的核心理念写在它的指导原则里:测试应该越接近用户使用软件的方式越好。
由此得出的查询优先级(官方文档明确列出):
| 优先级 | 查询方式 | 为什么 |
|---|---|---|
| 1 | getByRole(配合 name) | 无障碍树里的角色,最接近真实用户与辅助技术 |
| 2 | getByLabelText | 表单字段的就label文字,用户就是这么找的 |
| 3 | getByPlaceholderText | 次优(placeholder 不能替代 label) |
| 4 | getByText | 非交互元素的可见文本 |
| 5 | getByDisplayValue | 已填表单的当前值 |
| 6 | getByAltText / getByTitle | 语义化属性 |
| 7 | getByTestId | 最后手段,用户看不到它 |
// ❌ 绑定 class 与实现细节:改样式就红,改行为却不红
const { container } = render(<Login />);
expect(container.querySelector('.btn-primary')).toBeTruthy();
// ✅ 按角色与可访问名称查询:改样式不影响,改行为立刻红
render(<Login />);
const input = screen.getByLabelText('用户名'); // 对应 <label for>
await userEvent.type(input, 'alice');
await userEvent.click(screen.getByRole('button', { name: /登录/i }));
expect(await screen.findByText('欢迎,alice')).toBeInTheDocument();
getBy / queryBy / findBy* 的区别(官方总结表):
| 查询 | 0 个匹配 | 1 个匹配 | 多个匹配 | 是否重试 |
|---|---|---|---|---|
getBy... | 抛错 | 返回元素 | 抛错 | 否 |
queryBy... | 返回 null | 返回元素 | 抛错 | 否 |
findBy... | 抛错 | 返回元素 | 抛错 | 是(异步) |
断言「元素不存在」只能用 queryBy——用 getBy 会因为抛错而让测试失败,用 findBy 会等超时。
快照测试的陷阱
快照测试(snapshot testing)把渲染结果序列化存盘,之后对比差异。
陷阱:
- 快照被当成「正确答案」:
--updateSnapshot一按,什么 bug 都被「批准」了; - 快照太大:一个组件几百行 DOM,diff 里根本看不出改了什么;
- 快照只反映结构不反映行为:改了文案要更新快照,但没人会认真读 diff;
- 多人协作下快照冲突:每次格式化工具升级都会产生大量无意义改动。
合理用法:只对稳定、小、有意义的结构做快照(如序列化后的 API 响应、错误消息文本、内联样式对象),而不是整个页面 DOM。
性能与稳定性:让测试跑得快
慢测试 = 没人跑的测试。三条主线:
1. 并行
npx jest --maxWorkers=50% # 用到一半 CPU 核心
npx vitest run --pool=threads # 线程池并行
pytest -n auto # 需要 pytest-xdist
dotnet test --parallel # 项目级并行
2. 只跑受影响的测试
npx vitest run --changed HEAD~1 # 只跑被最近一次提交影响的测试
npx jest --onlyChanged # Jest 的对应选项
pytest --testmon # 需要 pytest-testmon 插件
3. CI 分层执行
# .github/workflows/ci.yml(示意)
jobs:
fast: # 每个 PR 都跑:静态检查 + 单元测试,目标 < 3 分钟
steps:
- run: npm run lint
- run: npm run test:unit
slow: # 合并到主干或定时跑:集成 + E2E
if: github.ref == 'refs/heads/main'
steps:
- run: npm run test:integration
- run: npx playwright test
用耗时估算设预算
若 CI 目标 s,单元测试 条、单条 ms、并行度 ,则
要满足 s,可容纳 条。单元测试几乎不可能成为瓶颈——瓶颈永远在集成与 E2E。所以优化顺序是:把 E2E 缩到最小,把逻辑下沉到单元测试。
完整单元测试示例:正常路径 + 边界 + 异常路径
被测代码(discount.py):
from decimal import Decimal, ROUND_HALF_UP
class InvalidAmountError(ValueError):
"""金额非法时抛出。"""
def apply_discount(total, is_vip=False):
"""按会员等级与金额计算折扣后价格。
规则:
- 金额必须为非负数,否则抛 InvalidAmountError
- VIP 用户打 9 折
- 非 VIP 且满 200 减 20
- 结果保留两位小数(四舍五入)
"""
if total is None or Decimal(str(total)) < 0:
raise InvalidAmountError(f"金额不能为负: {total}")
amount = Decimal(str(total))
if is_vip:
amount = amount * Decimal("0.9")
elif amount >= 200:
amount = amount - 20
return float(amount.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP))
三组用例(test_discount.py):
import pytest
from discount import apply_discount, InvalidAmountError
# ── 第一组:正常路径(Happy Path)──────────────────────────
class Test正常路径:
def test_非VIP_未满200_不打折(self):
assert apply_discount(199) == 199.00
def test_非VIP_刚好满200_减20(self):
assert apply_discount(200) == 180.00
def test_VIP_打九折(self):
assert apply_discount(100, is_vip=True) == 90.00
def test_VIP_优先于满减(self):
# VIP 与满减是互斥分支,VIP 时不应再减 20
assert apply_discount(300, is_vip=True) == 270.00
# ── 第二组:边界值(Boundary)─────────────────────────────
class Test边界值:
def test_金额为0_返回0(self):
assert apply_discount(0) == 0.00
def test_金额为199_99_不减(self):
assert apply_discount(199.99) == 199.99
def test_金额为200_00_恰好减(self):
assert apply_discount(200.00) == 180.00
def test_四舍五入到两位小数(self):
# 0.905 → 0.91(HALF_UP),验证取整策略而非默认的银行家舍入
assert apply_discount(1.005) == 1.01
def test_极小正数不丢失(self):
assert apply_discount(0.01) == 0.01
# ── 第三组:异常路径(Error Path)──────────────────────────
class Test异常路径:
def test_负数金额抛异常(self):
with pytest.raises(InvalidAmountError):
apply_discount(-1)
def test_None抛异常(self):
with pytest.raises(InvalidAmountError):
apply_discount(None)
def test_异常信息包含非法值(self):
# 断言消息内容,方便线上排错
with pytest.raises(InvalidAmountError, match="-5"):
apply_discount(-5)
@pytest.mark.parametrize("bad", [-0.01, -100, None])
def test_参数化非法输入(self, bad):
with pytest.raises(InvalidAmountError):
apply_discount(bad)
运行:
pip install pytest
pytest test_discount.py -v # 逐条列出
pytest test_discount.py --cov=discount # 需要 pytest-cov
pytest test_discount.py -k 边界 # 只跑名字匹配的用例
为什么这三组缺一不可
正常路径证明「功能能用」;边界值证明「临界条件处理正确」(历史上绝大多数线上事故发生在边界);异常路径证明「错误输入不会静默产生错误结果」——这是最容易被跳过、也最容易造成资损的一组。
怎么用
完整配置文件
Jest(jest.config.js)
// Jest 官方推荐用独立配置文件;文件名 jest.config.js|ts|mjs|json 会被自动发现
const { defineConfig } = require('jest');
module.exports = defineConfig({
testEnvironment: 'jsdom', // 前端组件测试用 jsdom;纯 Node 用 'node'
roots: ['<rootDir>/src'],
testMatch: ['**/*.test.{js,ts,tsx}'],
setupFilesAfterEnv: ['<rootDir>/jest.setup.ts'],
clearMocks: true, // 每个测试前清空 mock 调用记录
restoreMocks: true, // 同时还原被 mock 的实现
randomize: true, // 随机顺序,暴露顺序依赖
collectCoverageFrom: [ // 未导入的文件也纳入统计
'src/**/*.{js,ts,tsx}',
'!src/**/*.d.ts',
'!src/**/index.ts',
],
coverageProvider: 'v8', // 比 babel 快,V8 原生覆盖
coverageReporters: ['text', 'lcov', 'html'],
coverageThreshold: {
global: { branches: 70, functions: 75, lines: 80, statements: 80 },
'./src/core/': { branches: 90, lines: 95 }, // 核心逻辑单独设卡
},
maxWorkers: '50%', // 并行,别把本机跑死
testTimeout: 10000, // 单条超时(默认 5s 偏紧)
});
Vitest(vitest.config.ts)
import { defineConfig } from 'vitest/config';
export default defineConfig({
test: {
environment: 'jsdom',
include: ['src/**/*.{test,spec}.{ts,tsx}'],
globals: true, // 免去 import { test, expect }
setupFiles: ['./vitest.setup.ts'],
clearMocks: true,
restoreMocks: true,
// 顺序与并行
sequence: { shuffle: true },
pool: 'threads',
maxWorkers: '50%',
coverage: {
provider: 'v8', // 或 'istanbul'(需要 @vitest/coverage-istanbul)
enabled: false, // 用 CLI 的 --coverage 按需开启
include: ['src/**/*.{ts,tsx}'],
exclude: ['**/*.d.ts', '**/main.ts'],
reporter: ['text', 'lcov'],
thresholds: {
lines: 80,
branches: 70,
functions: 75,
statements: 80,
},
},
},
});
pytest(pyproject.toml)
[tool.pytest.ini_options]
minversion = "7.0"
testpaths = ["tests"]
addopts = [
"-ra", # 显示跳过/预期失败的原因摘要
"--strict-markers", # 未注册的 marker 直接报错,避免拼错标记
"--strict-config",
]
markers = [
"slow: 标记为慢测试,默认可用 -m 'not slow' 排除",
"integration: 需要真实数据库或网络的集成测试",
]
[tool.coverage.run]
branch = true # 开启分支覆盖
source = ["src"]
[tool.coverage.report]
show_missing = true
fail_under = 80 # 覆盖率低于 80% 直接失败
exclude_lines = [
"pragma: no cover",
"if TYPE_CHECKING:",
"raise NotImplementedError",
]
conftest.py(pytest 的共享 fixture 入口)
import pytest
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
@pytest.fixture(scope="session")
def engine():
# 整个测试会话共用一个引擎,避免重复建连接池
return create_engine("postgresql://test:test@localhost:5432/testdb")
@pytest.fixture
def db_session(engine):
"""每个测试一个事务,结束回滚 —— 测试之间零污染。"""
connection = engine.connect()
transaction = connection.begin()
Session = sessionmaker(bind=connection)
session = Session()
try:
yield session
finally:
session.close()
transaction.rollback() # 无论成功失败都回滚
connection.close()
@pytest.fixture
def fixed_clock(monkeypatch):
"""把时间冻结在固定时刻,消除时间依赖导致的 flaky。"""
from datetime import datetime
class FixedDatetime(datetime):
@classmethod
def now(cls, tz=None):
return cls(2026, 10, 11, 12, 0, 0)
monkeypatch.setattr("discount.datetime", FixedDatetime)
.NET(MyApp.Tests.csproj)
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net10.0</TargetFramework>
<Nullable>enable</Nullable>
<IsPackable>false</IsPackable>
<TestingPlatformDotnetTestSupport>true</TestingPlatformDotnetTestSupport>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="xunit.v3" Version="3.*" />
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.*" />
<PackageReference Include="coverlet.collector" Version="6.*" />
</ItemGroup>
</Project>
版本以官方最新文档为准
上面的版本号用了通配符,实际项目请锁定版本(见 工具-03-包管理器)。.NET 的测试平台正从 VSTest 迁移到 Microsoft.Testing.Platform(MTP),配置项可能变化,以 Microsoft Learn 的 .NET 测试文档为准。
可执行命令清单
# ── 安装 ─────────────────────────────────────────────
npm i -D jest # 或 npm i -D vitest
npm i -D @vitest/coverage-v8 # Vitest 覆盖率(v8)
pip install pytest pytest-cov pytest-xdist # Python
dotnet new xunit -o MyApp.Tests # .NET 新建测试项目
# ── 运行 ─────────────────────────────────────────────
npx jest # 全部(watch 需 --watch)
npx jest --coverage # 带覆盖率
npx jest --watch # 只跑受影响的(开发时)
npx vitest run # 注意:vitest 默认 watch,CI 用 run
npx vitest run --coverage
npx vitest --ui # 图形界面
pytest -q # 安静模式
pytest -x # 首个失败即停
pytest -k "边界" # 按名字过滤
pytest -m "not slow" # 按 marker 过滤
pytest -n auto --dist loadfile # 并行
dotnet test # 全部测试项目
dotnet test --filter "FullyQualifiedName~Discount"
dotnet test --collect:"XPlat Code Coverage" # 覆盖率
# ── E2E ──────────────────────────────────────────────
npx playwright install --with-deps # 安装浏览器与依赖
npx playwright test --headed # 显示浏览器窗口
npx playwright test --ui # 交互式调试
常见坑
十个高频错误
1. 测试之间共享状态:单跑通过、全量失败。用
beforeEach重建状态,并开启随机顺序执行。2. 异步测试忘记
await/return:测试永远是绿的,因为断言根本没执行。断言 reject 分支时加expect.assertions(n)。3. 断言太弱:
toBeDefined()、toBeTruthy()几乎对任何值都成立。断言具体的值与结构。4. 只测正常路径:线上事故绝大多数发生在边界与异常输入上。
5. 过度 mock:mock 掉一切之后,测试只验证了「你的假设」,而不是「真实行为」。尤其是别 mock 数据库来替代集成测试。
6. 断言实现细节:断言私有方法被调用、断言 class 名、断言 DOM 结构。重构即全红,团队随后不再信任测试。
7. 用
sleep等待:sleep(2)在慢 CI 上依然不够,在快机器上纯浪费。改成条件等待。8. 快照随手更新:
--updateSnapshot变成了「让 CI 变绿」的按钮,等于关掉了测试。9. 在测试里捕获异常后不失败:
try: ... except: pass—— 测试永远不会红。10. 把覆盖率当 KPI:立刻出现「调用但不断言」的凑数测试与
ignore注释滥用。
测试数据污染生产
集成/E2E 测试的连接串、API 密钥必须来自测试专用配置。曾多次出现「E2E 测试往生产库写数据」的事故。上线前检查:
TEST_DATABASE_URL是否指向生产?测试用户是否真的是只读账号?见 后端-08-部署与运维基础。
练习题
- 测试金字塔判断:下面四条测试,分别属于单元、集成还是 E2E?说明理由。
(a) 调用 applyDiscount(200) 断言返回 180;
(b) 启动 FastAPI 应用,用 TestClient 发 POST /orders,断言数据库里多了一条记录;
(c) 用 Playwright 打开首页,点击「加入购物车」,断言页面出现「结算」按钮;
(d) 用 unittest.mock 替换 requests.get,断言 fetch_price() 解析出正确价格。
- 写三组用例:为下面的函数写出正常路径、边界值、异常路径各至少两条测试(pytest 或 Jest 均可)。
```python
def paginate(items, page, size=10):
"""返回第 page 页(从 1 开始)的数据。page < 1 或 size < 1 抛 ValueError。"""
```
要求:至少覆盖「最后一页不足 size」「页码超出范围」「空列表」三种情况。
- 该不该 mock:你要测试
UserService.register(),它会:校验邮箱格式 → 查数据库确认邮箱未占用 → 写库 → 发送欢迎邮件 → 写审计日志。请为每一步选择「真实使用 / 替换为测试替身 / 替换成哪种替身」,并说明理由。
- 覆盖率分析:某函数行覆盖率 100%、分支覆盖率 50%。请构造一段代码,说明这种情况下仍然可能漏掉真实 bug,并写出能把它抓出来的测试思路。
- flaky 治理:某条 E2E 测试在 CI 上约 10% 概率失败,报错为「等待元素
.submit-btn超时」。请列出三种可能根因,以及各自的修法与验证方式。
FAQ
单元测试和集成测试的界线到底在哪?
判断标准只有一个:是否使用了真实的、被测系统之外的依赖(数据库、网络、文件系统、时钟)。全部替换成替身 → 单元测试;含至少一个真实外部依赖 → 集成测试。同一条测试可能既是「多模块」又是「单元」——例如测两个纯函数组合,没有外部依赖,仍算单元测试。.NET 官方文档的说法是:单元测试不测试基础设施问题(数据库、文件系统、网络),集成测试则练习两个或更多组件协同工作。
覆盖率应该定多少?我们团队在争论 60% 还是 90%。
没有普适数字,但有三条可操作的建议:(1) 对新增/改动的代码要求高(如新增行 ≥ 80%),对历史代码不设卡;(2) 整体覆盖率只做「防倒退」(棘轮机制,不允许下降);(3) 对核心逻辑(金额、权限、状态机)单独设高阈值,对 UI 装配层、自动生成的代码、纯类型定义不设卡。争数字不如争「有没有测边界和异常」。
TDD 真的能提高效率吗,还是只是教条?
在需求相对明确、逻辑可判定的场景(金额计算、状态机、解析器、协议实现),TDD 通常净收益为正,因为它把「调试」换成了「小步验证」。在探索性、UI 布局、第三方首次对接场景,TDD 往往净损失。务实的团队做法是:核心逻辑 TDD,外围后补测试,并且每个 bug 修复都先写一条复现测试——这一条纪律的投入产出比最高。
测试写不完,需求一直在变,测试老是红怎么办?
三个方向同时做:(1) 只测行为,不测实现——按用户视角断言(输入输出、可见结果),需求演进时测试不必跟着改;(2) 降低脆弱性——禁止断言私有方法、内部调用顺序、DOM 类名;(3) 缩到核心——先给最贵的那部分逻辑(钱、权限、数据一致性)写测试,其余靠集成测试兜底。测试全红且无人修,比没有测试更糟:它会训练团队忽略失败。
相关笔记
- 工具-07-调试技巧:测试失败后如何定位根因——断点、日志、二分排查。
- 工具-08-CICD入门:把测试挂到流水线上,让分支保护真正生效。
- 工具-03-包管理器:测试框架依赖的安装、版本锁定与锁文件。
- 后端-09-后端安全与性能:安全测试与性能测试的位置。
- JavaScript-04-异步编程:理解 Promise 与事件循环,才能写对异步测试。
- Python-05-异常与文件IO:异常类型设计直接影响异常路径测试的写法。
参考来源
- Jest — Getting Started(安装、配置发现机制、
test.each提示) - Jest — Testing Asynchronous Code(Promise / async-await /
.resolves/.rejects/done的正确写法与警告) - Jest — Configuring Jest(
randomize、clearMocks、coverageThreshold、collectCoverageFrom等配置项) - Vitest — Getting Started(安装、
vitest run与 watch 模式的区别) - Vitest — Coverage(v8 与 istanbul 两种 provider 的取舍、
coverage.include的作用) - pytest — How to parametrize fixtures and test functions(
@pytest.mark.parametrize、堆叠参数化、pytest.param与 xfail) - pytest — How to use fixtures(fixture 复用、scope 语义、yield 清理、安全 teardown 结构)
- Python 官方文档 — unittest 单元测试框架(
TestCase、setUp/tearDown语义、subTest、断言方法表) - Microsoft Learn — 在 .NET 中进行测试(单元/集成/负载测试的界定,MSTest、NUnit、TUnit、xUnit.net 的官方定位)
- Testing Library — About Queries(查询优先级、
getBy/queryBy/findBy对照表、反对按 class 查询的理由) - Playwright — Installation(安装、
--ui、show-report、系统要求)
版本提示
本文涉及的框架版本(Jest、Vitest、pytest、xUnit.net、Playwright)更新频繁,配置项与默认值可能变化,请以各自官方文档为准。文中链接均已于撰写时验证可访问。