计算机是怎么长出来的
总目录/ 第 1 部/ 1.6 把程序做出来的一套工具/ 1.6.3

1.6.3 测试:单元、集成与压测

约 0.65 万字 · 6 张图 · 读完你能说清一次测试本质上是几行代码、 为什么单元测试要多而端到端要少、覆盖率为什么会骗人, 以及压测报告里最该看的那两个数字是什么

上一节最后说,调试器只能证明「这一次是错的」。 你跑通一百次,第一百零一次仍可能错;你手动试过的输入,只是所有可能输入里的一小撮。 要回答「它在所有情况下都对吗」,得换一套方法: 把「应该是什么结果」写成代码,让机器每次改完都自动跑一遍。

这就是测试。它听起来像是「额外的工作」,实际上是把人工检查变成机器检查—— 你只需要想清楚一次,之后每次改动都由机器替你验。 一行代码改坏十个功能的事,靠人眼盯是盯不住的,靠测试跑一遍只要几秒钟。

这一节讲三层测试各自解决什么问题、覆盖率这个指标为什么经常骗人, 以及压测到底在测什么——它测的不是「对不对」,是「撑不撑得住」。

本节的小部分

  1. 1 一个测试就是一句断言
  2. 2 为什么不用手跑,要用框架
  3. 3 单元测试与测试金字塔
  4. 4 依赖怎么办:三种替身
  5. 5 集成测试:把真的东西接上
  6. 6 端到端测试:最像真的,也最脆
  7. 7 覆盖率为什么骗人
  8. 8 先写测试:红-绿-重构
  9. 9 压测:测的不是功能,是极限
  10. 10 测试之外的三道防线
  11. 11 它证明不了什么
  12. 12 收尾:从「验证」到「测量」

1.6.3-1一个测试就是一句断言

把所有框架、注解、报告都剥掉,一个测试剩下的东西只有一句: 「拿这个输入跑一遍,结果应该等于这个」。

def test_average():
    assert average([1, 2, 3]) == 2

就这么多。没有魔法,也没有「测试专用的运行时」。 assert 在工作原理上就是「条件不成立就抛异常」:

def assert(cond):
    if not cond:
        raise AssertionError()   # 抛出,调用链一路往上,直到有人接住

测试框架做的事,就是批量调用这些函数、接住异常、记下哪个失败了、最后打一份报告。 所以「写测试」这件事的门槛其实很低:只要能描述「输入是什么、期望是什么」, 就能写出来,不需要任何特殊工具。

真正难的不是写,是想到该测什么。这件事后面几节都在讲。

1.6.3-2为什么不用手跑,要用框架

既然就是一个断言,那为什么不直接在 main 里写几行 assert 就完事? 因为一旦测试超过十个,四件事会变得无法忍受:

问题手写 assert 的后果框架怎么解决
一个失败就中断第一个断言挂了,后面全不跑,你得改一次跑一次每个用例独立捕获,一次跑完全部
互相污染用例 A 改了全局变量,用例 B 就假失败每个用例前后跑 setup / teardown
不知道挂在哪只有一行 AssertionError,得自己加打印报告里有用例名、期望值、实际值
全量太慢改一行要等所有检查跑完只跑上次失败的那些、只跑改动相关的

这四件事加起来,就是「测试框架」存在的全部理由。 它不让你能测更多东西,它让你在测试变多之后还愿意继续跑。 一个跑一次的测试是资产,一个跑十分钟还没人看的测试是负债。

1.6.3-3单元测试与测试金字塔

「单元」这个词没有严格定义,实践中指一个可以独立调用的最小单位: 一个函数、一个类、一个模块。它的特征是不碰外部世界—— 不连数据库、不发网络请求、不读文件、不看当前时间。

这样做的理由很实际:一个不碰外部的测试,跑一次是毫秒级的;碰了数据库就变成几十毫秒, 碰了网络就变成几百毫秒甚至超时。当你有三千个测试时,前者三秒跑完,后者要跑半小时。

三层金字塔:底层单元测试几百到几万个、毫秒级;中层集成测试几十到几百个、秒级;顶层端到端测试几个到几十个、分钟级
图 1.6.3-1 测试金字塔。越往下越快、越稳、越便宜;越往上越接近真实。这个形状不是审美偏好,是成本算出来的:单元测试写起来便宜、跑起来快、坏了容易定位;端到端测试写起来贵、跑起来慢、挂了还得猜是哪一层的问题。所以底座要厚。

一个「好」的单元测试有四个特征,缺一个都会变成负担:

快。单条毫秒级。慢的测试没人愿意跑,不跑就等于没有。

独立。不依赖别的测试留下的状态,也不依赖执行顺序。 能单独跑,也能和别的任意组合跑。

确定。同样的代码跑一百次,结果一样。 不能依赖当前时间、随机数、网络状况——这些东西会让测试变成「偶尔失败」, 而偶尔失败比一直失败更糟:它会训练所有人忽略红色。

只测一件事。一个测试里塞五个断言、测五个场景, 挂了之后你不知道是哪个坏了。拆成五个测试,报告直接告诉你。

写的时候有个通用结构,叫「准备-执行-断言」三段:

def test_withdraw_rejects_when_balance_is_short():
    acc = Account(balance=100)        # 准备:把世界摆成想要的样子
    result = acc.withdraw(150)        # 执行:只调一次被测函数
    assert result == Err("余额不足")   # 断言:只验一个结果
    assert acc.balance == 100         # 失败时余额不能变

三段各自只干一件事,好处是失败时一眼能看出是哪一段的假设不成立。 命名也值得花点心思:测试名应该是一句话,说明「在什么条件下、期望什么」。 test_withdraw_rejects_when_balance_is_short 挂了, 你从名字就知道发生了什么;test3 挂了,你得打开文件读代码。

最该警惕的测试: 那种「偶尔失败、重跑就好」的测试。它看起来只是小毛病, 实际后果是整个团队开始把红色当背景色——真正的 bug 出现时,没人会多看一眼。 遇到这种测试,要么修好,要么删掉,绝不能留着。

1.6.3-4依赖怎么办:三种替身

单元测试要求「不碰外部」,可你的函数偏偏要查数据库、要发邮件、要读系统时间。 这时候需要找个东西顶上。顶法有三种,名字经常被混着叫 mock,其实干的活完全不同。

三张卡片:Stub 打桩,写死返回值,关心我的代码拿到这个值会怎样;Mock 断言,记录被调用几次,关心我有没有按时调用它;Fake 替身实现,写一个简化但真能干活的版本,关心整条流程能不能走通
图 1.6.3-2 三种替身。选哪个取决于你想验证什么:想验证「算出什么」用 stub,想验证「有没有做」用 mock,想验证「整条路通不通」用 fake。三者经常被统称为 mock,论坛上吵架有一半是因为这个词指的东西不一样。

举一个具体的例子。假设有个下单函数,要扣库存、要发确认邮件:

def place_order(user, item, qty):
    stock = inventory.reserve(item, qty)      # 要连数据库
    if not stock:
        return Err("库存不足")
    mailer.send(user.email, "下单成功")        # 要发邮件
    return Ok(order_id)

三种替身分别能测出不同的东西:

替身在测试里怎么写能发现什么
Stub让 inventory.reserve 永远返回 0库存不足时,对不对
Mock断言 mailer.send 被调了 0 次失败路径上有没有误发邮件
Fake用一个内存字典当库存表扣减、回滚、并发下单能不能走通

一条经验值得记住:能用 fake 就别用 mock。 因为 mock 断言的是「你调用了谁、调了几次、参数是什么」—— 这是实现细节。哪天你把「发邮件」拆成「发邮件 + 记日志」, 或者换了一个邮件库,测试全红,可功能一点没变。

而 fake 断言的是行为:下单成功了、库存少了两件。 实现随便改,只要行为不变,测试就绿。 测试应该锁住「做什么」,不该锁住「怎么做」——这是区分好测试和坏测试最实用的标准。

1.6.3-5集成测试:把真的东西接上

单元测试有个天然的盲区:它测的是「我的逻辑」,不是「我的逻辑和真实世界能不能对上」。 你用假数据库跑得再顺,也测不出「这个 SQL 在 PostgreSQL 上语法不对」。

集成测试就是把真的东西接上:真数据库、真消息队列、真 HTTP。 它关心的不是某个函数的返回值,而是几个组件拼起来还能不能工作。

这里有个经常被忽略的坑:用内存数据库代替真数据库,会漏掉大量 bug。 H2、SQLite 这类内存库跑得飞快,很多项目拿它跑集成测试, 但它们和 MySQL、PostgreSQL 的差异远比想象中大:

差异点内存库通常真实库
事务隔离级别简单,默认就很强各家不同,脏读/幻读行为不一样
锁与并发几乎不锁行锁、表锁、死锁检测
SQL 方言标准子集窗口函数、JSON、全文索引各有一套
索引行为常常直接全表扫走不走索引直接决定快慢

所以现在的主流做法是测试容器:跑测试时临时起一个真的 PostgreSQL 容器, 测完销毁。启动多花几秒,但测的是真东西。 几秒钟买一个「上线不会因为 SQL 方言炸掉」的保险,非常划算。

1.6.3-6端到端测试:最像真的,也最脆

端到端(E2E)测试从用户视角出发:开一个真浏览器,点按钮、填表单、看页面变成什么样。 它是最接近真实使用的测试——毕竟用户不会调用你的函数,他只会点。

也是最脆的。原因很朴素:它依赖的东西最多。 前端改一个 CSS 类名、后端改一个接口字段、测试环境的网络抖一下, 都会让它红。而红了之后你还要判断:是真的坏了,还是选择器过期了?

这就是为什么很多团队的做法是「E2E 只覆盖最关键的几条路」—— 注册、登录、下单、支付。这几条挂了是灾难,其它的交给下面两层。

端到端之外还有一种折中手段,前端用得很多:快照测试。 做法是把组件的渲染结果(HTML 或序列化数据)存成一个文件, 下次跑测试时再渲染一遍,和文件比对。不一样就红。

它便宜、写起来快,特别适合「输出很复杂、但我不关心细节、只要别变」的场景: 一个表格组件的 HTML、一份配置的序列化结果、一个编译器生成的中间代码。 第一次跑生成的快照文件,得人眼过一遍——那是唯一一次真的在检查。

风险也在这儿:改了一行样式,几十个快照全红,人会下意识地执行「更新所有快照」。 一键下去,测试全绿,但没人看过新快照长什么样。快照测试的纪律是:每次更新快照,都要真的看一眼 diff。 做不到这一点,它就会退化成「只要代码能跑就算过」的装饰品。

一个反直觉的事实: 成熟的团队往往主动减少 E2E 测试的数量,而不是增加。 不是不重视质量,是算过账:一百条 E2E 跑一次四十分钟, 失败三条要花两小时排查(其中两条是环境问题), 这些时间本来可以用来写三百条单元测试,覆盖更多逻辑。 测试的价值不在「像真的」,在「能持续跑、挂了能定位」。

1.6.3-7覆盖率为什么骗人

覆盖率是个很诱人的指标:一个百分比,越高越好,还能画成图。 但它衡量的是「代码被执行过没有」,不是「代码对不对」。

左边是一个求平均值的函数,五行代码左侧全是绿点表示都覆盖了;右上写了两个测试用例都通过;右下红框标出 average([]) 会抛 ZeroDivisionError,但没人测
图 1.6.3-3 覆盖率 100%,照样有 bug。每一行都跑过了,但没跑过的那类输入照样能把它打崩。行覆盖率只统计「这行执行过没有」,它不问「这个值对不对」,更不问「别的值会怎样」。一个空列表就能让线上服务返 500,而覆盖率报告上它是一片漂亮的绿色。

三种覆盖率的严格程度递增:

类型统计什么漏在哪
行覆盖这一行执行过没有执行过不代表走对了分支
分支覆盖每个 if 的 true / false 都走过没有组合起来的路径没测
路径覆盖所有可能的执行路径路径数指数爆炸,实际做不到

而且还有更根本的问题:覆盖率测不出「断言写错了」。 你写 assert result == 3,可正确答案是 4, 代码执行了、断言也执行了、覆盖率 100%,测试还是绿的——因为它验的是错的东西。

所以覆盖率的正确用法只有一条:拿它找「从来没被跑到的地方」。 看到一段代码覆盖率是 0,说明要么它是死代码(该删), 要么它是真的没测(该补)。至于那个百分比本身,到 70% 还是 90%, 和 bug 数量没有线性关系。

刷覆盖率最省事的办法是删断言。 这不是玩笑——只要有考核,就有人这么做。覆盖率适合当「探索工具」, 不适合当「KPI」。用错了,它会精确地训练团队写「能跑但不检查任何东西」的测试。

1.6.3-8先写测试:红-绿-重构

常规顺序是「先写代码,再补测试」。测试驱动开发(TDD)把它反过来: 先写一个必然失败的测试,再写刚好让它通过的代码。

三个节点组成循环:写一个失败的测试(红)、写刚好够的代码(绿)、重构(还是绿),一圈几分钟
图 1.6.3-4 红-绿-重构。先说「红」,是因为一个从来没失败过的测试,你不知道它到底测没测到东西。写完测试先跑一遍、确认它真的挂了,这一步排除掉「测试写错了所以永远绿」这种最尴尬的情况。然后写刚好够的代码让它变绿,最后在不改行为的前提下收拾干净。

「写刚好够的代码」这一条经常被误解成「故意写得烂」。 它的真实意思是不要提前实现你还不需要的东西—— 只让当前这个测试通过,不多写一行。等下一个测试逼你的时候再加。

这套循环真正逼出来的东西,其实不是测试本身,而是「先想清楚接口再写实现」。 因为测试必须调用你的函数:它叫什么、收什么参数、返回什么、失败时怎么表示, 这些都得先定下来。定不下来,说明设计还没想明白—— 而这些问题在写实现之前发现,比写完三千行之后发现,便宜一百倍。

它不是万能的。探索性的原型、UI 布局、算法调参, 都是「先跑起来看看」更快。工具要分场合用, 把 TDD 当成宗教比不写测试更糟。

1.6.3-9压测:测的不是功能,是极限

前面所有测试都在问「对不对」。压测问的是另一个问题: 给它一百倍的压力,它会在哪里先垮。

压测报告里该看四个数字:

指标含义为什么重要
QPS / TPS每秒处理多少请求系统的吞吐上限在哪
延迟分位数P50 / P95 / P99 各是多少用户实际感受到的速度
错误率多少请求失败了是「变慢」还是「开始丢」
资源占用CPU、内存、连接数、GC 频率瓶颈在哪,离崩溃还有多远

其中最容易看错的是延迟。平均值几乎一定骗人:

一条右偏的延迟分布曲线,峰值在 110 毫秒附近,右侧拖着一条长长的尾巴到 3000 毫秒,三个点分别标出 P50 约 110 毫秒、P95 约 400 毫秒、P99 约 2 秒
图 1.6.3-5 延迟分布是长尾的。大部分请求很快,少数请求极慢,平均值把这两拨人混在一起。95 个人等 100 毫秒、5 个人等 3 秒,平均下来是 250 毫秒,看着挺好——但那 5 个人已经在客服群里了。所以压测报告里最重要的两个数是 P95 和 P99。

长尾通常来自几个固定的地方:锁等待(有别的请求占着)、 GC 停顿(内存回收时全世界暂停)、 缓存过期后的回源(正好赶上冷数据)、 慢查询(少数字段没走索引)、 网络重传(丢包之后等超时重发)。 每一个都能把 1% 的请求拖成几十倍慢。

压测的常见错误,几乎都是同一个毛病的变种:把压测当成「跑个数字」。

只压不调。跑出个 QPS 就完事,不看瓶颈在 CPU 还是数据库还是锁。 这样下次还得重新压一遍,什么也没学到。

用生产数据。拿真实用户数据压测,轻则污染统计,重则给真人发消息、扣真钱。

忽略冷启动。刚启动的服务缓存是空的、连接池是空的、JIT 还没编译热点代码。 这时候压出来的数字比稳态差好几倍,但它恰恰是用户能感知到的「发布后第一分钟」。

具体做法上,最有用的一招叫阶梯加压: 从 10 个并发开始,每两分钟翻一倍(10 → 20 → 40 → 80……), 同时记录每一档的 QPS、P99 和错误率。

并发     QPS      P99       错误率
10      950      120 ms    0
20      1900     130 ms    0
40      3700     180 ms    0
80      5200     900 ms    0.2%     ← 拐点在这附近
160     5400     4200 ms   6%

看第四行到第五行:并发翻倍,QPS 几乎没涨,P99 却翻了四倍多,错误率开始出现。 这个位置就是拐点——系统从「加压力就多干活」变成「加压力只会更堵」。 之后再加并发,吞吐不升反降,因为时间都花在排队和超时重试上了。

找拐点的价值在于:它告诉你安全水位在哪。 拐点在 80 并发,那生产环境的常态就该控制在 40 以下, 留一倍余量给突发流量。不知道拐点在哪,就等于不知道自己离悬崖多远。

压测的正确产出不是数字,是一句话: 「在 X 个并发下,P99 会涨到 Y 毫秒,瓶颈是 Z」。 有了这句话,你才知道扩容该加机器还是加索引,也才知道大促前该紧张到什么程度。 没有瓶颈定位的压测报告,等于没做。

1.6.3-10测试之外的三道防线

测试不是唯一的防线。实际项目里至少还有三样东西在帮你挡 bug, 而且它们挡住的类型各不相同:

类型系统。编译期就能发现「你传了个字符串给要数字的参数」。 这类错误测试也能发现,但前提是你恰好写了那个用例; 类型系统不需要用例,它对所有代码一视同仁。 类型检查是「全量」的,测试是「抽样」的——这是它最大的优势。

代码审查。人看代码能发现机器看不见的问题: 这个命名是不是有歧义、这个抽象是不是过度设计、这个错误处理是不是在掩盖问题。 测试和类型系统都回答不了「这段代码该不该存在」。

静态分析。lint 能发现「定义了没用的变量」「可能为空却没判」「忘了 await」。 这些东西既不是类型错误,也很难写测试覆盖,但确实是 bug 的高发区。

防线擅长管不了
类型系统接口契约、数据形状业务逻辑对不对
静态分析常见错误模式、代码异味运行时状态、并发
测试行为、边界、回归没想到的输入
代码审查设计、意图、可维护性规模大的重复检查

四者不能互相替代,因为它们覆盖的维度不一样。 一个类型完备的项目照样会算错钱;一个测试覆盖率 90% 的项目照样有安全漏洞。 每道防线都在挡它最擅长的那类问题,剩下的漏给下一道。

1.6.3-11它证明不了什么

这一节最该记住的一句话,来自 Dijkstra: 「测试只能证明有 bug,不能证明没有 bug。」

一个大方框代表所有可能的输入,里面一小块不规则区域是被测过的,三个红点标在区域之外,分别写着空列表、超大数、负数
图 1.6.3-6 测试覆盖的只是输入空间里的一小块。一个收两个 32 位整数的函数,输入组合有 2⁶⁴ 种,每秒测一百万种也要测 58 万年。所以测试永远是在抽样,不是在做证明。三个红点就是抽样漏掉的地方——而 bug 最喜欢躲在这些边界上。

既然测不完,那测试的意义在哪?在于三件事,每一件都很实际:

一是挑代表。按等价类划分:正数、负数、零各测一个, 因为它们走的是不同分支。不需要测一万个正数,只需要测「正数这一类」。

二是挑边界。0、1、最大值、空集合、只有一个元素—— bug 极大概率躲在这些转折点上。因为写代码的人脑子里想的是「一般情况下」, 边界是事后才补的,而补的时候容易漏。

三是挑曾经出过错的。每修一个 bug,就补一个用例。 这条规矩的价值是复利:三年之后,这个项目的每一个历史伤疤都有一道护栏, 谁也没法再把它弄坏一次。

所以测试的目标不是「证明正确」: 是把已知的错都钉死,让新的错无处可藏。 一个健康的项目里,测试应该像一套不断变厚的护栏—— 每修一次事故,护栏就多一根。

1.6.3-12收尾:从「验证」到「测量」

这一节讲的所有东西,都在回答同一个问题:它做的是不是我们想要它做的事。 单元测试验逻辑,集成测试验拼接,端到端验流程, 压测验它在压力下还守不守规矩。

但还有一类问题,测试完全回答不了:它做得够不够快。

你当然可以在测试里断言「这个函数要在 10 毫秒内跑完」, 但这种测试通常很不可靠——同一条断言,在开发机上过,在 CI 的共享机器上就挂, 因为机器负载不一样。测试环境不是测量环境。

而且更根本的是:测试只能告诉你「超了没有」,不能告诉你「时间花在哪儿了」。 一个接口慢了 200 毫秒,是数据库慢、是 GC 停顿、还是某个循环写得蠢? 这个问题得用另一类工具回答——它不检查结果,它观察过程。 那就是下一节:性能分析。

自测:能答上 6 题,这一节就算过了

  1. 把框架剥掉,一个测试剩下的是什么?
  2. 为什么「偶尔失败」的测试比「一直失败」的更危险?
  3. 单元测试为什么要求「不碰数据库、不看时间」?
  4. stub、mock、fake 各验证什么?为什么说「能用 fake 就别用 mock」?
  5. 用内存数据库跑集成测试,会漏掉哪几类问题?
  6. 为什么成熟团队反而会主动减少端到端测试?
  7. 行覆盖率达到 100%,为什么还可能有 bug?举出两种情况。
  8. 覆盖率的正确用法是什么?为什么它不适合当 KPI?
  9. TDD 的「写刚好够的代码」是什么意思?
  10. 压测报告里为什么不该看平均延迟?该看哪两个数?
  11. 长尾延迟通常来自哪五个地方?
  12. 测试为什么不能替代类型系统?反过来呢?
点开看答案(先自己想,别急着点)
  1. 一句断言:拿某个输入跑一遍,结果应该等于某个值。框架做的事只是批量调用、接住异常、记下哪个失败、最后出报告。
  2. 因为它会训练团队忽略红色。一旦「红了重跑一下就好」成为习惯,真正的 bug 出现时也没人认真看。这种测试要么修好要么删掉,不能留。
  3. 因为它们会让单条测试从毫秒级变成几十上百毫秒,三千个测试就从三秒变成半小时。跑得慢的测试没人愿意跑,不跑等于没有。
  4. stub 验证「算出什么」,mock 验证「有没有调用、调了几次」,fake 验证「整条流程通不通」。因为 mock 断言的是实现细节(调用了谁、调几次),实现一重构就全红,哪怕功能没变;fake 断言的是行为,实现随便改。
  5. 事务隔离级别的差异(脏读幻读)、锁与并发的行为、SQL 方言(窗口函数、JSON、全文索引)、索引是否真的生效。这四类问题在内存库上根本复现不出来。
  6. 因为 E2E 跑得慢、脆、挂了难定位。一百条 E2E 跑四十分钟、失败三条排查两小时,这些时间够写三百条单元测试,覆盖更多逻辑。测试的价值在「能持续跑、挂了能定位」,不在「像真的」。
  7. 一是断言写错了(执行了但验的是错的东西);二是输入没覆盖到(比如空列表、负数这类边界),代码每行都跑过,但那一类输入从没试过。
  8. 拿它找「从来没被跑到的地方」——是死代码还是漏测。不适合当 KPI,因为刷数字最省事的办法是删断言,考核会精确地训练团队写不检查任何东西的测试。
  9. 只写让当前这个测试通过的最少代码,不提前实现还用不上的功能。等下一个测试逼你的时候再加。
  10. 因为平均值把「最慢的那批人」稀释掉了。95 人等 100 毫秒、5 人等 3 秒,平均 250 毫秒看着挺好,但那 5 个人已经在投诉了。该看 P95 和 P99。
  11. 锁等待、GC 停顿、缓存过期后的回源、慢查询、网络重传。每一个都能把 1% 的请求拖成几十倍慢。
  12. 类型系统是「全量」的,对所有代码一视同仁,不需要写用例;测试是「抽样」的,只能覆盖你想到的输入。反过来,类型系统管不了业务逻辑对不对,测试能。两者覆盖的维度不同,不能互相替代。
← 1.6.2 调试器:断点、单步与看变量,程序怎么被“冻住”