w wyl123ly 的博客
MD

工具-04-测试基础

51 KB 2026.10.11 原文件

工具-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-Thengiven_total_200_when_checkout_then_discount_30业务规则复杂时
三层 describe/itdescribe('购物车') > it('满200减30')JS 生态,输出分层清晰

命名反模式

test1、test_calc、test_works、testFixBug——这类名字在 CI 报告里等于噪声。测试名应该能让没读过代码的人判断这条测试保护的是什么规则。

断言与框架

语言主流框架断言库运行命令
JavaScript / TypeScriptJest、Vitest内置 expectnpx jest / npx vitest run
Pythonpytest、unittest内置 assert / unittest.TestCase.assert*pytest / python -m unittest
C# / .NETxUnit.net、NUnit、MSTestxUnit Assert.* / FluentAssertionsdotnet 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 会产生三类典型病症:

  1. 测试与实现强耦合:把内部函数名、调用顺序写进断言。重构(不改行为)→ 测试全红 → 团队开始不信任测试。
  2. 测试通过但线上崩:mock 掉的是「你以为的」依赖行为。真实 API 返回 null 而不是空数组、真实数据库有唯一约束——mock 不会告诉你。
  3. 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('网络错误');
});

三条铁律:

  1. 必须 return 或 await,否则测试会在异步完成前结束(Jest 官方文档明确警告这一点)。
  2. 断言 reject 分支时,给测试加 expect.assertions(n),避免「没进 catch 也算通过」。
  3. 回调风格的 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)——即「不改动代码就能替换行为的地方」。

补测顺序建议:

  1. 从最外层的纯函数开始:工具函数、格式化、金额计算,零依赖,最好测;
  2. 找接缝:把 new HttpClient() 改成构造函数参数(这一步是重构,但极小);
  3. 为「即将修改的地方」补测试,不要追求一次全覆盖;
  4. 写「特征测试」(characterization test):不断言「应该是什么」,而是记录「当前是什么」——先固定现状,再改;
  5. 每次改 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 简介
对比项PlaywrightCypress
维护方MicrosoftCypress.io
浏览器支持Chromium / Firefox / WebKitChromium 系为主,Firefox/WebKit 支持有限
运行模型进程外驱动浏览器,支持多标签/多域名运行在浏览器内,多域名需额外配置
语言JS/TS、Python、Java、.NETJS/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 的正确职责不是「覆盖所有分支」,而是验证「系统能跑起来且主干流程通」。典型清单(电商为例):

  1. 首页能打开、关键商品能搜到;
  2. 加入购物车 → 结算 → 支付(用测试支付渠道)成功;
  3. 登录 / 登出;
  4. 订单列表能看到刚下的单。

四条就够。E2E 的失败原因大部分是环境问题(服务没起、数据被清、选择器漂移),它贵在告诉你「部署坏了」,不在告诉你「逻辑错了」。

flaky 测试的危害与治理

flaky 测试:同一份代码,有时通过有时失败。它的危害是系统性的:

  • 团队学会「重跑一次就好了」→ 从此忽略所有失败 → 真 bug 被淹没;
  • 分支保护形同虚设;
  • 排查 flaky 比写新功能更让人抗拒,士气受损。

治理流程:

  1. 先隔离:把 flaky 测试标记为 skip 或移到单独的 quarantine 套件,恢复主干的可信度;
  2. 记录:建个 issue,写清失败率与报错;
  3. 定位常见根因:
根因表现修法
硬等待sleep(2) 偶发超时改成条件等待(waitFor / expect(locator).toBeVisible())
顺序依赖单独跑通过、全量跑失败清理共享状态,开随机顺序
时间依赖跨零点/月末失败注入可控时钟
数据污染并行跑互相改同一行数据每个测试用自己的数据
动画/异步渲染元素偶尔点不到禁用动画,或用自动等待的定位器
网络与外部服务偶发超时固定网络 mock,或加大超时并重试
  1. 允许有限重试,但必须上报:retries: 1 可以救急,但要用报告把「重试后才通过」的测试单独列出来,否则重试只是把问题藏起来。

前端组件测试

Testing Library(React Testing Library / Vue Testing Library 等)的核心理念写在它的指导原则里:测试应该越接近用户使用软件的方式越好。

由此得出的查询优先级(官方文档明确列出):

优先级查询方式为什么
1getByRole(配合 name)无障碍树里的角色,最接近真实用户与辅助技术
2getByLabelText表单字段的就label文字,用户就是这么找的
3getByPlaceholderText次优(placeholder 不能替代 label)
4getByText非交互元素的可见文本
5getByDisplayValue已填表单的当前值
6getByAltText / getByTitle语义化属性
7getByTestId最后手段,用户看不到它
// ❌ 绑定 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-部署与运维基础。

练习题

  1. 测试金字塔判断:下面四条测试,分别属于单元、集成还是 E2E?说明理由。

(a) 调用 applyDiscount(200) 断言返回 180;

(b) 启动 FastAPI 应用,用 TestClient 发 POST /orders,断言数据库里多了一条记录;

(c) 用 Playwright 打开首页,点击「加入购物车」,断言页面出现「结算」按钮;

(d) 用 unittest.mock 替换 requests.get,断言 fetch_price() 解析出正确价格。

  1. 写三组用例:为下面的函数写出正常路径、边界值、异常路径各至少两条测试(pytest 或 Jest 均可)。

```python

def paginate(items, page, size=10):

"""返回第 page 页(从 1 开始)的数据。page < 1 或 size < 1 抛 ValueError。"""

```

要求:至少覆盖「最后一页不足 size」「页码超出范围」「空列表」三种情况。

  1. 该不该 mock:你要测试 UserService.register(),它会:校验邮箱格式 → 查数据库确认邮箱未占用 → 写库 → 发送欢迎邮件 → 写审计日志。请为每一步选择「真实使用 / 替换为测试替身 / 替换成哪种替身」,并说明理由。
  1. 覆盖率分析:某函数行覆盖率 100%、分支覆盖率 50%。请构造一段代码,说明这种情况下仍然可能漏掉真实 bug,并写出能把它抓出来的测试思路。
  1. 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、Vitest、pytest、xUnit.net、Playwright)更新频繁,配置项与默认值可能变化,请以各自官方文档为准。文中链接均已于撰写时验证可访问。