---
title: 工具-04-测试基础
aliases:
  - 测试基础
  - Unit Testing
  - 单元测试
  - 测试金字塔
tags:
  - 工具/工程化
  - 类型/教程
created: 2026-10-11
updated: 2026-10-11
level: 进阶
prerequisites:
  - "[[Python-01-环境与基础语法]]"
  - "[[JavaScript-01-基础语法与类型]]"
sources:
  - https://jestjs.io/docs/getting-started
  - https://jestjs.io/docs/asynchronous
  - https://jestjs.io/docs/configuration
  - https://vitest.dev/guide/
  - https://vitest.dev/guide/coverage
  - https://docs.pytest.org/en/stable/how-to/parametrize.html
  - https://docs.pytest.org/en/stable/how-to/fixtures.html
  - https://docs.python.org/zh-cn/3/library/unittest.html
  - https://learn.microsoft.com/zh-cn/dotnet/core/testing/
  - https://testing-library.com/docs/queries/about/
  - https://playwright.dev/docs/intro
---

# 工具-04-测试基础

> [!abstract] 这篇笔记讲什么
> 自动化测试（automated testing）是「让机器替你确认代码没坏」的工程手段。本篇从**为什么必须写测试**讲到**怎么写才算好测试**：测试金字塔、AAA 结构、断言与框架选型、测试替身（test double）、覆盖率、TDD、集成与端到端测试、前端组件测试，以及一条完整的单元测试示例。
> 读完你应该能：为一个函数写出正常路径 + 边界 + 异常三组用例，能判断某个依赖「该不该 mock」，能解释为什么 100% 覆盖率仍然可能线上崩溃。

## 是什么

**测试**就是一段代码，它调用另一段代码，然后断言（assert）结果符合预期。

一个最小的单元测试长这样（Jest / Vitest 风格）：

```js
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） | 整个系统，从用户界面到数据库 | 是 | 秒到分钟级 |

> [!note] 术语原文
> 单元测试 = unit test；集成测试 = integration test；端到端测试 = end-to-end test（E2E）；断言 = assertion；测试替身 = test double；覆盖率 = coverage；持续集成 = continuous integration（CI）；测试驱动开发 = test-driven development（TDD）。

## 为什么需要它

### 1. 重构的安全网

重构（refactoring）的定义是「不改变外部行为的前提下调整内部结构」。**没有测试，你根本无法确认「外部行为没变」**——只能靠人肉点页面，而人肉点击是不可重复、不可穷尽的。有了测试，重构变成「改代码 → 跑测试 → 全绿 → 提交」，从「胆子活」变成「体力活」。

### 2. 缺陷修复成本随阶段指数增长

这是软件工程里最经得起检验的经验规律之一。设第 $i$ 个阶段发现并修复一个缺陷的成本为 $C_i$，则大致满足：

$$
C_i \approx C_0 \cdot k^{\,i}, \quad k \approx 5 \sim 10
$$

其中 $C_0$ 是编码期修复成本。取 $k = 8$，各阶段的相对成本：

| 阶段 | 相对成本 $C_i / C_0$ | 典型表现 |
|---|---|---|
| 需求/设计 | $1/8$ | 改一句话 |
| 编码（本地测试发现） | $1$ | 改几行，跑一下测试 |
| 提交 / CI 阶段 | $8$ | 修提交、重跑流水线 |
| 测试环境 | $64$ | 查日志、复现、定位 |
| 生产环境 | $512$ | 停机、回滚、道歉、补数据 |

结论不是「测试能省钱」这么含糊，而是：**越早拦住的缺陷越便宜，而自动化测试是目前最便宜的「早拦住」手段**。

### 3. 测试即活文档（executable documentation）

注释会腐烂，文档会过期，只有测试会被 CI 强制执行——**它一旦不真实就会变红**。新人读 `test('订单金额为 0 时抛异常')` 立刻知道业务规则，比读三十行注释快。

### 4. 真实事故：改一行，修好三处坏五处

一个在真实项目里反复上演的场景：

```text
需求：把「满 200 减 20」改成「满 200 减 30」
改动：一行常量
结果：
  ✓ 优惠计算修正了
  ✓ 顺手修好了「优惠叠加」的判断
  ✓ 顺手修好了发票金额取整
  ✗ 购物车小计错了（用了优惠后的金额）
  ✗ 订单列表金额错了
  ✗ 退款金额错了
  ✗ 对账接口签名校验失败
  ✗ 历史订单查询慢查询告警
```

这正是没有测试的典型形态：**改动的爆炸半径（blast radius）不可见**。有测试时，四处标红，你在本地五分钟内就知道自己踩了什么；没有测试时，你在生产环境用两小时才知道。

> [!important] 一句话记住
> 测试不是为了证明代码是对的，而是为了**在改动后立刻知道哪里坏了**。

## 核心内容

### 测试金字塔（test pyramid）

Mike Cohn 提出的经典模型：底层多、上层少。

```text
        ╱╲          E2E 测试：少量，只覆盖核心用户路径
       ╱  ╲         慢、脆、贵、覆盖广
      ╱────╲
     ╱      ╲       集成测试：中等数量，覆盖模块协作与真实依赖
    ╱────────╲      中等速度、中等脆弱
   ╱          ╲
  ╱────────────╲    单元测试：大量，覆盖每个分支与边界
 ╱______________╲   快、稳、便宜、精准
```

| 维度 | 单元测试 | 集成测试 | E2E 测试 |
|---|---|---|---|
| 数量占比（经验值） | 约 70% | 约 20% | 约 10% |
| 单条耗时 | $1 \sim 50$ ms | $50$ ms $\sim$ 数秒 | $5$ s $\sim$ 数分钟 |
| 编写成本 | 低 | 中 | 高 |
| 维护成本 | 低（不依赖环境） | 中 | 高（选择器/环境/数据） |
| 定位失败原因的难度 | 低（直指函数） | 中 | 高（不知哪一层坏） |
| 能发现的问题 | 逻辑错误、边界错误 | 接口不匹配、SQL 错误、序列化问题 | 流程断裂、部署配置错误 |
| 是否依赖真实环境 | 否 | 是（可容器化） | 是 |

用耗时估算说明为什么必须分层。设单元测试 $n_u$ 条、集成测试 $n_i$ 条、E2E $n_e$ 条，串行总耗时为：

$$
T_{\text{serial}} = n_u t_u + n_i t_i + n_e t_e
$$

代入 $n_u = 1000,\ t_u = 5\ \text{ms}$；$n_i = 100,\ t_i = 500\ \text{ms}$；$n_e = 20,\ t_e = 20\ \text{s}$：

$$
T_{\text{serial}} = 1000 \times 0.005 + 100 \times 0.5 + 20 \times 20 = 5 + 50 + 400 = 455\ \text{s}
$$

注意：**20 条 E2E 占了总耗时的 88%**。若把 E2E 也写成 1000 条，光 E2E 就是 $5.5$ 小时——没人会等，于是测试形同废弃。所以「金字塔」的本质是**成本与反馈速度的权衡**，不是审美偏好。

### 冰淇淋反模式与测试奖杯

**冰淇淋反模式（ice cream cone anti-pattern）**：手工测试最多 → E2E 一大堆 → 集成一堆 → 单元几乎没有。形状倒过来，后果是测试套件越跑越慢、越跑越红、最后被 `--skip` 掉。它通常不是被设计出来的，而是**逐步长歪**的：每次出事故都补一条 E2E，从不补单元测试。

**测试奖杯（testing trophy）**是 Kent C. Dodds 针对前端提出的补充视角：底座是静态检查（TypeScript / ESLint），中间**最厚的一层是集成测试**，顶部才是 E2E，单元测试很薄。理由很务实：前端组件的价值大多在「组合与交互」上，纯函数式的单元测试覆盖不到真正的风险，而大量前端单元测试容易退化为「测试实现细节」。

> [!tip] 两个模型怎么选
> 后端业务逻辑（金额、权限、状态机）→ 金字塔，单元测试为主。
> 前端 UI 组件 → 奖杯，静态检查 + 组件级集成测试为主。
> 两者不冲突：都是「把测试放在性价比最高的层」。

### 单元测试结构

#### AAA 模式（Arrange-Act-Assert）

三段式：**准备 → 执行 → 断言**。每个测试都应该是这三段，且**只有一段 Act**。

```python
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（那么应如此）。测试名可以直接用这个句式，可读性最好。

#### 一个测试只验证一件事

```python
# ❌ 反例：失败了不知道坏在哪
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 生态，输出分层清晰 |

> [!warning] 命名反模式
> `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）。

#### 参数化测试

同一个逻辑跑多组数据，避免复制粘贴：

```js
// 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);
});
```

```python
# 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
```

> [!tip] 参数化测试的价值在「用例名」
> 失败时输出会是 `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 是「查行为」**：它自己带着期望（「必须被调用一次」）。测试的断言部分是**由替身完成的**。

```python
# 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"]   # 断言在替身上
```

> [!important] 判据
> 如果一条测试在**替身**上做断言（调用次数、参数），它是行为验证；如果在**返回值/状态**上断言，它是状态验证。状态验证更稳，行为验证更准——但更容易碎。

#### 什么时候不该 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 依赖」的代码：

```python
# ❌ 无法测试：内部硬编码了真实 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）

测试必须满足：**任意顺序、单独运行、重复运行，结果都一样**。

破坏独立性的元凶是共享状态：

```python
# ❌ 顺序依赖：单跑 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；
- 打开**随机顺序执行**，把隐藏的顺序依赖暴露出来：

```bash
# Jest：按文件级随机
npx jest --randomize
# Vitest：随机顺序 + 固定种子便于复现
npx vitest run --sequence.shuffle --sequence.seed=42
# pytest：需要插件
pip install pytest-randomly
pytest -p randomly
```

> [!tip] 为什么随机顺序值得开
> 顺序依赖的测试在 CI 上会以「flaky（时好时坏）」的面目出现，排查成本极高。随机顺序把它变成**一条稳定的失败**，问题立刻可定位。

### 异步代码测试

异步测试最常见的 bug 是**测试跑完了，异步操作还没结束**——于是断言从未执行，测试永远是绿的。

```js
// ❌ 假绿：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)` 就让整个套件多一秒。

```js
// ❌ 真实等待：慢且不稳（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();                  // 记得还原，避免污染其他测试
});
```

> [!warning] 假定时器的常见坑
> - 忘记 `useRealTimers()` → 后续测试里所有 `setTimeout` 都不再前进，测试挂死。
> - 假定时器与 `await` 混用：`await` 依赖微任务队列，通常仍工作，但依赖真实定时器的第三方库会卡住。
> - 测试「节流」时要断言**中间状态**，只断言最终结果无法区分防抖与节流。

### 测试覆盖率（code coverage）

覆盖率衡量「测试执行到了多少代码」，四种常见口径：

| 口径 | 含义 | 强度 |
|---|---|---|
| 行覆盖率（line） | 有多少行被执行过 | 最弱，容易被空行/注释抬高 |
| 语句覆盖率（statement） | 有多少语句被执行过 | 略强于行 |
| 分支覆盖率（branch） | 每个 `if`/三元/`switch` 的两个方向是否都走过 | 实用主力 |
| 函数覆盖率（function） | 有多少函数被调用过 | 适合粗筛「完全没测的文件」 |

```text
if (user.isVip && order.total > 100) {   // 2 个条件 → 分支覆盖要求 4 种组合
  discount = 0.2;
}
```

行覆盖率 100% 只意味着这一行执行过——**`user.isVip` 为 true、`order.total` 为 101 那一种组合**走通了，其余三种可能全错。

#### 覆盖率是必要非充分条件

设某函数有输入空间 $D$，测试用到的输入集合为 $E \subseteq D$。覆盖率只度量「代码被触碰的比例」，不度量「$E$ 对 $D$ 的代表性」：

$$
\text{Coverage} = \frac{|\{\text{被执行的代码单元}\}|}{|\{\text{全部代码单元}\}|}
$$

它只与**执行了哪些代码**有关，与**断言是否为真**完全无关。因此 100% 覆盖率仍可能有 bug：

- **没有断言**：`expect(fn()).toBeTruthy()` 之外还有 `fn()` 被调用但结果没被检查；
- **断言太弱**：`expect(result).toBeDefined()` 对任何返回值都成立；
- **边界未测**：`if (n > 0)` 只测了 `n = 5`，没测 `n = 0`、`n = -1`；
- **组合未测**：多个条件的分支组合没覆盖全；
- **mock 掩盖了真实行为**：见上文 mock 病症。

> [!important] 正确的心态
> 覆盖率用来找**没被测到的代码**（漏测线索），不是用来证明**测试有效**。它是一把手电筒，不是一张成绩单。

#### 覆盖率门禁的合理用法与滥用

```js
// ✅ 合理：防止倒退（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）三步循环：

```text
1. Red     先写一条会失败的测试       → 明确「要什么行为」
2. Green   用最笨的办法让它通过       → 只追求正确，不追求漂亮
3. Refactor 在测试保护下改进设计      → 全绿即可放心改
   ↑______________________________________|
```

关键纪律：**每次只前进一小步**。Red 阶段先跑一遍确认它真的失败了——否则你可能写了条永远不会失败的测试（假绿）。

收益：

- 强制先想清接口与边界，减少返工；
- 天然高覆盖，且每条测试都对应一个需求；
- 小步前进，调试时间显著缩短。

代价：

- 学习曲线陡，前期速度肉眼可见地下降；
- 需求尚不明确时容易写成「测试牵着设计走」的伪需求；
- 对**探索性**任务几乎无效。

#### 不适合 TDD 的场景

| 场景 | 原因 | 替代做法 |
|---|---|---|
| 探索性原型（spike） | 需求本身在变，测试会全部作废 | 先写代码摸清方案，稳定后再补测试 |
| UI 布局与视觉效果 | 「好看」难以断言 | 目视检查 / 视觉回归测试（截图对比） |
| 与第三方对接的第一次打通 | 对方行为未知 | 先手工打通，摸清契约后再补集成测试 |
| 一次性数据迁移脚本 | 生命周期极短 | 迁移前后校验数据量即可 |

> [!tip] 务实建议
> 不必做「纯 TDD 信徒」。日常更实用的组合是：**核心业务逻辑 TDD，胶水代码与 UI 后补测试**。

#### 遗留代码如何逐步补测

遗留代码（legacy code）的实用定义是「没有测试的代码」。直接上手写测试通常卡在「依赖太多，构造不出来」。Michael Feathers 的方法论是**先找接缝（seam）**——即「不改动代码就能替换行为的地方」。

补测顺序建议：

1. **从最外层的纯函数开始**：工具函数、格式化、金额计算，零依赖，最好测；
2. **找接缝**：把 `new HttpClient()` 改成构造函数参数（这一步是重构，但极小）；
3. **为「即将修改的地方」补测试**，不要追求一次全覆盖；
4. **写「特征测试」（characterization test）**：不断言「应该是什么」，而是记录「当前是什么」——先固定现状，再改；
5. 每次改 bug 时，**先写一条能复现它的测试**，再修——这条测试从此永久防回归。

```python
# 特征测试：不判断对错，只冻结当前行为
def test_遗留的_计算折扣_当前行为():
    # 注意：这段逻辑看起来像 bug（先四舍五入再乘），但先锁住现状
    assert legacy_discount(199.5) == 19.0
```

### 集成测试与端到端测试

#### 数据库测试：事务回滚还是容器

| 方案 | 做法 | 优点 | 缺点 |
|---|---|---|---|
| 事务回滚 | 每个测试开事务，结束回滚 | 最快，隔离干净 | 被测代码若自己提交事务则失效；测不了跨事务行为 |
| 每次重建 schema | 测试前 `DROP/CREATE` | 语义最真实 | 慢（秒级/次） |
| 容器化数据库 | 测试启动 PostgreSQL/MySQL 容器 | 与生产同款，最真实 | 需要 Docker，启动慢（可用 session 级共享 + 每测试清表） |
| 内存数据库 | SQLite/H2 替代 | 极快 | 方言差异会掩盖真实问题（如外键、并发、类型） |

> [!warning] 别用内存数据库替代生产数据库做集成测试
> SQLite 与 PostgreSQL 在类型、约束、并发、函数上差异显著。用它跑出来的绿，是**假绿**。

#### 测试数据工厂与 fixture

硬编码测试数据会随 schema 变化而全面崩坏。用**工厂（factory）**生成带默认值的对象：

```python
# 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 或自建 |

```bash
# 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，或加大超时并重试 |

4. **允许有限重试，但必须上报**：`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` | **最后手段**，用户看不到它 |

```jsx
// ❌ 绑定 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. 并行**

```bash
npx jest --maxWorkers=50%          # 用到一半 CPU 核心
npx vitest run --pool=threads      # 线程池并行
pytest -n auto                     # 需要 pytest-xdist
dotnet test --parallel             # 项目级并行
```

**2. 只跑受影响的测试**

```bash
npx vitest run --changed HEAD~1    # 只跑被最近一次提交影响的测试
npx jest --onlyChanged             # Jest 的对应选项
pytest --testmon                   # 需要 pytest-testmon 插件
```

**3. CI 分层执行**

```yaml
# .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
```

> [!tip] 用耗时估算设预算
> 若 CI 目标 $T_{\text{budget}} = 300$ s，单元测试 $n_u$ 条、单条 $t_u = 5$ ms、并行度 $p = 4$，则
> $$T \approx \frac{n_u t_u}{p} = \frac{n_u \times 0.005}{4}$$
> 要满足 $T \le 60$ s，可容纳 $n_u \le 48000$ 条。**单元测试几乎不可能成为瓶颈**——瓶颈永远在集成与 E2E。所以优化顺序是：把 E2E 缩到最小，把逻辑下沉到单元测试。

### 完整单元测试示例：正常路径 + 边界 + 异常路径

被测代码（`discount.py`）：

```python
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`）：

```python
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)
```

运行：

```bash
pip install pytest
pytest test_discount.py -v                 # 逐条列出
pytest test_discount.py --cov=discount      # 需要 pytest-cov
pytest test_discount.py -k 边界             # 只跑名字匹配的用例
```

> [!important] 为什么这三组缺一不可
> 正常路径证明「功能能用」；边界值证明「临界条件处理正确」（历史上绝大多数线上事故发生在边界）；异常路径证明「错误输入不会静默产生错误结果」——这是最容易被跳过、也最容易造成资损的一组。

## 怎么用

### 完整配置文件

**Jest（`jest.config.js`）**

```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`）**

```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`）**

```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 入口）**

```python
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`）**

```xml
<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>
```

> [!note] 版本以官方最新文档为准
> 上面的版本号用了通配符，实际项目请锁定版本（见 [[工具-03-包管理器]]）。.NET 的测试平台正从 VSTest 迁移到 Microsoft.Testing.Platform（MTP），配置项可能变化，以 [Microsoft Learn 的 .NET 测试文档](https://learn.microsoft.com/zh-cn/dotnet/core/testing/)为准。

### 可执行命令清单

```bash
# ── 安装 ─────────────────────────────────────────────
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                       # 交互式调试
```

## 常见坑

> [!warning] 十个高频错误
> 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` 注释滥用。

> [!danger] 测试数据污染生产
> 集成/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()` 解析出正确价格。

2. **写三组用例**：为下面的函数写出正常路径、边界值、异常路径各至少两条测试（pytest 或 Jest 均可）。
   ```python
   def paginate(items, page, size=10):
       """返回第 page 页（从 1 开始）的数据。page < 1 或 size < 1 抛 ValueError。"""
   ```
   要求：至少覆盖「最后一页不足 size」「页码超出范围」「空列表」三种情况。

3. **该不该 mock**：你要测试 `UserService.register()`，它会：校验邮箱格式 → 查数据库确认邮箱未占用 → 写库 → 发送欢迎邮件 → 写审计日志。请为每一步选择「真实使用 / 替换为测试替身 / 替换成哪种替身」，并说明理由。

4. **覆盖率分析**：某函数行覆盖率 100%、分支覆盖率 50%。请构造一段代码，说明这种情况下仍然可能漏掉真实 bug，并写出能把它抓出来的测试思路。

5. **flaky 治理**：某条 E2E 测试在 CI 上约 10% 概率失败，报错为「等待元素 `.submit-btn` 超时」。请列出三种可能根因，以及各自的修法与验证方式。

## FAQ

> [!question] 单元测试和集成测试的界线到底在哪？
> 判断标准只有一个：**是否使用了真实的、被测系统之外的依赖**（数据库、网络、文件系统、时钟）。全部替换成替身 → 单元测试；含至少一个真实外部依赖 → 集成测试。同一条测试可能既是「多模块」又是「单元」——例如测两个纯函数组合，没有外部依赖，仍算单元测试。.NET 官方文档的说法是：单元测试不测试基础设施问题（数据库、文件系统、网络），集成测试则练习两个或更多组件协同工作。

> [!question] 覆盖率应该定多少？我们团队在争论 60% 还是 90%。
> 没有普适数字，但有三条可操作的建议：(1) 对**新增/改动的代码**要求高（如新增行 ≥ 80%），对历史代码不设卡；(2) 整体覆盖率只做「防倒退」（棘轮机制，不允许下降）；(3) 对**核心逻辑**（金额、权限、状态机）单独设高阈值，对 UI 装配层、自动生成的代码、纯类型定义不设卡。争数字不如争「有没有测边界和异常」。

> [!question] TDD 真的能提高效率吗，还是只是教条？
> 在**需求相对明确、逻辑可判定**的场景（金额计算、状态机、解析器、协议实现），TDD 通常净收益为正，因为它把「调试」换成了「小步验证」。在**探索性、UI 布局、第三方首次对接**场景，TDD 往往净损失。务实的团队做法是：核心逻辑 TDD，外围后补测试，并且**每个 bug 修复都先写一条复现测试**——这一条纪律的投入产出比最高。

> [!question] 测试写不完，需求一直在变，测试老是红怎么办？
> 三个方向同时做：(1) **只测行为，不测实现**——按用户视角断言（输入输出、可见结果），需求演进时测试不必跟着改；(2) **降低脆弱性**——禁止断言私有方法、内部调用顺序、DOM 类名；(3) **缩到核心**——先给最贵的那部分逻辑（钱、权限、数据一致性）写测试，其余靠集成测试兜底。测试全红且无人修，比没有测试更糟：它会训练团队忽略失败。

## 相关笔记

- [[工具-07-调试技巧]]：测试失败后如何定位根因——断点、日志、二分排查。
- [[工具-08-CICD入门]]：把测试挂到流水线上，让分支保护真正生效。
- [[工具-03-包管理器]]：测试框架依赖的安装、版本锁定与锁文件。
- [[后端-09-后端安全与性能]]：安全测试与性能测试的位置。
- [[JavaScript-04-异步编程]]：理解 Promise 与事件循环，才能写对异步测试。
- [[Python-05-异常与文件IO]]：异常类型设计直接影响异常路径测试的写法。

## 参考来源

- [Jest — Getting Started](https://jestjs.io/docs/getting-started)（安装、配置发现机制、`test.each` 提示）
- [Jest — Testing Asynchronous Code](https://jestjs.io/docs/asynchronous)（Promise / async-await / `.resolves` / `.rejects` / `done` 的正确写法与警告）
- [Jest — Configuring Jest](https://jestjs.io/docs/configuration)（`randomize`、`clearMocks`、`coverageThreshold`、`collectCoverageFrom` 等配置项）
- [Vitest — Getting Started](https://vitest.dev/guide/)（安装、`vitest run` 与 watch 模式的区别）
- [Vitest — Coverage](https://vitest.dev/guide/coverage)（v8 与 istanbul 两种 provider 的取舍、`coverage.include` 的作用）
- [pytest — How to parametrize fixtures and test functions](https://docs.pytest.org/en/stable/how-to/parametrize.html)（`@pytest.mark.parametrize`、堆叠参数化、`pytest.param` 与 xfail）
- [pytest — How to use fixtures](https://docs.pytest.org/en/stable/how-to/fixtures.html)（fixture 复用、scope 语义、yield 清理、安全 teardown 结构）
- [Python 官方文档 — unittest 单元测试框架](https://docs.python.org/zh-cn/3/library/unittest.html)（`TestCase`、`setUp`/`tearDown` 语义、`subTest`、断言方法表）
- [Microsoft Learn — 在 .NET 中进行测试](https://learn.microsoft.com/zh-cn/dotnet/core/testing/)（单元/集成/负载测试的界定，MSTest、NUnit、TUnit、xUnit.net 的官方定位）
- [Testing Library — About Queries](https://testing-library.com/docs/queries/about/)（查询优先级、`getBy`/`queryBy`/`findBy` 对照表、反对按 class 查询的理由）
- [Playwright — Installation](https://playwright.dev/docs/intro)（安装、`--ui`、`show-report`、系统要求）

> [!note] 版本提示
> 本文涉及的框架版本（Jest、Vitest、pytest、xUnit.net、Playwright）更新频繁，配置项与默认值可能变化，请以各自官方文档为准。文中链接均已于撰写时验证可访问。
