DevTernity Conference
现代测试套件脆弱并阻碍代码重构,根源在于过度以类为粒度滥用Mock,开发人员必须回归Kent Beck原教旨,仅针对稳定端口的业务行为编写测试。
AI-assisted summary of 🚀 TDD, Where Did It All Go Wrong (Ian Cooper) — original source. Check the original for full context.
Source published:
Key ideas
- 现代 TDD 偏离了 Kent Beck 的初衷:行业误将面向模块行为的黑盒测试窄化为针对单一类的白盒测试,并泛滥使用 Mock,导致测试与内部实现细节高度死锁,反而阻碍了重构。 (20:24)
- 编写新测试的唯一合法触发条件是系统出现了新的业务需求或用例行为,而不是在类上新增或修改某个方法。 (24:01)
- 测试隔离的核心是“测试用例之间的执行隔离”而非“被测类的代码隔离”,单元测试直接连接无状态污染的数据库或文件系统完全符合 Kent Beck 的原始定义。 (35:01)
- 重构阶段的铁律是严禁编写新测试:重构提取出的内部类应当保持私有或 internal,其正确性已被面向对外契约的既有测试覆盖。 (43:23)
- 六边形架构的“端口层”(Ports/Facade)是执行开发者测试的最佳切入点,过度依赖端到端 UI 测试或复杂 ATDD 翻译层会严重拖慢研发效率与破坏编程心流。 (55:18)
Detailed notes
## Background 该视频由技术大会 DevTernity Conference 于 2017 年 12 月 20 日发布在 YouTube 上。页面简介指出,自 Kent Beck 于 2002 年提出 TDD 以来,行业内产生了大量关于“测什么”、“什么是单元测试”以及“公开接口”的误解,导致当今许多测试套件脆弱、晦涩且阻碍重构;本演讲旨在重温 Kent Beck 的原始构想,纠正关键误区并探索真正赋能软件开发的 TDD 实践。
## TL;DR Ian Cooper 回顾了自己十余年的 TDD 实战经历,深刻反思了软件行业如何将原本旨在保障重构的优秀实践扭曲为阻碍开发的沉重负担。他指出,现代开发者误将“被测单元”窄化为单一类,并在方法级别泛滥使用 Mock,导致测试与具体实现细节深度耦合,代码稍有重构便大面积飘红。Cooper 倡导重归 Kent Beck 最初倡导的 TDD 原则与 Dan North 的行为视角:编写测试的唯一触发点是业务需求而非类的方法;在红-绿-重构循环中,允许以粗糙代码快速变绿,且重构期间严禁为提取的内部私有类补充测试;最终结合六边形架构,将测试锚定在稳定的对外端口(Port/Facade)层,从而写出更少却更高价值的测试套件。
## Atmosphere & style 整场演讲呈现出一种直击痛点、充满自嘲与犀利解构的坦诚氛围。Cooper 既像一位遍历沧桑的老兵,又像一位不留情面的技术清醒者,借用乔治·贝斯特的艳遇笑话、“胶带程序员 Bob”以及晨间“抓鬼定罪”等鲜活案例,生动还原了工程师在日常开发中的疲惫与荒唐感。现场既有引人会心一笑的幽默嘲讽,又有刀刀见血的方法论批判,给听众带来一种卸下教条枷锁、豁然开朗的震撼与共鸣。
## Bulletin - [20:24](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=1224s) 现代 TDD 偏离了 Kent Beck 的初衷:行业误将面向模块行为的黑盒测试窄化为针对单一类的白盒测试,并泛滥使用 Mock,导致测试与内部实现细节高度死锁,反而阻碍了重构。 - [24:01](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=1441s) 编写新测试的唯一合法触发条件是系统出现了新的业务需求或用例行为,而不是在类上新增或修改某个方法。 - [35:01](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=2101s) 测试隔离的核心是“测试用例之间的执行隔离”而非“被测类的代码隔离”,单元测试直接连接无状态污染的数据库或文件系统完全符合 Kent Beck 的原始定义。 - [43:23](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=2603s) 重构阶段的铁律是严禁编写新测试:重构提取出的内部类应当保持私有或 internal,其正确性已被面向对外契约的既有测试覆盖。 - [55:18](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=3318s) 六边形架构的“端口层”(Ports/Facade)是执行开发者测试的最佳切入点,过度依赖端到端 UI 测试或复杂 ATDD 翻译层会严重拖慢研发效率与破坏编程心流。
## Key takeaways - [06:04](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=364s) 测试代码量达到生产代码两到三倍但开发速度减缓 20% 到 50%,反映出团队测试套件过于臃肿且缺乏高性价比反馈。 - [08:17](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=497s) Mock 泛滥将底层方法调用序列与参数完全锁死,导致本不该破坏对外行为的代码重构引发大面积测试红灯。 - [14:38](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=878s) 以 FitNesse 为代表的端到端验收测试长期处于全红状态,不仅掩盖真实缺陷,且业务方从不查阅,沦为维护沉重的假文档。 - [19:01](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=1141s) DHH 发文宣告“TDD 已死”并抨击教条主义,促成了与 Kent Beck、Martin Fowler 的公开论战,推动业界反思测试偏离本质的现状。 - [24:01](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=1441s) 测试驱动编写的唯一触发器是“实现业务需求行为”,以“为类添加新方法”作为测试触发点是当代实践中最致命的误区。 - [26:02](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=1562s) 测试目标必须是模块向外暴露的稳定契约(API/Facade),绝不应将测试渗透到易变的内部实现细节与辅助函数中。 - [28:00](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=1680s) SUT(被测系统)并非单一类,过度将“单元”窄化为“类”迫使开发者编写大量无意义的隔离 Mock,制造出过度指定的脆弱测试。 - [31:58](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=1918s) Dan North 倡导 BDD 旨在用“行为”(Behavior)替换“测试”(Test)概念,让开发者聚焦验证业务需求而非微观方法。 - [35:01](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=2101s) 隔离的单元是测试用例本身而非被测试代码,限制外部持久化访问纯粹为了防止测试间共享夹具污染并保障毫秒级反馈速度。 - [39:57](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=2397s) 绿灯阶段追求“速度压倒设计”,允许像“胶带程序员”一样用最粗暴、简陋的事务脚本快速跑通逻辑,严禁过早套用设计模式。 - [43:23](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=2603s) 重构阶段严禁编写任何新测试,提取的类应保持 internal 或包级私有,使用 [InternalsVisibleTo] 暴露细节测试是典型反模式。 - [49:42](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=2982s) 设计模式的最佳应用时机是在重构阶段根据已跑通的丑陋代码消除坏味道,而非在绿灯前进行投机性预先设计。 - [53:07](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=3187s) 依赖繁重人工点击和脆弱 UI 自动化(如 Selenium)的倒金字塔测试体系,一旦发生界面重构就会全线崩溃,极为昂贵且不可持续。 - [55:18](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=3318s) 依据六边形架构,开发者测试应统一锚定在端口层(Ports/Facade),领域核心为纯对象,外部适配器只需轻量级集成测试验证配置。 - [57:59](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=3479s) Kent Beck 的五档理论:遇到复杂算法可降入低档编写细粒度内部测试探索前进,但探索完成后必须立刻删除这些探路测试。 - [01:01:36](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=3696s) 在测试代码中配置 IoC 容器注册或滥用 Mock 进行白盒实现审查是严重的设计脱轨,会彻底剥夺系统未来的可重构性。
## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=0s) 开场互动与演讲初衷
Ian Cooper 首先向在座的观众提问互动,询问有多少人看过他之前关于该主题的演讲视频,现场有少数几位举了手。他提醒道,现场演讲会有些许细微差别和节奏调整,但核心论点始终如一。接着,他调查了现场使用测试驱动开发(TDD)的情况:有多少人目前正在做测试(先测还是后测)、有多少人严格践行“先写测试”(test-first),以及有多少人在使用 Mock 技术。看到大量观众举手表示重度使用 Mock 时,他认为这非常耐人寻味。
随后,Ian Cooper 介绍了自己的背景。他打趣道,幻灯片上的个人履历大多枯燥无趣,但最重要的一点是:“像我这样来大会演讲并站在你们面前的人,并不一定比你们更聪明或更有才华;我非常鼓励大家尽可能站出来在技术大会上分享、回馈社区。”他解释说,自己只是一名普通的开发者,早年在.NET 刚起步时,由于市场上几乎找不到现成的专家,要想组织用户组或 Meetup 就必须硬着头皮自己上。他认为参与分享不仅是回馈,更是程序员个人成长的极佳途径,能逼自己把想法表达得更加清晰。他目前就职于 SaaS 软件公司 Huddle(同时顺便提了一句公司在招人),但他强调自己不是来推销任何产品或咨询服务的,所有的思考都纯粹源自多年的实战血泪经验。
- 现场大部分开发者都在实践 TDD,且绝大多数都极度依赖 Mocking 技巧。 - 演讲的核心目的在于分享同行经验,推动开发者自我表达与社区回馈,而非商业推广。
---
[02:02](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=122s) 本次演讲的主线脉络
Ian Cooper 梳理了本场演讲的整体大纲。他希望重点探讨当今行业在实践 TDD 时陷入的误区,以及为什么开发团队对 TDD 的抵触情绪与日俱增。
```mermaid flowchart TD accTitle: TDD核心问题与梳理路线 accDescr: 展示从当前TDD的痛点到回归原始原则的分析流程
subgraph Problem["当前TDD的困境"] A["社区抵触情绪上升"] B["测试代码庞大、昂贵且脆弱"] end
subgraph Reboot["重温 Kent Beck 的初衷"] C["红-绿-重构循环 (Red-Green-Refactor)"] D["区分被测行为与实现细节"] end
subgraph Solution["改进架构与实践"] E["六边形架构 (Ports and Adapters)"] F["重新审视测试金字塔与 Mock 的边界"] end
Problem --> Reboot Reboot --> Solution ```
他计划带领大家重温 Kent Beck 最初倡导的 TDD 原则,重新审视“红-绿-重构”(Red-Green-Refactor)、什么是“绿灯代码”以及重构的本质定义,从而挖掘出我们究竟在哪个环节误入歧途,导致了如今那些痛苦的反模式做法。最后,他还会结合六边形架构(Ports and Adapters)、Given-When-Then、BDD 风格的行为驱动理念以及如何恰当使用 Mock 进行深入剖析。
---
[02:53](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=173s) 十年 TDD 之路与漫长周期的反思
Ian Cooper 回忆道,自己从 2004 年左右在伦敦就开始实践 TDD。当时伦敦的.NET 社区与极限编程(XP)圈子走得很近,彼此思想交流频繁,因此他们很早就成了 TDD 的先锋实践者。到了 2013 年他第一次做这篇演讲时,他已经积累了近十年的 TDD 经验。正是长期维护那些由 TDD 产出的测试套件,让他痛定思痛,意识到现有做法存在巨大漏洞。
他谈到了一个重要的职业心得:作为软件架构师,他倾向于在一家公司待足够长的时间,以至于能够亲眼目睹自己当年犯下的错误反噬自身。Ian Cooper 感慨道:“这是一件非常令人谦卑的事情,但这也正是你从经验中汲取巨大价值的方式。”如果一个人在每家公司只待两年,往往刚做完一个系统,自豪地觉得自己交付了一项了不起的成果便拍拍屁股走人,永远不知道后来的维护者对自己留下的设计有多么咬牙切齿。唯有留下来长期维护,才会发现自己写出的大规模测试套件在后续维护中是多么笨重、昂贵且难以维系。
---
[04:24](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=264s) 资深工程师的质疑与初期的布道盲目
在 2005 到 2006 年前后,刚刚“喝了 TDD 迷魂汤”(drunk the Kool-Aid)的 Ian Cooper 处于极度热衷的状态。面对外界对 TDD 的怀疑与抗拒,他当时的反应充满优越感,总觉得那些反对者“根本没开窍”,甚至认为 TDD 是过去十年里最伟大的软件开发方法演进。
然而,令他感到困惑的是,反对队伍中不乏极其聪明、令他由衷敬佩的高水平工程师。他们写出的代码质量极高,却依旧坦言 TDD 不是正确的软件开发方式。每当遇到这种阻力,Ian Cooper 便会像教小孩一样,一字一句缓慢而固执地背诵 TDD 教条,以为只要重复得够多,对方脑子里的灯泡总会亮起来。直到有一天,一位他非常欣赏的优秀开发者对他说:“初级开发者确实需要 TDD,它能帮助他们写出好代码;但我相信你肯定不会真指望团队里的资深工程师也去搞 TDD 吧?”这番话彻底击中了他,让他开始反思那些顶尖工程师抗拒 TDD 的背后根源究竟是什么。
---
[06:04](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=364s) 代码量失衡与开发速度的现实折损
Ian Cooper 讲述了一个令团队无比自豪的成功案例:他们曾开发过一个纯后端服务(不包含易变的 UI),上线运行整整一年没有报告过任何生产环境缺陷(zero defects)。团队当时一致认为这完全归功于 TDD,因为他们覆盖了所有业务场景,用无可辩驳的证据证明了代码的正确性。
然而,在审视该项目的代码库时,他发现了一个诡异的现象:测试代码量是生产代码量的整整三倍。为此他去推特(他戏称为“宇宙万物真理与智慧的源泉”)求证,结果同行们纷纷附和表示:“两到三倍的测试代码完全属于常态。”这种代码比例让他深感不安。
随之而来的就是项目经理(PM)的灵魂拷问:“各位,我们能不能跳过写测试?这样我们进入市场的速度会快得多。我知道你们追求优秀的工程素养,但写这些测试花的时间实在太长了。我们直接发布代码不行吗?就算生产环境有一点 Bug 也没什么大不了的吧?”面对这种质疑,开发人员搬出了标准教条回怼,声称测试就是写代码不可分割的一部分,“不让写测试就等于让我们停止写代码”。虽然成功挡回了产品经理的要求,但 Ian Cooper 也不得不承认一个残酷的现实:
> “从实际情况来看,因为编写这些测试,我们的开发速度确实比以往慢了 20% 到 50%。”
---
[08:17](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=497s) 脆弱的 Mock 与重构承诺的破灭
更致命的痛点出现在系统维护期。面对庞大的测试套件,团队只要想变动一点实现,就会引发大面积的测试红灯崩溃。而且这种变动往往根本不是在修改业务逻辑,而仅仅是在做“重构”——例如随着新功能加入,既有实现的组织形态不够合理,开发者想通过重构调整代码架构,让其更易于维护、更具可读性。在系统的外部行为完全没变的情况下,测试却崩了一大片。
深入排查后发现,崩溃最严重的恰恰是那些充斥着大量 Mock 的测试。因为 Mock 强行把底层的实现细节锁死了:它巨细靡遗地规定了“这个方法必须先被调用两次,然后再调用那个方法,并且传入特定的参数”。一旦重构调整了内部协作逻辑,这些依赖 Mock 的测试立刻报废,开发者不得不花费海量精力去修改每一个 Mock 的断言逻辑。
这与 TDD 当初许下的神圣诺言形成了荒谬的对立。行业先驱原本承诺,TDD 能够赋予我们重构的信心,避免系统沦为“大泥球”(big ball of mud)或过早腐化;测试套件本应是重构的安全网,如今却成了阻碍代码变更的最大绊脚石。每次稍微改动实现细节,就必须修复成百上千个测试。Ian Cooper 尖锐地指出了这种脱节:“Martin Fowler 和 Kent Beck 告诉我们,重构是指在不破坏测试的前提下改变内部实现细节;然而我们的测试却无时无刻不在崩溃。”到了 2009 至 2010 年左右,业界甚至开始涌现出一批新的开发方法论,公开打出旗号劝诫开发者不要使用 TDD,理由正是“TDD 严重拖慢了研发交付的速度”。
[10:36](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=636s) 极客无政府主义、精益创业与“胶带程序员”的崛起
随着软件行业的发展,一种被称为“程序员无政府主义”(Programmer Anarchy)的思想开始抬头。Ian Cooper 提到 Fred George 提出了类似于电影《摇滚万万岁》(Spinal Tap)式的极端观点:“如果极限编程(XP)是好的,那我们就把音量旋钮直接拧到 11——来搞‘极限极限编程’”。这种模式的主张非常激进:裁掉所有非软件开发人员,干掉 QA,干掉产品经理,只让开发人员直接与客户沟通。他们编写极小的代码片段,也就是最初意义上的“微服务”(Microservices),规模仅有区区 100 行左右代码。由于代码体量极其微小,他们认为开发人员肯定能写对,因此根本不需要任何测试;代码写完直接丢到生产环境,一旦需要变更,直接扔掉重写。与此呼应的还有“刺探与稳定”(Spike and Stabilize),以及成为加州硅谷初创企业圣经的“精益软件开发”(Lean Software Development)。精益思想告诫开发者:“先别做测试,尽可能快地把软件推到客户面前以获取真实反馈,因为你构建的可能从头到尾就是错误的东西,迟早要被扔掉;TDD 是你在规模化扩张阶段才需要做的事,现阶段写测试会严重拖垮你的速度。”
与这种思潮伴生的是每个团队中都存在的“胶带程序员”(Duct-tape Programmer)。业务方和产品团队极度偏爱这种人,因为每当有新需求,只要交给“Bob”,Bob 就能以惊人的速度把功能推上线。然而,团队里的其他工程师往往痛苦不堪,甚至咬牙切齿:Bob 的工程实践一塌糊涂,写出来的全是垃圾代码,其他人不得不耗费大量的时间替他重构、修补和维护。更令人沮丧的是,产品经理根本看不到背后的技术债务,他们盛赞 Bob 思维敏捷、执行力强;而当规范的开发者还在恪守严格的工程实践、慢吞吞地完善测试套件时,Bob 的代码早就已经在生产环境中跑起来了。这让坚守最佳实践的团队在交付信誉上彻底输给了“胶带工程师”。
Ian Cooper 这样描述业务方对这种开发者的偏爱: > “The guy's going Bob fantastic he's so receptive to our ideas he's pushes stuff out the rest are you going but it's so hard to maintain the Bob's code is terrible right but they love Bob because Bob delivers for them you're still writing it for your test suite and bob has shipped the code and it's running okay we had a few of those and needs to be really annoying you should be really annoying that we were still doing they're doing our best engineering practices and these guys were shipping code and there's waffle code but they were shipping right and so they won the credibility not us.”
---
[13:21](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=801s) 脆弱且充斥着 Mock 的测试:失去意义的套件
开发者在维护遗留测试套件时陷入了另一种深重挫败:由于测试过度绑定了实现细节,一旦重构内部实现,大量测试便纷纷变红报错。当开发者停下来排查失败时,却困惑地发现自己根本搞不懂测试到底在测什么,也无法判断这个红脸到底是揭示了系统缺陷,还是只是代码变动带来的假警报。例如某些测试只是把两个数字加在一起,得出一个匪夷所思的结果,开发者既无法理解最初为什么会通过,也无法理解为什么一旦重构就变红。
更严重的问题是测试套件中泛滥成灾的 Mock 对象。很多测试里密密麻麻塞满了 Mock,以至于当开发者仔细审视测试代码时,会震惊地发现整段测试里根本没有任何真正的业务代码在运行,被测的完全就是一堆 Mock 本身。面对这些既不提供有效信息、又无法保障业务逻辑的测试,开发者最后被逼得抓狂,唯一理性的选择竟然是直接将这行不知所云的测试代码删掉。
Ian Cooper 回忆起排查测试时的典型困境: > “They don't have this experience you go back and find the test is red and you're looking at it in your going I have no idea what this test is for and I have no idea whether the fact that this red is good or bad at this point in time.”
---
[14:38](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=878s) FitNesse 与验收测试的幻灭:无人问津的“活文档”
为了消除业务与技术之间的鸿沟,Ian Cooper 的团队曾引入了 FitNesse(后续的 SpecFlow 和 Cucumber 也是同类工具)。他们的构想十分美好:用自然英语编写可执行的规范,在 HTML 表格中清晰呈现高层测试,客户只要打开网页、点一下按钮,看到满屏绿色,就能完全确信系统正在严格按照他们的需求运转。然而在实际落地中,这套流程沦为了一场灾难。
在迭代开发初期,这些端到端验收测试几乎必然是全红的,并且会在整个迭代的大部分时间里持续保持红色,直到最终完成全部功能才会变绿。这就造成了一个致命的认知盲区:开发者无法分清测试变红是因为“功能尚未实现”,还是因为“已有的功能被改坏了”。长此以往,大家在测试变红时普遍默认是前者,导致真正的系统破坏长期被掩盖,测试套件大部分时间处于事实上的损坏状态。
而最具有讽刺意味的是,开发团队费尽心机打造的“面向客户的文档”,业务方根本连看都不看一眼。即便开发者主动把客户按在电脑屏幕前展示,客户也只会推脱“改天再聊”,转身就走。
```mermaid flowchart TD accTitle: FitNesse 测试落地失效循环 accDescr: 展示 FitNesse 验收测试在迭代中由于长期变红而失去反馈价值并被团队边缘化的恶性循环
subgraph Iteration["迭代开发生命周期"] A["编写 FitNesse 自然语言规范"] --> B["迭代前半段:测试全红<br/>(功能尚未实现)"] B --> C{"测试持续变红"} C -->|"假设未实现,实际已破坏"| D["真实 Bug 被掩盖<br/>测试套件长期处于损坏状态"] C -->|"迭代末期开发完成"| E["期望:测试全部转绿"] end
subgraph Feedback["反馈与价值检验"] D --> F["代码签入受阻<br/>测试缓慢打断心流"] E --> G["向业务客户展示 HTML 报告"] G --> H["客户毫无兴趣、拒绝查阅<br/>('改天有空再聊')"] end ```
Ian Cooper 总结了客户对这些测试页面的冷淡态度: > “And they were completely uninterested in seeing these test Suites that we written to prove to them that the code works correctly for and the check in dollars became more complicated because as well as passing a developer tests you had to run all these fitness test Suites before we allowed you to check your tests into the code base.”
---
[16:56](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=1016s) 心流被断与“捉鬼定罪”:团队对测试的全面排斥
FitNesse 带来的不仅是虚妄的客户满意度,更是开发效能的雪崩。由于团队要求在代码签入前必须完整运行这套缓慢的测试套件,开发人员不得不常常暂停编码去冲咖啡。这种强制性的流程阻断破坏了经典的“20 分钟编程心流”,开发者很难再重新找回专注于代码的状态,导致整个工程效率极度低下。
为了应对缓慢而脆弱的流程,开发者开始学会“钻空子”:无视全红的测试,抱着侥幸心理继续签入代码,甚至依靠“合理推诿”(Plausible Deniability)来互相甩锅,坚称“这次变红肯定不是我的提交造成的,是 Dave 的改动破坏的”。团队甚至畸形地设立了一个专职角色,专门负责“捉鬼”——排查是谁把测试搞砸了,并强迫当事人去修复。当一个团队必须引入专职角色来对测试变红追责时,恰恰证明了整个团队已经彻底对测试失去了信任与关切。Ian Cooper 指出,一个好的工程实践如果有效,团队会自发支持它;若团队长期抗拒并抱怨感受不到价值,那就说明现有的做法一定是哪里出了严重问题。
Ian Cooper 犀利地反思了团队设立“追责机制”背后的荒谬: > “The fact that we actually had a step in our process which essentially was somebody decides who's to blame for the tests being red today and then they go to have to go and fix them implies that no one really cared about those tests because they'd reached that point at being a red the whole time really the developers couldn't see any value they constantly resisted write-ins his tests and one thing I've learned over time is that you know if an idea actually really works after a while your team will be quite happy behind it and if you get some supporters of it if your team is constantly pushing back saying we e doesn't they don't see where I'm getting from this I don't see the value in the test that you're forcing me to write and maybe you need to think again about what you're doing.”
---
[19:01](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=1141s) DHH 发难与“TDD 已死”论战的爆发
大约在该演讲初版分享的一年后,Ruby on Rails 的创始人 DHH(David Heinemeier Hansson)发表了轰动业界的博客《TDD 已死,测试长存》(TDD is dead. Long live testing.)。DHH 的核心痛点在于,主流 TDD 拥趸总是不依不饶地指责 Rails“做错了”,理由是 Rails 的架构对所谓的“测试友好框架”不够顺从。Rails 广泛采用 Active Record 模式,数据持久化方法直接附着在业务对象上(例如 User 对象自带持久化方法)。TDD 狂热者批评这种设计无法将领域模型与持久化及测试框架彻底解耦。
此外,DHH 过去编写单元测试时很自然地会直接读写数据库,如今却被 TDD 原教旨主义者痛斥为违反规则。DHH 抱怨自己最初其实很喜欢 TDD,但随着社区愈发教条,他无论怎么写都会被指责“姿势不对”。失望之下,DHH 宣布彻底放弃 TDD:虽然他依然会编写测试,但他拒绝再忍受 TDD 的教条束缚。这一发难在软件工程界掀起了轩然大波,随后甚至引来了 Kent Beck 本人写下了一篇略带讽刺意味的回应文章《TDD 安息吧》(RIP TDD),正式拉开了对 TDD 真正本质的全面反思与论战。
DHH 对当时苛刻的 TDD 规则表达了强烈的反弹: > “I used to like TDD when it first came out but now I'm constantly being told I'm doing TDD wrong then I'm just giving up on GED you know TDD as far as I'm concerned doesn't work I'm still gonna do some testing but I'm quitting on TDD.”
[20:24](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=1224s) 乔治·贝斯特轶事与重访 Kent Beck 的初衷
Ian Cooper 提到,在 DHH 对外发表对现代 TDD 的批评后,Martin Fowler 曾组织并主持了一系列 Kent Beck 与 DHH 之间的公开对谈。DHH 曾在挪威 NDC 大会上听过 Ian Cooper 本次演讲的早期版本,并表示两人的观点完全不谋而合;而那场三人辩论的最终结论,也与本次演讲的主旨高度一致。面对社区中对于 TDD 的诸多怨言与挫败感,核心问题究竟是什么?TDD 到底是在哪里走偏了?为了生动描摹这种现状,Ian 讲了一个关于 20 世纪 70 年代北爱尔兰著名足球明星乔治·贝斯特(George Best)的经典笑话:
> 酒店的行李员推门走进乔治·贝斯特的套房,只见贝斯特赤身裸体躺在床上,身旁环绕着几位同样不着寸缕的超级名模。行李员推着准备送给他们的鱼子酱和昂贵香槟,低头看着床上的贝斯特,忍不住感叹道:“乔治,这一切究竟是在哪里出了差错?”
Ian 借这个典故自嘲并表明立场:他自己始终是 TDD 的忠实拥护者,之所以问出“哪里走偏了”,并不是要全盘否定它,而是要重新审视其发展历程。他提出的核心论点是:**我们当下在 TDD 中遇到的所有困境,其实早在 Kent Beck 最初阐释 TDD 时就已有现成的解法。** 遗憾的是,整个行业在此后不断给 TDD 堆砌各种各样衍生出的模式与实践,反而远离了 Kent Beck 最初的设计意图。当 Ian 自己在实践中陷入挣扎时,他重新翻读了 Kent Beck 于 2002 年出版的经典著作《Test-Driven Development: By Example》,震惊地发现书中早已囊括并解答了他所经历的绝大多数难题(甚至包括被很多人误以为是后期才发明的 Mock 技术)。
```mermaid flowchart TD accTitle: TDD的历史偏差与回归原始理念 accDescr: 对比Kent Beck原始TDD理念与现代过度装饰后走偏的TDD实践
subgraph Original ["Kent Beck 原始 TDD 理念"] A["需求与行为驱动"] --> B["模块公开接口(API / Facade)"] B --> C["支持无痛重构与信息隐藏"] end
subgraph Modern ["走偏的现代 TDD 实践"] D["方法触发测试(Class/Method)"] --> E["与实现细节深度绑定"] E --> F["大量使用 Mock 导致脆弱脆弱测试"] end
Original -.->|"被后期模式与误解带偏"| Modern ```
---
[24:01](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=1441s) 触发测试的根源:测试行为,而非实现细节
对于实践 TDD 而言,最关键的一条准则被无数人严重忽视:**“测试行为,不要测试实现细节。”** Ian Cooper 强调,这是当代开发者在实践 TDD 时犯下的最普遍错误。在许多团队日常的现代 TDD 流程中,典型的操作逻辑是:“我准备在类上编写一个新方法,于是在写这个方法之前先写一个单元测试,用这个测试来判定该方法执行成功还是失败。”换句话说,开发者将“为类添加新方法”视作了编写测试的触发器。
Ian 明确指出,这种以方法为粒度的驱动方式根本不是 TDD 的灵魂,甚至完全南辕北辙:
> “在 TDD 中,创建新测试的触发条件只有一个:你有一项需要实现的业务需求。仅此而已,别无其他。”
编写测试的动力应当源于软件必须完成的业务目标。例如,“当向客户的银行账户存入一笔金额时,软件需要更新其余额”,或者“软件需要允许用户向其个人文件库中上传一个新文件”。这才是驱动 TDD 测试编写的真实需求。相反,写一个测试去验证诸如“`foo()` 方法应当接收两个数字并返回它们的乘积”,纯粹是在测试具体的内部实现细节。除非系统本身就是一个计算器程序,否则没有任何一条实际的业务需求会直接定义这种底层函数的入参和返回值;过早陷入这种微观函数的测试,只会让测试代码沦为易碎的负担。
- 错误触发器:计划在类中添加或修改某一个内部方法或函数 - 正确触发器:系统接收到一项全新的业务需求或用例(User Story / Use Case) - 目标分层:需求处于顶层业务契约,而底层辅助方法属于极易波动的实现细节
---
[26:02](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=1562s) 重新定义 API:软件与外部世界的稳定契约
为了摆脱对实现细节的纠缠,开发者必须将测试焦点转移到软件的 API 上。Ian Cooper 澄清道,在当今的技术语境下,只要一提到“API”,许多人便立刻联想到 RESTful、HTTP、JSON 或者 GraphQL 等网络传输接口;但他在这里所说的 API 具有更本质的软件工程含义——它是**模块公开暴露的表面积,是软件向外部世界许下的契约**。
从经典软件工程的模块化理论来看,每个模块都应该具备明确的信息隐藏(Information Hiding)与封装(Encapsulation)机制: 1. **公开导出部分(Exports / Facade):** 供外部调用者或其它模块依赖调用的公开契约。这部分代表了相对稳定的业务功能承诺,通常不会频繁剧烈变动。 2. **内部实现细节(Internal Implementation):** 隐藏在模块外壳内部的具体算法、辅助类与数据结构。这是最不稳定的部分,开发者随时可能想到更好的算法或设计来对其进行优化和重构。
Ian 告诫开发者,TDD 的测试必须且只能针对这个稳定的公开契约(API)进行编写,而绝对不要将测试渗透到模块内部的实现细节之中。
---
[28:00](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=1680s) SUT 不是单个类:反思过度 Mock 与“单元”的真义
敏捷开发中通常使用用户故事(User Story)或用例来描述需求,并常借用 Given-When-Then 模式(例如:“假设账户内已有 100 英镑,当我存入 100 英镑时,账户总额应为 200 英镑”)。在这个过程中,测试关注的是向系统输入操作并观察其行为反馈。Ian 尖锐地批评了现代单元测试中泛滥的教条主义:
> “被测系统(System Under Test)并不是一个类。太多的 TDD 实践把精力过度集中在为单个类编写测试上了。”
在经典测试理论诞生的时代,“单元测试”指代的是对一个完整模块的黑盒测试,开发者只需要与模块对外暴露的门面(Facade)进行交互。然而,随着面向对象语言(如 C#、Java)的普及,行业逐渐将“单元”窄化为单一的“类”,并演变成“必须把这个类与其所有依赖彻底隔离”的僵化规则。这种偏执引发了一连串恶果: - **过度 Mock 滥用:** 为了孤立单一类,开发者为所有周边协作对象编写大量的 Mock 和调用断言。 - **过度指定的测试(Overspecified Tests):** 测试代码通过 Mock 详尽地知道了类内部的方法调用顺序、参数传递与内部协同,导致测试与实现细节形成了 100% 的死锁绑定。 - **重构能力丧失:** 内部一旦有任何微调,哪怕对外行为毫无改变,所有 Mock 验证也会瞬间全部挂掉,使原本为了保障重构的测试变成了阻止重构的最大障碍。
```mermaid flowchart LR accTitle: 模块黑盒测试与过度Mock类测试对比 accDescr: 对比针对模块Facade的黑盒测试与针对单一类的过度Mock白盒测试
subgraph GoodPractice ["提倡的做法:模块级黑盒测试"] T1["业务测试用例"] -->|"调用稳定API"| F["模块门面 (Facade)"] F --> I1["内部实现类 A"] F --> I2["内部实现类 B"] style F fill:#e1f5fe,stroke:#0288d1 end
subgraph AntiPattern ["走偏的做法:类级白盒测试与过度 Mock"] T2["类测试用例"] -->|"测试具体类"| C1["目标类"] T2 -.->|"大量 Mock 验证细节"| M1["Mock 依赖 1"] T2 -.->|"深度耦合调用链路"| M2["Mock 依赖 2"] style C1 fill:#ffebee,stroke:#e53935 end ```
Ian 总结道,即使在强面向对象的静态语言中,测试驱动的入口虽然表现为一个类,但那个类应当扮演的是门面(Facade)或命令处理器(Command Handler)的角色,代表整个模块的边界。在这个架构下,**重构(Refactoring)** 是帮助开发者理清“哪些属于必须测试的对外契约”与“哪些属于无需测试的内部细节”的关键步骤。即便有时候为了排查极度复杂的算法逻辑,开发者偶尔需要探入内部细节编写探针测试,也应当在逻辑验证完成后坚决删除这些测试(即“豁免条款”)。最后,Ian 顺带提及了 Dan North 提出“行为驱动开发”(BDD)的初衷——Dan 当时之所以构想 BDD,正是因为观察到了业界在理解 TDD 的“测试”概念时已经产生了严重的偏差。
[31:58](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=1918s) 行为驱动与 TDD 的核心初衷
Ian Cooper 指出,人们在推行测试驱动开发(TDD)时常常陷入极大的困惑,其根源恰恰在于“测试”(test)这个词。这个词误导了大家,而 Dan North 很早就洞察到了这一点:如果把“测试”换成“行为”(behavior)——即通过定义系统的行为来推进系统开发,大家立刻就能把事情做对。早在 2005 年左右,Dan North 就指出了同样的问题:人们之所以误解 Kent Beck 的原意,很大程度上是因为 Kent Beck 在书中使用了一些传统测试术语,比如“test”和“unit test”;但事实上,Kent Beck 在书中只提过寥寥数次“unit test”,他更频繁使用的词汇是“开发者测试”(developer test)。
这两位先驱所对抗的其实是同一个顽疾:开发者总是习惯于“我需要测试这个方法”,而实际上他们本应说的是“系统中存在某种行为,我希望用代码来验证该行为在系统中确实有效”。Ian Cooper 强调这绝非 Dan North 后来凭空发明的概念,Kent Beck 最初在书中讨论的就是“行为”——能够证明程序计算正确、生成报表正确的行为。例如,“将两种不同货币的金额相加,并根据给定的汇率换算出结果”,或者“用每股价格乘以股票数量以获得总金额”。测试的目标是验证这些业务需求行为,绝非仅仅测试某个类上的某个方法。测试代码应该扮演该代码的第一个外部调用者,用来设计和检验对消费者而言直观好用的公开 API。
> “People misunderstood what Kent was talking about probably because Kent used classical testing terminology like test, unit test, which he mentioned just a couple of times in the book; generally the phrase Kent Beck uses is developer test, right, not unit testing, developer tests.” —— Ian Cooper
- Dan North 提出转向以“行为”为核心的思考方式,使系统开发流程更加明确且不易走偏。 - Kent Beck 关注的 TDD 需求案例包括多币种加法与股票总价计算,皆为具体的业务功能需求而非类级别的内部实现。 - 测试作为系统的首个外部消费者,其职责是探索与定义易用的公共 API(Public Facing API)。
---
[35:01](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=2101s) 隔离的单元究竟是什么
在经典单元测试术语的演进中,出现了一个影响深远的误解。在传统测试理论中,模块(例如.NET 中的一个程序集 Assembly)通常是独立测试的单元;多个模块协作构成集成测试(Integration Test),所有模块联合则构成系统测试(System Test)。Kent Beck 在提出单元测试概念时,其实际指的是对一个模块的验证。然而,许多开发者却将“单元”(unit)生搬硬套成面向对象中的“类”(class),从而衍生出一套对 TDD 实践造成毁灭性打击的做法:把待测类与一切隔绝,强迫对该类的所有依赖进行全面 Mock。
Ian Cooper 严肃指正,这种做法完全颠倒了概念。在 Kent Beck 的定义中,**隔离的单元是测试用例本身,而不是被测试的代码(The unit of isolation is the test, not the thing under test)**。这意味着测试套件能够作为一个整体并发或按任意顺序运行,且任何一个测试用例的执行都不会对其他测试造成副作用。
```mermaid flowchart TD accTitle: Unit of Isolation Comparison accDescr: Diagram contrasting the correct TDD isolation model (test-level) with the flawed anti-pattern (class-level with excessive mocks).
subgraph AntiPattern["常见错误误区:隔离被测类"] direction TB TestA["单元测试用例"] -->|"测试与断言"| TargetClass["单个待测类 (Class Under Test)"] TargetClass -.->|"必须强制隔离"| Mock1["Mock 依赖 1"] TargetClass -.->|"必须强制隔离"| Mock2["Mock 依赖 2"] end
subgraph CorrectPattern["Kent Beck 原意:隔离测试本身"] direction TB Suite["测试套件 (Test Suite)"] Suite --> Test1["测试用例 1 (独立运行/无状态污染)"] Suite --> Test2["测试用例 2 (独立运行/无状态污染)"] Test1 --> ModuleA["完整模块协作网络 / 真实代码与状态"] Test2 --> ModuleA end ```
避免频繁访问数据库或文件系统并非因为要“隔离类”,而是为了避免“共享夹具”(Shared Fixture)带来的状态污染——如果前一个测试写入的数据污染了后一个测试读取的结果,测试间的独立性就会被打破。此外,测试必须保持秒级的极速反馈,开发者才可能使用它们;如果真实持久化太慢,可以换成能够快速重置的内存数据库(In-memory database)。但只要没有共享夹具带来的交叉影响,单元测试直接调用数据库或文件系统在 Kent Beck 的体系中是完全允许且非常普遍的。
> “The unit of isolation is the test, not the thing under test.” —— Ian Cooper
- 许多人坚信必须 Mock 掉类的一切依赖才能称为“纯粹的单元测试”,但这属于对概念的彻底曲解。 - 隔离驱动力来自两个工程诉求:消除测试之间的互相干扰(测试用例互相独立)以及保证测试套件的执行速度(获取快速反馈)。 - 只要不存在跨测试的状态污染,单元测试中操作真实的文件系统或数据库完全符合 TDD 原理。
---
[38:28](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=2308s) 方法级测试与过度 Mock 的危害
当测试聚焦于孤立的方法而非业务行为时,测试代码就会充斥着对方法调用协议与内部实现细节的刻画。日后开发者回看这些测试时,往往一头雾水,完全看不懂这段测试到底想表达什么业务意图。反之,如果测试绑定的是系统行为,意图就一目了然:它明确断言了系统在某场景下的行为特征。当代码发生演进导致该测试变红时,开发者能够清晰判断:这项既有行为应当继续成立并修复,还是业务需求已经变更因而需要同步调整测试。
过度使用 Mock 造成的灾难在此尤为致命。如果开发者把测试限定在孤立的类上,并对周围的一切协作对象配置繁琐的 Mock 调用期望,测试代码就不可避免地深入了解了代码的内部实现细节。一旦系统进行重构或内部交互略微调整,所有 Mock 的断言都会瞬间崩塌并飘红。这使得测试与实现细节形成了致命的高耦合(Coupled to implementation details)——任何一方的改动都会强迫另一方做出修改,重构的安全性与自由度荡然无存。
> “And if I essentially therefore know too much about the implementation details, then I've coupled my tests to my implementation, and I can't change one without changing the other.” —— Ian Cooper
- 基于孤立方法的测试缺乏业务语境,可读性与可维护性极差。 - 基于行为的测试能够在系统行为发生改变时给出明确的因果提示。 - 对内部实现和 Mock 调用链细节的过度依赖,直接扼杀了安全重构的可能性。
---
[39:57](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=2397s) 重归 Red-Green-Refactor:拥抱“胶带程序员”
针对如何走出上述误区,Ian Cooper 带领大家重新梳理了经典的“红-绿-重构”(Red-Green-Refactor)三部曲。当他向现场听众提问时,几乎所有人都认为自己理解这个循环,也有不少人会写出通不过的红测试,但真正坚持贯彻重构步骤的人却寥寥无几。
首先是“红”(Red)阶段。之所以必须先看到失败,是因为“测试本身是没有测试来检验的”(There are no tests for tests)。开发者必须证明:在缺乏正确实现代码的情况下,该测试确实会挂掉。否则,一旦写出一个永远为真的假测试,后续编写的任何业务逻辑都毫无验证价值。
其次是“绿”(Green)阶段。该阶段的核心法则是:**以最快的速度让测试通过,在这个过程中可以犯下任何架构设计上的“罪恶”**。这个阶段的目标仅仅是搞清楚如何解决当前问题并实现该行为,开发者应该直接写出最平铺直叙的事务脚本(Transaction Script),一行接一行地写代码,绝对不要在此时过早引入精美的类划分或设计模式。甚至可以直接去 Stack Overflow 上复制粘贴代码。在这个阶段,开发者必须抛弃学院派的工程洁癖,完全化身为团队里那种为了求快、用胶带修修补补的“胶带程序员”(Duct tape programmer),用最粗暴、最快的方式抢先跑通逻辑并追赶进度。
> “Make the test work quickly, committing any sins basically necessary in the process.” —— Ian Cooper
- **红(Red)**:编写测试,确保代码可以编译,但必须运行失败;证明测试有效且能捕捉问题。 - **绿(Green)**:不择手段让测试以最快速度变绿,允许写出丑陋、未良好工程化的代码,优先搞清实现路径。 - **重构(Refactor)**:在绿灯的保护网下,才开始消除坏味道、提取良好设计和架构。
[43:23](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=2603s) 重构的核心原则:在重构阶段绝不编写新测试
Ian Cooper 强调,在通过测试的瞬间,“速度压倒设计(speed trumps design)”,目标是用最快的速度让测试变绿。之所以不能在一开始就兼顾优雅设计,是因为人类很难同时做好两件事:你不可能一边理解业务问题的解决方案,一边把代码工程架构设计得尽善尽美。如果你试图同时做这两件事,要么会过度设计出远超当前测试所需复杂度的代码,要么就会陷入“分析瘫痪(analysis paralysis)”。
真正的代码清理发生在接下来的重构(Refactoring)阶段。重构的本质是一系列不改变系统可观察行为的安全步骤,它只改变内部实现。在重构阶段最关键的铁律是:**绝对不要编写新的测试**。测试验证的是行为,比如“将两种不同货币的金额相加得到正确的汇总结果”。只要最初的测试已经锁定了这一行为,无论你在内部如何提取类、调整内部结构,原有的测试都已经完整覆盖了代码。
```mermaid flowchart TD accTitle: TDD两步走与重构阶段边界 accDescr: 展示从快速编码到安全重构的流程,强调在重构时不能编写新测试,只能依靠既有测试防护。
subgraph Solve["阶段一:快速实现"] A["编写测试并使其通过"] -->|"速度压倒设计"| B["产出可行解(允许简陋实现)"] end
subgraph Refactor["阶段二:安全重构"] B --> C["消除重复 / 识别代码坏味道"] C --> D["引入设计模式 / 提取内部类"] D -->|"行为保持不变"| E["运行既有测试进行验证"] end
classDef warning fill:#f96,stroke:#333,stroke-width:2px; D -.->|"严禁此时编写新测试!"| F["为内部类写单测(错误做法)"]:::warning ```
- 演讲者引用 Kent Beck 的观点:在追求测试变绿的那一刻,“Speed trumps design. I want to get there as fast as I can.” - Ian Cooper 总结核心矛盾:“You can't both understand the solution to the problem and engineer the code, right? One of two things will go wrong: you will either over-engineer your solution beyond what the test actually requires, or you'll get some kind of analysis paralysis.” - 如果在重构阶段引入了新的条件分支(conditionals)或投机性代码,代码覆盖率工具会发出警报;条件分支通常意味着引入了新的业务行为,而新的行为必须回到 TDD 起点,通过编写新的需求测试来驱动,绝不能在重构阶段顺手添加。
---
[46:07](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=2767s) 解耦实现细节:保护内部可见性与消除脆弱测试
不为重构中产生的类编写新测试,带来两个巨大的好处:第一,测试数量更少,开发速度更快,工程团队不会因为背负海量无用测试而在交付节奏上落后于野路子的“胶带程序员(duct-tape programmer)”;第二,测试不再与实现细节发生耦合。例如在 C# 或 Java 中,提取出来的新类通常应该标记为 `internal` 或包级私有,永远不对外暴露。
只要测试只与稳定的公共契约(Public API)绑定,内部细节无论如何重构,测试都不会失败。很多人在重构时发现某个内部类没有测试,就顺手把它改成 `public`,或者在.NET 中使用 `[InternalsVisibleTo]` 特性把内部类暴露给测试程序集,Ian Cooper 直言这是绝对错误的倒退。把内部细节暴露给测试,不仅破坏了信息隐藏原则,还会让测试陷入脆弱的泥潭。
- Ian Cooper 直击痛点:“Dependencies [are] the key problem in software, right? Coupling is [a] worse enemy for you than DRY. Coupling is what kills all software.” - 谈到代码可见性与测试的隔离,Ian 坚决反对为了测试破坏封装:“Do not make these public to test. If you find yourself making things public in order to get it under test by implementation details, ask yourself if that genuinely is a part of the contract of your module? If it's not, don't.” - 针对.NET 开发者的常见坏习惯,Ian 警告:“If you are in.NET land and you use the assembly attribute `InternalsVisibleTo` and list your test assembly so that you can get your internals tested, do not do that.” - 这种解耦带来的实际成效极其显著:“We changed the whole way we did, for example, a modeling between of an aggregate without any test breaking, because the behavior hadn't changed; our choice about how to implement it had changed. So test behavior, don't test implementations.” - 如果在重构过程中发现确实需要一个新的公开类,唯一的“代码坏味道”提示是:该功能其实属于模块对外契约的另一个独立公开 API;此时应该通过 Mock 隔离该外部 API 依赖,后续再针对该公开接口单独编写功能测试。
---
[49:42](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=2982s) 重构与设计模式的正确时机:Martin Fowler 与 Joshua Kerievsky 的洞见
Martin Fowler 的经典著作《重构》(*Refactoring*)出版于 Kent Beck 的 TDD 专著之前,书中详细列举了诸如发散式变化、依恋情结(Feature Envy)等代码坏味道,并给出了安全的重构手法。重构的定义本身就是只改变内部实现而不改变外部契约。Ian Cooper 以 DevExpress 和 ReSharper 的重构工具为例,早期 DevExpress 的工具严格禁止重构公开类上的公共方法,因为更改公开契约属于破环性变更(Breaking Change),根本不属于“重构”的范畴;后来虽然妥协加上了“不安全重构(Unsafe Refactoring)”按钮,也是迫于市场竞争压力。
与此同时,Joshua Kerievsky 在《重构与模式》(*Refactoring to Patterns*)中指出了软件开发中普遍存在的“模式狂热(Pattern Happy)”:很多开发者一上来就到处套用设计模式,结果在错误的语境下导致系统严重过度复杂化。Kerievsky 与 Kent Beck 的共同观点是:**应用设计模式的最佳时机恰恰是在重构阶段**。因为只有当你用最粗暴的方式先实现了一遍,彻底搞懂了具体问题和解法后,你才能清晰地看出来这里到底需不需要一个命令模式(Command Pattern)或模板方法模式(Template Method Pattern)。
| 维度 | 绿灯阶段(Green Phase) | 重构阶段(Refactor Phase) | |:--- |:--- |:--- | | **首要目标** | 极速通过测试,跑通业务行为 | 清理代码坏味道,消除重复,优化结构 | | **设计模式** | 严禁预先过度设计,不套用模式 | 识别具体场景后,将代码“重构到模式” | | **测试变动** | 编写并运行针对需求行为的高层测试 | **严禁编写任何新测试**,依赖既有测试验证安全 | | **可见性控制** | 满足行为即可,提取的中间代码收敛为 internal/私有 | 严格遵守信息隐藏,保持公开接口稳定 |
- Ian Cooper 援引 Joshua Kerievsky 的核心理念:“Joshua Kerievsky said the ideal step for applying patterns is the refactoring step, because at this point I know what the solution is — I've written one. It's an awful solution, because I was told to make an awful solution, and at this point now I can see I can clean up by making a pattern.” - 无论是在 Fowler 的《重构》还是 Beck 最初的 TDD 著作中,重构向设计模式演进都是内生逻辑,而非后人的额外发明。
---
[53:07](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=3187s) 传统测试倒金字塔的灾难与 UI 脆弱测试
讨论完单元测试的真正形态后,Ian Cooper 转向了系统架构维度的“端口与适配器(Ports and Adapters)”架构。在展开架构前,他剖析了多数组织中常见的一种极其不健康的“倒金字塔”测试现状:在发布软件之前,团队依赖一波规模庞大的人工手动测试,大家拿着手册拼命点点点;下面是一堆极其庞大的 Selenium UI 自动化测试套件;再往下是少量的集成测试;而最底层的开发者单元测试却寥寥无几。
Ian 斥责这种模式是一场“彻底的灾难(a bit of a disaster)”。手动测试昂贵且不可重复,而大量的端到端 UI 测试(如 Selenium)则极其脆弱。只要把系统的 UI 界面从老旧的 2008 年风格重构成现代的 2017 年风格,底层的核心业务逻辑和软件行为完全没有任何变化,整套自动化 UI 测试用例就会全军覆没,因为底层的控件、DOM 结构和组件交互方式全变了。依靠驱动脆弱的 UI 来测试系统的核心业务行为,是软件交付流程中最昂贵也是最痛苦的泥潭。
- 很多公司发布前依赖两道屏障:手动点击的人工验收大军,以及某个被称为“科学家”的专人维护的庞大 Selenium 测试用例库。 - 谈到 UI 自动化测试的脆弱性,Ian 吐槽道:“If I change my UI to give it a nice classy new look and feel that's much more, you know, 2017 rather than 2008, right? I may not be changing any other behavior of my software whatsoever... I've just cleaned up the UI, but these tools all break... because I changed the way that my widgets work.”
[54:28](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=3268s) 晨间指责游戏与测试金字塔
Ian Cooper 直言不讳地指出,糟糕的测试体系不仅跑得极慢——通常必须挂在通宵运行——而且每天早晨还会引发一场荒唐的“指责游戏”(The Blame Game)。在许多组织里,甚至会专门设立一个岗位,此人每天上班的唯一工作就是去查明“昨晚到底是谁把测试跑挂了”。Cooper 对这种现象给予了无情的嘲弄:“If you have find yourself in the situation where you have somebody whose job every morning is to determine who's to blame the test failing, you are doing it wrong.” 他自嘲道,自己之所以能在这里头头是道地指出这些问题,绝非自命聪明,而是因为他自己曾经犯过这上面所有的每一个错误。
解决这种困局的出路在于回归经典“测试金字塔”(Testing Pyramid): - 金字塔底部:占据绝大多数比例的应该是“开发者测试”(Developer Tests),由开发人员快速执行; - 金字塔顶部:只有少量的高层代码用来验证系统顶部的 UI 或各类小部件(Widgets)是否运行正常; - 金字塔中部:介于二者之间的是适量的集成测试,负责将内外两侧连接起来,但 Cooper 提醒中间层往往藏着不少“骗局”(Scam),随后会详细拆解。
---
[55:18](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=3318s) 六边形架构(端口与适配器)与测试切入点
Cooper 引入了由 Alistair Cockburn 提出的六边形架构(Hexagonal Architecture,也被 Uncle Bob 称为整洁架构 Clean Architecture,或其他人称之的洋葱架构 Onion Architecture)。这套架构将系统划分为三大清晰层次: 1. **核心领域层(Core Domain)**:位于最中央,完全由纯粹的对象组成(POCOs、POJOs 或纯 Python 对象;Cooper 还幽默地提醒台下听众在英国别乱叫“POPO”,因为在英国俚语里那是“警察”的意思)。它们不关心任何外部技术实现,根本不知道怎么连数据库,也不知道怎么处理 Web 请求。 2. **外部适配器层(Adapters)**:位于最外层,承担所有与具体技术相关的脏活累活。驱动侧有 HTTP 适配器(Web API、Django、Sinatra、Flask 等)和 GUI 适配器;被驱动侧有数据库持久化、消息队列(RabbitMQ)以及邮件网关等。 3. **端口层(Ports)**:介于核心领域与适配器之间,就像操作系统中的端口或一扇门。HTTP 适配器通过这扇门进入领域层(通常体现为门面 Facade 层);领域层想要访问数据库或外部基础设施时,也通过由它定义的端口(如仓储 Repository 接口)跨出门外。
Cooper 强调,六边形架构中的“端口层”正是运行测试的绝对理想位置。测试代码应当直接调用端口层,绝不要去碰内部的实现细节。端口层对外接收所有进入系统的业务调用,对内接收领域发出的所有事件或持久化调用。对于外部适配器本身,它们主要由第三方库构成,根本不需要开发者编写复杂的单元测试去测适配器,集成测试只需验证适配器是否配置正确、能否顺利连接外部系统即可;而端到端系统测试则仅需极少量地确认自外向内的链路能够打通。
```mermaid flowchart LR accTitle: Hexagonal Architecture Testing Strategy accDescr: Hexagonal architecture showing external adapters connecting via ports to the core domain, with tests targeting the port layer.
subgraph Adapters["外部适配器层 (Adapters)"] HTTP["HTTP / Web API / GUI"] DB["数据库 / 消息队列 / 邮件"] end
subgraph Ports["端口层 (Ports / Facade / Repositories)"] InPort["入站端口 / 门面"] OutPort["出站端口 / 仓储接口"] end
subgraph Domain["核心领域层 (Domain)"] Core["POCO / POJO / 纯对象<br/>(零技术依赖,仅含纯业务逻辑)"] end
Test["【开发者测试切入点】"] -.-> InPort
HTTP --> InPort InPort --> Core Core --> OutPort OutPort --> DB ```
---
[57:59](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=3479s) 切换档位:五档理论与何时删除测试
针对听众可能提出的疑问——“如果我就是想用 TDD 帮自己钻进内部细节、理清算法实现怎么办?”——Cooper 搬出了 Kent Beck 提出的隐喻:“换挡”(Shifting Gears)。TDD 就像开一辆拥有五个档位的汽车: - **四档(日常巡航)**:测试公共 API,写出能用的代码,然后进行重构。 - **五档(高速直达)**:实现方式非常直观显而易见,以至于省去了“先写糙代码再重构”的步骤,直接把最终答案写出来。但 Cooper 警告,一旦发现测试覆盖率开始异常膨胀,必须立即降回四档,因为这说明你开始凭空编写没有测试保护的投机性代码了。 - **低档(探索实现)**:如果你卡住了,“I don't know how to go green”,不知道该怎么写出能变绿的实现,想通过测试摸索前进,那就果断降入低档。你可以写一些针对细粒度内部实现的测试,或者借助 REPL 工具(如 Python 交互终端)来辅助试探。
但 Cooper 给出了极其严苛的后续操作规则:“At the end of that process, delete the tests.” 这些低档位探路测试的价值仅在于引导你攻克难关;一旦目标达成,保留它们就会沦为后来维护者的沉重包袱。下一位开发者重构内部细节时,根本看不懂你当年写下的临时探路脚手架,测试只会莫名其妙地阻碍正常的架构演进。把它们统统删掉,只保留面向公共端口的测试。
---
[59:39](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=3579s) 验收测试驱动开发(ATDD)的反思与 BDD 的初衷
谈到验收测试驱动开发(ATDD),Cooper 回顾了其跌宕起伏的历史: - Kent Beck 最初极力反对 ATDD,理由是成本极高,而且客户对这些东西根本不感兴趣。后来他虽然略有动摇,担心开发者测试无法聚焦系统的核心主旨,但依然持保留态度。 - 工具 Fit 的作者之一 James Shore 多年后也公开发表反思,宣布自己不再使用这种工具了,原因同样是客户根本不在乎这些表格或特定文本,而且 Fit、Cucumber(Gherkin 语法)这类工具带来了极其沉重的长期维护负担。Shore 提倡开发人员直接与客户交谈,由交谈成果指导开发者编写地道的开发者测试。
Cooper 承认自己过去也迷信过 Fit 和 Gherkin 这一套,曾认为这种端到端的可执行规范能让程序员保持诚实,明确“完成的标准(Done Done)”。但后来他意识到,团队之所以需要 ATDD,纯粹是因为以前的单元测试走入了歧途——大家以前都在测“类和方法”,根本没有东西在记录和验证“系统行为”。一旦把 TDD 的核心纠正为“以行为为导向”,ATDD 就失去了存在的必要,大家就可以彻底扔掉自然语言和代码库之间那层恶心的翻译胶水层(Horrible translation layer)。
谈到行为驱动开发(BDD),Cooper 澄清,Dan North 最早写下 BDD 的核心初衷非常纯粹:测试应当关注行为(Behaviour),而不是关注类和方法。虽然 BDD 如今已被包装成一整套庞大的敏捷方法论,但今日本次演讲吸纳的只是 Dan North 最初的那颗思想内核。
---
[01:01:36](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=3696s) 滥用 Mock、IoC 容器灾难与结语
在演讲的尾声,Cooper 快速而尖锐地炮轰了几个行业毒瘤实践:
1. **Mock 对象的本质与滥用**:Mock 的唯一合法场景是“该资源创建极其昂贵,且代表了共享的状态性资源”(Shared fixed problem)。然而行业里的大多数人却拿 Mock 来强行隔离每一个类。更恶劣的做法是资深开发者通过强制要求初级程序员使用 Mock,以此来肉眼审查初级开发者的方法实现步骤。Cooper 严厉告诫:“It just couples your test to your software means you can't change it, it's never worth it.” 这会使测试与软件结构深度耦合,彻底剥夺未来的重构能力。 2. **IoC 容器的滥用**:IoC(控制反转)容器在当代开发中被极度滥用。除非框架强行绑定,否则尽量不要引入。一个优秀的框架应当要求传入工厂(Factories),而不是扔给你一个全局 IoC 容器。Cooper 警告:“If you find yourself implementing an IoC registration in your test, something has gone horribly wrong.” 在测试代码里配置 IoC 注册,说明设计已经彻底脱轨,就像当年滥用 ORM 一样荒唐。
最后,Cooper 总结了整场演讲的核心教训: - 永远测试**系统行为**,只有在增加新行为时才新增测试; - 哪怕写出脏代码也要先变绿,然后在不破坏测试的前提下重构; - 重构出来的内部私有细节根本不需要单独写测试,它们已经被端口层的测试所覆盖; - 测试应锚定在六边形架构的“端口层”; - 集成测试仅用于验证外部适配器与端口的对接配置; - 彻底停止针对类内部实现的 Mock。
Cooper 抱歉没有留下提问时间,建议大家在会场中找他交流,或去观看网上 NDC 等会议的录播切片,并推荐大家观看 Kent Beck、DHH 和 Martin Fowler 关于 TDD 的那场经典论战视频。
[01:03:48](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=3828s) 演讲结语与致谢
在整场演讲的尾声,Ian Cooper 对 TDD 在行业实践中偏离初衷的现状进行了最后的总结性收束。他提到关于测试驱动开发究竟“在何处走入歧途”的探讨还可以持续深入地交流,并对在场所有参会开发者的聆听表示由衷感谢。Ian Cooper 说道:“conversation about how it's all gone wrong but thanks very much thank you”,随后全场响起了热烈的掌声,为本次关于重拾 Kent Beck 经典 TDD 核心理念的演讲画上了圆满句号。
## Notable quotes > [35:01](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=2101s) The unit of isolation is the test, not the thing under test. — Ian Cooper
> [24:01](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=1441s) 在 TDD 中,创建新测试的触发条件只有一个:你有一项需要实现的业务需求。仅此而已,别无其他。 — Ian Cooper
> [28:00](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=1680s) 被测系统(System Under Test)并不是一个类。太多的 TDD 实践把精力过度集中在为单个类编写测试上了。 — Ian Cooper
> [46:07](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=2767s) Dependencies [are] the key problem in software, right? Coupling is [a] worse enemy for you than DRY. Coupling is what kills all software. — Ian Cooper
> [46:07](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=2767s) Do not make these public to test. If you find yourself making things public in order to get it under test by implementation details, ask yourself if that genuinely is a part of the contract of your module? If it's not, don't. — Ian Cooper
> [01:01:36](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=3696s) If you find yourself implementing an IoC registration in your test, something has gone horribly wrong. — Ian Cooper
> [54:28](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=3268s) If you have find yourself in the situation where you have somebody whose job every morning is to determine who's to blame the test failing, you are doing it wrong. — Ian Cooper
> [43:23](https://www.youtube.com/watch?v=EZ05e7EMOLM&t=2603s) You can't both understand the solution to the problem and engineer the code, right? One of two things will go wrong: you will either over-engineer your solution beyond what the test actually requires, or you'll get some kind of analysis paralysis. — Ian Cooper
## Mentioned Ian Cooper, Kent Beck, Martin Fowler, Dan North, David Heinemeier Hansson (DHH), Fred George, Joshua Kerievsky, Alistair Cockburn, Robert C. Martin (Uncle Bob), James Shore, Huddle, .NET, Ruby on Rails, Active Record, FitNesse, Cucumber, SpecFlow, Selenium, DevExpress, ReSharper, RabbitMQ, Test-Driven Development: By Example, Refactoring: Improving the Design of Existing Code, Refactoring to Patterns
## Video description 🗓️ Upcoming developer events: https://dev.events Since Kent Beck wrote the book on TDD in 2002 a lot of words have been dedicated to the subject. But many of them propagated misunderstandings of Kent's original rules so that TDD practice bears little resemblance to Kent's original ideas. Key misunderstandings around what do I test, what is a unit test, and what is the 'public interface' have led to test suites that are brittle, hard to read, and do not support easy refactoring. In this talk, we re-discover Kent's original proposition, discover where key misunderstandings occurred and look at a better approach to TDD that supports software development instead of impeding it. Be prepared from some sacred cows to be slaughtered and fewer but better tests to be written.
[Source](https://www.youtube.com/watch?v=EZ05e7EMOLM)