罗罗编程学习记录
本页内容 展开查看

04.8.3.3 测试框架与质量工具

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.8 Kotlin / 04.8.3 构建工具链与测试

本节要解决的问题

本节聚焦 Kotlin/JVM 后端工程的测试落地与质量门禁:JUnit 5 与 Kotest、MockK 的用法与风格,协程测试的 runTest 与虚拟时间,测试替身取舍,参数化与属性测试,Testcontainers 集成测试,JaCoCo 覆盖率门禁,detekt/ktlint/Dokka 静态分析与文档工具,契约/API 测试以及测试分层与 CI 流水线。版本基线为 JUnit 5、Kotest、MockK 与 kotlinx-coroutines-test;具体库版本以官方文档当前版本为准。

04.8.3.3-001 JUnit 5 在 Kotlin 中如何写测试函数?

一句话结论

测试函数用 @Test 标注,无返回值,放在测试源集;Kotlin 中函数可省略 public,断言调用静态导入的断言方法或使用第三方断言库。

概念解释

JUnit 5 由平台、引擎与木星 API 组成,Kotlin 测试类与函数不需要特殊基类。测试函数可以是私有之外的成员函数,参数化测试另有注解。Kotlin 表达式风格常与断言库结合写链式断言。

原理流程

  1. 测试源码放入 src/test/kotlin。
  2. 函数标注 @Test。
  3. 调用被测对象并断言结果。
  4. 测试引擎发现并执行测试函数。

代码或图示

import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Assertions.assertEquals

class CalculatorTest {
    @Test
    fun `add 返回两数之和`() {
        assertEquals(3, Calculator().add(1, 2))
    }
}

常见误区

  • 测试函数写返回值:JUnit 测试函数应为 Unit。
  • 测试类漏加无参构造或被实例化假设:JUnit 按引擎规则实例化测试类。

追问

  • 测试函数为什么用反引号命名?答:Kotlin 允许反引号标识符写中文/空格描述性用例,提升可读性。
  • JUnit 4 注解能否混用?答:引擎兼容层可桥接,但新工程应统一 JUnit 5 注解。

04.8.3.3-002 JUnit 断言与 Kotlin 风格断言如何选择?

一句话结论

JUnit 断言提供基础相等、异常判断;Kotest/第三方断言库提供链式、类型推导的 Kotlin 风格断言。团队按统一规范选择一种,避免断言风格混用。

概念解释

JUnit 断言是静态方法调用(assertEquals(expected, actual));Kotlin 风格断言用扩展函数(actual shouldBe expected),失败信息更友好且类型推导更好。一个工程内固定主断言库,减少阅读成本。

原理流程

  1. 引入对应断言依赖到 testImplementation。
  2. 测试代码按库 API 写断言。
  3. 断言失败抛出带对比信息的异常。
  4. 测试引擎记录失败用例。

代码或图示

// JUnit 断言
assertEquals(expected, actual)

// Kotlin 风格断言(Kotest matchers,具体依赖以文档为准)
actual shouldBe expected

常见误区

  • 同一测试混用多套断言:失败信息风格不一致,维护混乱。
  • 断言不写期望值说明:失败时只看到两个值,难定位语义。

追问

  • 断言库会进入运行产物吗?答:testImplementation 依赖不打包进生产产物。
  • 链式断言失败定位在哪一步?答:各 matcher 按调用点抛出异常,堆栈指向失败断言行。

04.8.3.3-003 Kotest 框架的定位与常用 Spec 样式是什么?

一句话结论

Kotest 是 Kotlin 原生测试框架,提供多种 Spec 风格(行为描述、函数式、自由样式等)与丰富 matcher、属性测试;可通过 JUnit 引擎适配在 JUnit 平台运行。

概念解释

Spec 风格决定测试代码组织方式:如行为规格用 Given/When/Then 描述,函数式风格用 lambda 嵌套层级表达用例。Kotest 同时提供断言 matcher、数据驱动与属性测试能力,是 JUnit 之外的可选主框架。

原理流程

  1. 测试类继承某一种 Spec。
  2. 在风格 DSL 中组织用例层级。
  3. matcher 断言结果。
  4. 测试引擎执行并报告。

代码或图示

class CalculatorTest : StringSpec({
    "add 应返回两数之和" {
        Calculator().add(1, 2) shouldBe 3
    }
})

常见误区

  • 以为 Kotest 必须替代 JUnit:可通过引擎适配在 JUnit 平台运行,也有独立运行方式。
  • 在团队内混用多种 Spec 风格:选一种主风格,保持测试代码一致。

追问

  • Kotest 与 JUnit5 注解能否共存?答:按引擎适配配置,同一工程可保留 JUnit 用例与 Kotest 用例。
  • 常用 Spec 有哪些?答:StringSpec、FunSpec、BehaviorSpec 等,选风格以团队约定为准。

04.8.3.3-004 Kotest 与 JUnit 5 是什么关系?

一句话结论

Kotest 有自己的测试引擎,也可通过 JUnit 5 平台引擎适配运行;二者不是互相包含关系,工程选其一为主框架,断言与生命周期 API 各成体系。

概念解释

JUnit 5 是测试平台规范,允许不同引擎接入。Kotest 适配后其用例可被 JUnit 平台发现与报告。混用框架时注意生命周期、扩展机制不互通,断言库也各自独立。

原理流程

  1. 引入对应引擎/框架依赖。
  2. 测试类按所选框架 API 编写。
  3. 平台引擎发现并执行用例。
  4. 报告统一汇总到测试结果输出。

代码或图示

JUnit 平台 ──▶ JUnit Jupiter 引擎 / Kotest 引擎(适配)

常见误区

  • 把 JUnit 生命周期注解用在 Kotest Spec 中:二者扩展模型不同。
  • 断言库重复引入导致冲突:按主框架保留对应 matcher。

追问

  • 后端服务测试选哪个?答:按团队熟悉度与现有体系;JUnit 生态通用,Kotest Kotlin 表达力更强。
  • 迁移框架成本在哪?答:用例组织、生命周期与断言调用需改写,测试夹具设计可复用。

04.8.3.3-005 MockK 的核心 API 有哪些?

一句话结论

核心是 mock<T>() 创建替身、every { 调用 } returns 结果 打桩、verify { 调用 } 校验交互;协程场景用 coEvery/coVerify。

概念解释

MockK 是 Kotlin 专用 mock 库,支持协程、对象与静态方法替身。打桩定义方法返回行为,验证检查调用次数与参数。未打桩的方法按严格性策略返回默认值或报错。

原理流程

  1. 创建 mock 实例。
  2. every 录制方法调用与返回。
  3. 被测代码调用 mock。
  4. verify 校验交互发生与否。

代码或图示

val repo = mock<UserRepository>()
every { repo.findById(1) } returns User(1, "Ann")

val service = UserService(repo)
service.find(1)

verify(exactly = 1) { repo.findById(1) }

常见误区

  • 打桩对象与被测传入对象不是同一实例:桩不生效。
  • 验证未发生的调用却用默认次数:应明确 verify(exactly = 0) 或对应次数。

追问

  • mock 接口还是类?答:MockK 均可 mock;final 类支持方式以库版本为准。
  • 未打桩方法返回什么?答:按严格/放松策略返回默认值或抛异常,见后续题目。

04.8.3.3-006 MockK 如何 mock 挂起函数?

一句话结论

协程方法用 coEvery { } 打桩、coVerify { } 验证,而不是普通 every/verify;协程 mock 需匹配挂起签名与调度行为。

概念解释

挂起函数在 MockK 中有独立录制入口,普通 every 无法正确处理挂起调用。被测协程代码在测试调度器下运行,mock 挂起方法可返回值或抛异常模拟失败。

原理流程

  1. 创建协程依赖的 mock。
  2. coEvery 录制挂起方法返回/异常。
  3. 被测挂起函数调用 mock。
  4. coVerify 校验挂起调用。

代码或图示

val repo = mock<UserRepository>()
coEvery { repo.findAsync(1) } returns User(1, "Ann")

runTest {
    val user = service.find(1)
    coVerify { repo.findAsync(1) }
}

常见误区

  • 挂起方法误用 every:录制不匹配,调用时行为异常。
  • mock 抛异常未用协程方式声明:异常传播路径不符合协程模型。

追问

  • mock 挂起方法能延迟返回吗?答:可配合测试调度器模拟延迟,见协程测试专题。
  • 协程 mock 需要特殊依赖吗?答:MockK 协程支持随库提供,版本以官方文档为准。

04.8.3.3-007 如何 mockK 对象单例或静态方法?

一句话结论

mockkObject(单例) 临时替换 Kotlin object 或静态伴生对象行为,测试结束通过 unmockkAll() 恢复;适合替换全局单例工具,但应控制使用范围。

概念解释

Kotlin object 是全局单例,普通 mock 无法替换其调用点。mockkObject 在测试期间拦截对象方法打桩。测试后必须解除,避免影响其他用例。全局状态替身越多,测试隔离性越差。

原理流程

  1. 测试前 mockkObject 替换目标对象。
  2. every/coEvery 录制行为。
  3. 被测代码调用对象走替身。
  4. 测试后 unmockkAll() 恢复真实对象。

代码或图示

mockkObject(TimeSource)
every { TimeSource.now() } returns Instant.parse("2026-01-01T00:00:00Z")

// 测试逻辑

unmockkObject(TimeSource)

常见误区

  • 测试后不解除 mock:后续用例读到残留替身,出现偶发失败。
  • 大量 mockkObject 掩盖设计问题:全局单例难测,优先注入时钟/接口。

追问

  • 伴生对象怎么 mock?答:按 object 引用方式处理伴生对象,具体 API 以 MockK 文档为准。
  • 替代方案是什么?答:把时间/工具依赖抽象为接口注入,用普通 fake/mock 替换。

04.8.3.3-008 relaxed mock 是什么,什么时候用?

一句话结论

relaxed mock 对未打桩方法自动返回合理默认值(空集合、null、默认基本类型),减少桩代码;代价是未声明的调用不被严格检查,可能掩盖交互遗漏。

概念解释

严格 mock 遇到未打桩调用报错,迫使明确声明所有交互;relaxed mock 宽松返回默认值,适合桩方法很多的复杂依赖。默认值策略按返回类型生成,复杂对象可能返回 null。

原理流程

  1. mock(relaxed = true) 创建放松替身。
  2. 已打桩方法按桩返回。
  3. 未打桩方法返回类型默认值。
  4. 验证时仍可检查关键交互。

代码或图示

val repo = mock<UserRepository>(relaxed = true)
// 未打桩方法返回默认值,不抛异常

常见误区

  • 全用 relaxed 后不验证关键调用:业务交互未被断言,测试失去保护。
  • 依赖默认值返回复杂对象:NPE 风险,关键路径仍应显式打桩。

追问

  • relaxed 返回空列表还是 null?答:按 MockK 默认值规则,集合类型多为空集合;具体以库版本为准。
  • 严格模式有什么价值?答:强制列出依赖交互,改动时能发现未声明调用。

04.8.3.3-009 不 mock 外部依赖时测试如何组织?

一句话结论

对稳定、轻量的协作对象使用真实实现(手写 fake 或内存实现),只对不可控/重依赖(外部网关、消息中间件)使用 mock;测试围绕业务规则组织替身边界。

概念解释

mock 不是越多越好:真实 fake 能覆盖更多交互路径,mock 只隔离不稳定或慢的外部边界。选型按依赖可控性与测试目的决定,避免把内部协作也全部 mock 掉导致测试只验证桩。

原理流程

  1. 划分依赖:稳定域模型/内存实现 → 真实对象。
  2. 外部网关/中间件/时钟 → fake 或 mock。
  3. 测试注入对应替身。
  4. 断言业务行为而非桩调用细节。

代码或图示

业务规则:用内存 fake 仓储
外部支付网关:mock 或 Testcontainers

常见误区

  • 把仓储接口也 mock 掉:测试只剩调用桩,未验证真实存取规则。
  • 集成测试里大量 mock 外部依赖:失去集成验证意义。

追问

  • fake 与 mock 的本质区别?答:fake 有可用简化实现,mock 只记录交互并按桩返回,见测试替身专题。
  • 如何决定替身类型?答:需要验证行为用 mock,需要走完整简化逻辑用 fake。

04.8.3.3-010 测试类与测试函数命名有什么规范?

一句话结论

命名应描述被测行为与场景("条件 → 期望结果"),不用实现细节命名;类名对应被测单元,函数名可读出自意、前置条件与预期。

概念解释

测试名是活文档:失败时从名字即可判断场景。常见格式:方法名_场景_期望 或 Given/When/Then 描述。避免 test1、shouldWork 这类无信息命名。

原理流程

  1. 类名对应被测类/用例组。
  2. 函数名写清前置条件与预期。
  3. 断言对应预期行为。
  4. 失败时测试名直接进入报告。

代码或图示

@Test
fun `余额不足时下单应拒绝并返回错误`() { /* ... */ }

常见误区

  • 测试名复刻方法名无场景信息:失败后不知道哪个条件出错。
  • 一个测试函数塞多个行为:名字无法概括,应拆分。

追问

  • 中文测试名有什么利弊?答:可读性好,团队内统一即可;注意编码与跨平台显示。
  • 命名风格需要团队统一吗?答:需要,评审中检查命名是否描述行为。

04.8.3.3-011 JUnit 5 参数化测试怎么写?

一句话结论

@ParameterizedTest 配合数据源注解(值源、枚举源、方法源等)传入多组参数,测试函数带形参,一组输入执行一次断言。

概念解释

参数化避免为等价场景复制测试函数。数据源提供输入与期望输出,测试体共享断言逻辑。参数化适合边界值、等价类划分;复杂对象用方法源或工厂构造。

原理流程

  1. 标注参数化测试并声明数据源。
  2. 引擎按参数组多次调用测试函数。
  3. 每组独立断言与报告。
  4. 某组失败标记该参数用例。

代码或图示

@ParameterizedTest
@ValueSource(ints = [0, -1])
fun `非正数量应被拒绝(qty: Int)`(qty: Int) {
    assertThatThrownBy { OrderItem(qty) }.isInstanceOf(IllegalArgumentException::class.java)
}

常见误区

  • 参数组把输入与期望混在一列:可读性差,应明确分组。
  • 测试体隐式依赖参数顺序:形参命名对应数据列。

追问

  • 复杂对象参数怎么提供?答:方法源提供实例列表,或工厂函数构造。
  • 参数化用例名称如何展示?答:可用名字模式显示参数值,配置以 JUnit 版本为准。

04.8.3.3-012 Kotest 参数化测试如何写?

一句话结论

Kotest 提供 forAll/forNone 等数据驱动与属性测试入口,按数据列表或生成器多次执行断言;与 JUnit 参数化定位不同,Kotest 风格更偏函数式组合。

概念解释

数据驱动传入固定用例集合;属性测试传入生成器多次随机采样。Kotest matcher 在每次迭代中断言。框架负责迭代执行与失败用例报告。

原理流程

  1. 定义输入数据列表或生成器。
  2. 调用参数化/属性测试 DSL。
  3. 每轮传入参数执行断言。
  4. 失败用例附带输入值。

代码或图示

listOf(
    1 to 1,
    2 to 4
).forAll { (input, expected) ->
    square(input) shouldBe expected
}

常见误区

  • 把固定等价类用例写成属性测试:边界明确的场景用数据驱动更直接。
  • 属性测试未固定随机种子:复现失败用例困难。

追问

  • Kotest 参数化与 JUnit 参数化能互相替代吗?答:能力重叠,按主框架选择。
  • 失败参数如何缩小?答:属性测试自带用例缩小(shrink),见属性测试专题。

04.8.3.3-013 测试生命周期注解如何使用?

一句话结论

JUnit 5 用 @BeforeEach/@AfterEach 管理每个用例前后的夹具,@BeforeAll/@AfterAll 管理类级共享资源;Kotest 有对应生命周期钩子,两套体系不混用。

概念解释

每个用例通常重建被测对象,避免用例间状态共享。类级钩子用于启动昂贵共享资源(如容器)。生命周期顺序:类前 → 每用例前 → 用例 → 每用例后 → 类后。

原理流程

  1. 引擎实例化测试类。
  2. 类级钩子执行一次。
  3. 每个用例前钩子准备夹具。
  4. 用例后钩子清理,类结束钩子释放资源。

代码或图示

@BeforeEach
fun setUp() {
    service = UserService(InMemoryUserRepository())
}

常见误区

  • 在 @BeforeEach 启动重资源:每个用例重复启动,测试变慢。
  • 用例间共享可变对象:前一用例状态污染后续用例。

追问

  • 类级共享资源如何保证隔离?答:共享只读或在用例间重置;可变状态不要跨用例保留。
  • Kotest 生命周期钩子叫什么?答:按 Kotest Spec 的 beforeTest/afterTest 等 API,以版本文档为准。

04.8.3.3-014 测试实例生命周期是怎样的?

一句话结论

JUnit 默认每个测试方法创建一个测试类实例,用例之间字段不共享;可配置为类级单实例,但会放大状态耦合,后端测试一般保持默认方法级生命周期。

概念解释

默认实例化保证用例独立:字段在用例间重建。类级实例模式下字段跨用例保留,需要手动重置。测试框架实例化规则影响夹具设计,不能假设测试类是单例。

原理流程

  1. 引擎按生命周期策略创建测试类实例。
  2. 方法级:每个用例新实例。
  3. 类级:所有用例共用实例。
  4. 钩子按实例生命周期执行。

代码或图示

默认:new TestClass() ─▶ 用例1 ─▶ new TestClass() ─▶ 用例2

常见误区

  • 依赖字段跨用例累计状态:默认生命周期下字段被重置,行为不符合预期。
  • 类级实例下不清理字段:用例顺序影响结果,出现偶发失败。

追问

  • 如何查看当前生命周期?答:JUnit 配置注解/属性;默认方法级。
  • 测试类需要无参构造吗?答:按引擎实例化规则提供可构造形式,避免必填构造参数。

04.8.3.3-015 如何断言抛出异常?

一句话结论

JUnit 用 assertThrows 捕获异常并断言类型/消息;Kotest 用 shouldThrow 系列 matcher。断言应覆盖异常类型与关键消息,而不是只抛任意异常。

概念解释

异常断言先执行可能抛错的代码块,捕获异常后校验类型与信息。未抛异常则断言失败。业务错误若用结果类型返回而非异常,对应断言应检查结果值而非抛异常。

原理流程

  1. 包裹被测调用。
  2. 捕获抛出的异常。
  3. 断言类型、消息或属性。
  4. 无异常或类型不符则失败。

代码或图示

val ex = assertThrows(IllegalArgumentException::class.java) {
    OrderItem(-1)
}
assertTrue(ex.message?.contains("数量") == true)

常见误区

  • 只断言异常类型不查消息:上游改错误文案时测试不敏感。
  • 捕获过宽异常类型:掩盖具体错误分支。

追问

  • 协程代码抛异常怎么断言?答:在 runTest 中执行挂起函数并捕获断言,异常随协程传播。
  • 结果类型错误怎么测?答:断言 Left/失败分支值,见 Arrow 专题。

04.8.3.3-016 如何提升断言失败信息的可读性?

一句话结论

断言写出期望值与实际值的语义标签,使用能展示深度对比的 matcher,避免只断言布尔条件;失败报告应能直接看出哪个字段、哪组数据不符。

概念解释

assertTrue(businessValid) 失败时只知条件为假;结构化 matcher 展示对象字段差异。集合断言列出缺失/多余元素。测试夹具数据明确,失败信息才有对照基准。

原理流程

  1. 选择展示对比信息的断言 API。
  2. 断言包含关键业务字段。
  3. 失败异常携带期望与实际。
  4. 报告中按用例与断言点定位。

代码或图示

// 信息不足
assertTrue(result.isValid)

// 字段级对比
result.email shouldBe expectedEmail

常见误区

  • 一个巨型对象整体断言:失败时难以定位字段差异。
  • 断言消息写空话:应说明业务场景与期望。

追问

  • 自定义对象如何支持漂亮对比?答:实现合理 equals/hashCode,或用字段级 matcher 逐项断言。
  • 集合断言看什么信息?答:缺失项、多余项与顺序差异。

04.8.3.3-017 测试标签与分组如何使用?

一句话结论

JUnit 用 @Tag 标记用例类别,可按标签过滤执行;Kotest 有对应分组机制。标签用于区分冒烟、集成、慢测试等类别,CI 按阶段选择执行集合。

概念解释

标签是用例级元数据,不改变断言逻辑。常见分组:单元/集成/端到端、慢/快、外部依赖。测试任务按标签过滤,避免单元阶段跑重型集成测试。

原理流程

  1. 用例标注标签。
  2. 测试任务配置包含/排除标签。
  3. 执行时按标签筛选用例。
  4. 报告区分各组结果。

代码或图示

@Tag("integration")
@Test
fun `订单流程集成验证`() { /* ... */ }

常见误区

  • 标签体系混乱、一词多义:分组规则需团队约定并文档化。
  • 集成测试混入单元任务:反馈变慢且依赖环境。

追问

  • 标签与 sourceSet 分层关系?答:标签做用例级过滤,sourceSet 做编译/类路径分层,两者配合。
  • 如何在 CI 只跑冒烟用例?答:按标签或任务配置过滤,具体任务名按工程构建脚本。

04.8.3.3-018 测试套件如何组织?

一句话结论

按被测单元(类/模块)组织测试类,跨类组合用套件聚合;后端工程通常按业务域分层目录,测试类与生产包结构对应,便于定位。

概念解释

测试目录镜像主源码包结构,一个生产类对应测试类或测试组。套件用于跨类聚合执行(如某模块全部集成测试)。组织方式影响反馈速度与导航效率。

原理流程

  1. 测试源码包结构对齐主源码。
  2. 测试类按被测单元命名。
  3. 套件聚合相关测试类。
  4. CI 按分层与标签选择套件执行。

代码或图示

src/main/kotlin/com/example/order/OrderService.kt
src/test/kotlin/com/example/order/OrderServiceTest.kt

常见误区

  • 测试类按技术框架堆砌而非业务域:定位困难。
  • 套件包含跨层重型测试却在单元阶段运行:反馈变慢。

追问

  • 多个测试类共享夹具放哪里?答:测试辅助工厂/基类或共享 fixture,注意不污染用例独立性。
  • 套件能跨 sourceSet 聚合吗?答:按测试框架与构建配置支持,集成测试套件单独组织。

04.8.3.3-019 测试中的依赖注入与夹具如何管理?

一句话结论

测试中显式构造被测对象并传入替身依赖,不依赖生产 DI 容器启动;共享夹具用工厂函数或测试基类构造,保证每个用例得到干净实例。

概念解释

生产 DI 负责组装真实依赖,测试直接 new 被测类并注入 fake/mock。启动完整容器只在集成/端到端测试中使用。夹具构造逻辑封装为工厂,避免每个用例重复拼装。

原理流程

  1. 定义测试数据工厂。
  2. 用例构造替身依赖与被测对象。
  3. 执行业务行为。
  4. 断言结果与交互。

代码或图示

class OrderServiceTest {
    private val repo = InMemoryOrderRepository()
    private val service = OrderService(repo, PaymentGatewayFake())

    @Test
    fun `下单成功写入仓储`() { /* ... */ }
}

常见误区

  • 单元测试启动生产 DI 容器:变慢且混入环境依赖。
  • 夹具跨用例复用可变实例:状态污染。

追问

  • 构造参数很多怎么办?答:重构被测类依赖边界,或用测试工厂集中拼装;参数多本身是设计信号。
  • 集成测试如何注入替身?答:按环境配置替换实现,容器装配真实依赖或 Testcontainers。

04.8.3.3-020 共享测试数据工厂怎么设计?

一句话结论

用工厂函数/DSL 构造测试数据,提供默认合法实例与覆盖项;工厂只造数据,不承载业务断言,保证各用例按需改字段而不复制样板。

概念解释

测试数据重复拼装分散在各用例中易漂移。工厂产出合法基线对象,用例覆盖关键字段。复杂聚合根提供层级工厂。工厂对象本身不持有可变状态。

原理流程

  1. 定义数据工厂函数与默认值。
  2. 用例调用工厂取得基线实例。
  3. 覆盖场景相关字段。
  4. 数据进入被测流程。

代码或图示

fun anOrder(id: Long = 1, status: OrderStatus = OrderStatus.PAID) = Order(id, status)

常见误区

  • 工厂内置业务规则判断:数据构造与业务逻辑混淆。
  • 工厂返回共享可变实例:用例间修改互相影响,应每次新建。

追问

  • 敏感/边界数据放工厂吗?答:边界值在对应用例显式构造,工厂保持合法基线。
  • 工厂需要测试吗?答:关键构造逻辑可自检,但不应过度测试数据样板。

04.8.3.3-021 MockK 如何验证调用次数?

一句话结论

verify(mode) { 调用 } 中 mode 指定次数:exactly(n)、never、atLeast(n) 等;验证同时可匹配参数,确认交互发生的次数与条件。

概念解释

次数校验防止多余调用或漏调用。未匹配参数的调用不计入对应验证。严格 mock 下未验证的打桩调用也可能在收尾时报未使用桩。

原理流程

  1. 被测代码执行对 mock 的调用。
  2. verify 按模式统计匹配调用。
  3. 次数不符抛验证异常。
  4. 参数匹配器限定计入范围。

代码或图示

verify(exactly = 1) { repo.save(match { it.id == 1 }) }
verify(never) { repo.delete(any()) }

常见误区

  • 只验证调用不验参数:错误参数的调用也被放过。
  • 次数模式与实际业务语义不符:按业务应发生的交互选择模式。

追问

  • 顺序调用如何验证?答:MockK 顺序验证 API(verifyOrder 类),具体名称以库版本为准。
  • 未使用的桩如何发现?答:严格模式收尾检查未匹配打桩,及时清理冗余桩。

04.8.3.3-022 MockK 如何捕获调用参数?

一句话结论

用 slot 或捕获器在 verify/every 中取出实际参数,再对捕获值做断言;捕获用于校验传入依赖的对象内容,而不仅是调用发生。

概念解释

参数匹配器只能判断相等或类型,需要检查对象内部字段时先捕获再断言。捕获器在调用时记录实参,验证阶段取出。多次调用捕获列表按顺序保存。

原理流程

  1. 定义捕获槽位。
  2. 打桩/验证中用捕获器占位。
  3. 被测调用写入实参。
  4. 从槽位取出参数断言。

代码或图示

val saved = slot<Order>()
verify { repo.save(capture(saved)) }
saved.captured.status shouldBe OrderStatus.PAID

常见误区

  • 捕获后不断言字段:只证明调用,未验证内容正确。
  • 多次调用复用单槽:只留最后一次,多次场景用列表捕获。

追问

  • 复杂对象部分字段匹配怎么做?答:match { } 内判断字段组合,或捕获后逐项断言。
  • 捕获协程调用参数?答:在 coVerify 中使用捕获器。

04.8.3.3-023 spyk(部分 mock)怎么用?

一句话结论

spyk() 包装真实对象,保留大部分方法真实实现,只对指定方法打桩覆盖;用于在不整体替身的情况下隔离个别协作点。

概念解释

纯 mock 完全替换行为;spy 委托真实实现,仅拦截桩方法。部分 mock 适合遗留对象难构造、只想替换一个外部调用的场景。过度使用 spy 说明依赖边界不清。

原理流程

  1. 包装真实对象生成 spy。
  2. 对需隔离方法 every 打桩。
  3. 其余方法走真实实现。
  4. 验证被拦截方法交互。

代码或图示

val calculator = spyk(RealCalculator())
every { calculator.riskyExternal() } returns 0

常见误区

  • 用 spy 绕过构造困难:应改善可测试性设计,而非长期保留部分替身。
  • 未打桩方法仍被 spy 代理:确认真实委托行为符合预期。

追问

  • spy 与 mock 选择标准?答:需要真实逻辑走通用 spy,全隔离用 mock;优先 fake 替代两者。
  • spy 能 mock final 方法吗?答:按库对 final 成员的支持能力,以版本文档为准。

04.8.3.3-024 如何避免 MockK 严格性误报?

一句话结论

明确区分"必须交互"与"可选交互":关键调用显式 verify,无关依赖用 relaxed 或不打桩;清理未使用桩,按场景选择严格/宽松模式,而非靠全局放松消除告警。

概念解释

严格模式下未匹配桩、未验证调用都会报错,本意是暴露冗余配置;误报常来自桩写了未发生分支、依赖在某些用例中无交互。逐用例调整桩与验证,而不是全局 relaxed。

原理流程

  1. 梳理每个用例的预期交互。
  2. 只打桩该用例需要的方法。
  3. 关键调用显式验证。
  4. 收尾检查未使用桩并删除。

代码或图示

严格:未用桩报错 → 删除或移动到需要的用例
宽松:relaxed 兜底默认值 → 关键路径仍显式桩

常见误区

  • 遇到严格报错就全局 relaxed:掩盖真实冗余桩与漏验证。
  • 桩在多个用例间复用:不同分支交互不同,桩应按用例最小化。

追问

  • 未使用桩告警在哪个阶段报?答:测试收尾校验,具体规则以 MockK 版本为准。
  • 共享 mock 夹具如何避免残留?答:每用例重建 mock 或在前后钩子里重置。

04.8.3.3-025 JUnit 扩展与 Kotest 监听器有什么区别?

一句话结论

JUnit 扩展通过 Extension API 介入生命周期(前置/后置/异常处理);Kotest 用 listener 接口挂钩测试层级事件。两者模型独立,按主框架使用对应机制。

概念解释

扩展可复用通用测试逻辑:启动资源、记录失败、注入参数。JUnit 扩展注册后作用于匹配用例;Kotest listener 监听 Spec/用例生命周期事件。不要在 Kotest 用例上挂 JUnit 扩展。

原理流程

  1. 实现框架对应扩展/listener 接口。
  2. 按测试类或全局注册。
  3. 生命周期事件触发钩子。
  4. 钩子完成资源准备与清理。

代码或图示

JUnit:Extension + @ExtendWith / 自动注册
Kotest:TestListener 挂钩 beforeTest/afterTest 等事件

常见误区

  • 两套扩展机制混挂:生命周期不互通,行为不确定。
  • 扩展里持有可变全局状态:用例隔离被破坏。

追问

  • 跨框架通用的测试工具放哪里?答:纯函数工具可共享,生命周期钩子按框架各写适配。
  • 扩展失败如何影响用例?答:钩子异常按框架规则计入测试结果,清理失败需单独处理。

04.8.3.3-026 runTest 的作用是什么?

一句话结论

runTest 是协程测试入口:提供带测试调度器的协程作用域,虚拟时间推进,断言挂起函数与并发协程行为,避免真实延迟等待。

概念解释

被测挂起函数在 runTest 作用域内执行,调度器使用测试调度器,delay 不真实等待而是推进虚拟时间。作用域结束时检查未完成协程与异常。它来自协程测试库,需引入对应测试依赖。

原理流程

  1. 引入 kotlinx-coroutines-test 依赖。
  2. runTest { } 创建测试协程作用域。
  3. 调度器用虚拟时间执行协程。
  4. 断言结果,作用域收尾检查未处理协程。

代码或图示

@Test
fun `加载用户应返回结果`() = runTest {
    val user = service.find(1)
    user.name shouldBe "Ann"
}

常见误区

  • 普通 runBlocking 代替 runTest:真实 delay 拖慢测试,虚拟时间能力缺失。
  • runTest 内启动协程未在作用域管理:收尾时未完成协程报错。

追问

  • runTest 与 JUnit 注解冲突吗?答:测试函数返回 Unit,runTest 作为函数体执行;异步等待模型由作用域管理。
  • 测试库坐标?答:kotlinx-coroutines-test,版本与协程库对齐。

04.8.3.3-027 为什么用普通 runBlocking 测协程代码有问题?

一句话结论

runBlocking 使用真实调度器并真实等待 delay,测试慢且受并发时序影响;它不提供虚拟时间、未完成协程检查与测试调度器控制,容易产生 flaky。

概念解释

runBlocking 用于桥接阻塞与协程世界,不是测试工具。生产调度器、真实时钟与并发交错都进入测试,导致偶发失败。runTest 替换为测试调度器并控制时间推进,结果可重复。

原理流程

  1. runBlocking 运行在真实调度器。
  2. delay 真实挂起等待。
  3. 并发交错依赖线程时序。
  4. 测试耗时与不稳定性上升。

代码或图示

// 不推荐:真实等待
@Test
fun oldStyle() = runBlocking {
    delay(1000) // 真实等待 1 秒
}

常见误区

  • 测试里靠 sleep 等待异步结果:时序耦合,机器负载高时失败。
  • 用 runBlocking 验证超时行为:真实超时窗口不可控。

追问

  • runBlocking 完全不能用于测试吗?答:极少数桥接场景可参考,常规协程测试用 runTest。
  • 真实 IO 测试如何等待?答:集成测试用同步返回或显式完成信号,不靠 sleep 猜时序。

04.8.3.3-028 TestDispatcher 与虚拟时间如何工作?

一句话结论

测试调度器用虚拟时间替代真实时钟:delay 不挂起真实线程,而是按虚拟时间排队调度;测试可快进时间验证超时、周期任务等时间相关逻辑。

概念解释

虚拟时间维护逻辑时钟,调度任务按延迟时间排序执行。测试无需等待真实毫秒。调度器在 runTest 作用域内替换默认调度器,挂起函数读到的时间随虚拟时钟推进。

原理流程

  1. runTest 安装测试调度器。
  2. 协程调用 delay 登记到虚拟时间队列。
  3. 作用域推进时间执行到期任务。
  4. 断言时间相关结果。

代码或图示

@Test
fun `超时后返回默认值`() = runTest {
    val result = service.withTimeoutFallback()
    result shouldBe fallback
}

常见误区

  • 被测代码硬编码真实线程调度器:测试调度器无法替换,虚拟时间失效。
  • 依赖真实 wall-clock 判断:应注入时钟/调度器抽象。

追问

  • 如何推进虚拟时间?答:runTest 自动按任务队列推进;手动控制调度器的 API 以协程测试库版本为准。
  • 并发任务在虚拟时间下如何交错?答:按调度器队列与挂起点执行,具体顺序以测试调度器实现为准。

04.8.3.3-029 返回 Flow 的挂起函数如何测试?

一句话结论

在 runTest 中收集 Flow 元素,用测试断言序列匹配;冷流按收集触发,可测试元素顺序、完成与异常,必要时用 Turbine 类库做逐条事件断言。

概念解释

Flow 是冷异步数据流,测试要验证发出的元素序列与时序。基础方式 toList() 收集全部;逐条断言用专门的 Flow 测试库(如 Turbine,坐标以官方当前版本为准)控制事件窗口。

原理流程

  1. 在测试作用域内调用返回 Flow 的函数。
  2. 收集元素或逐条订阅。
  3. 断言元素序列、顺序与完成。
  4. 异常场景断言错误事件。

代码或图示

@Test
fun `状态流依次发出初始与更新`() = runTest {
    val values = service.observe().toList()
    values shouldBe listOf(initial, updated)
}

常见误区

  • 不收集就断言 Flow:冷流未触发,无元素产生。
  • 无限流直接 toList:永不结束,需取有限前缀或取消作用域。

追问

  • 无限流如何取前几个元素?答:用 take(n) 或 Flow 测试库逐条取消订阅。
  • Flow 异常事件怎么断言?答:收集时捕获异常或断言错误通道事件,按 Flow 协议处理。

04.8.3.3-030 协程取消如何断言?

一句话结论

在测试作用域内取消协程,断言取消状态与资源清理行为;取消是协程协作式的,需验证代码在 CancellationException 下正确退出与释放资源。

概念解释

协程取消通过作用域取消传播,被取消协程抛出 CancellationException。测试要确认挂起点响应取消、资源(连接、订阅)被清理。不能把取消异常当业务错误记录。

原理流程

  1. 启动被测协程任务。
  2. 取消作用域/任务。
  3. 断言任务状态为已取消。
  4. 检查资源清理副作用。

代码或图示

@Test
fun `取消后订阅被释放`() = runTest {
        val job = launch { service.stream() }
        job.cancel()
        job.isCancelled shouldBe true
    }

常见误区

  • 把 CancellationException 当失败断言:它是正常取消信号。
  • 长循环不检查取消状态:取消不协作,测试无法及时终止。

追问

  • 资源清理在哪一步验证?答:取消后检查 fake/桩中的关闭方法是否被调用。
  • 子协程取消如何传播?答:父作用域取消取消子协程,按作用域父子规则断言。

04.8.3.3-031 超时测试如何配合测试调度器?

一句话结论

在 runTest 虚拟时间下验证 withTimeout 等超时逻辑:延迟到期由虚拟时钟推进,断言超时分支触发,不需要真实等待超时窗口。

概念解释

超时逻辑依赖时间流逝,真实调度器下测试要等待完整超时;虚拟时间直接跳到到期点。被测代码使用可注入的超时/时钟抽象,测试才能稳定验证超时分支。

原理流程

  1. 被测逻辑声明超时与回退。
  2. runTest 内触发延迟操作。
  3. 虚拟时间推进到超时点。
  4. 断言超时分支结果或异常。

代码或图示

@Test
fun `超过时限返回回退结果`() = runTest {
    val result = service.callWithFallback(timeoutMillis = 100)
    result shouldBe fallback
}

常见误区

  • 超时值写死且依赖真实时钟:测试慢或 flaky。
  • 超时异常被业务错误捕获吞掉:分支未被验证。

追问

  • 超时单位与虚拟时间一致吗?答:虚拟时间按毫秒逻辑推进,单位与超时 API 对应。
  • 真实网络超时在单元测试怎么测?答:单元测试用挂起延迟模拟;真实超时由集成/容器测试覆盖。

04.8.3.3-032 多个并发协程如何测试?

一句话结论

在 runTest 作用域内 launch 多个协程,通过屏障/收集器同步汇合后断言结果与共享状态;避免靠睡眠等待并发完成。

概念解释

并发测试关注竞态下的结果正确性与共享状态安全。测试用同步原语(CountDownLatch 类、收集列表、屏障)等待全部协程完成,再断言聚合结果。调度器顺序模型帮助复现确定性交错。

原理流程

  1. 作用域内启动多个被测协程。
  2. 协程写入线程安全收集器。
  3. 汇合等待全部完成。
  4. 断言聚合结果与顺序/次数。

代码或图示

@Test
fun `并发提交全部入账`() = runTest {
    repeat(10) { launch { service.submit(it) } }
    advanceUntilIdle()
    repo.count() shouldBe 10
}

常见误区

  • 启动协程后立即断言:子协程未完成,结果不确定。
  • 共享普通可变列表跨协程:并发写入异常,用线程安全收集器。

追问

  • 如何等待所有子协程完成?答:作用域 join 或汇合原语;测试调度器可推进到空闲。
  • 竞态问题在测试中复现不了怎么办?答:提高并发轮次、检查同步机制,真实竞争由压测补充。

04.8.3.3-033 测试中 Dispatchers.Main 如何处理?

一句话结论

后端服务一般不涉及 Main 调度器;涉及 UI/端侧代码时,测试通过测试规则替换 Main 调度器为测试调度器,避免 Main 未初始化异常。本节以后端视角说明概念,端侧细节见 07 分册。

概念解释

Dispatchers.Main 绑定平台主线程,单元测试环境未初始化。测试框架提供 Main 调度器替换规则。后端协程代码应注入调度器而非硬编码 Main,便于测试替换。

原理流程

  1. 被测代码通过参数注入调度器。
  2. 测试传入测试调度器。
  3. 不依赖 Main 初始化。
  4. 端侧场景使用 Main 测试替换规则。

代码或图示

class Service(private val dispatcher: CoroutineDispatcher = Dispatchers.Default)

常见误区

  • 业务代码硬编码 Dispatchers.Main:后端无 Main,且测试无法替换。
  • 单元测试初始化真实 Main:引入平台依赖,测试失去隔离。

追问

  • 调度器注入是设计建议吗?答:是,便于测试与切换线程模型;见后端协程章节。
  • 后端默认调度器用什么?答:按服务模型选择 Default/IO,测试替换为测试调度器。

04.8.3.3-034 帧推进与 await 在测试中如何使用?

一句话结论

测试调度器通过推进时间/执行队列控制协程帧;需要等待特定状态时使用调度器提供的空闲推进或等待 API,而不是真实 sleep。

概念解释

协程多帧挂起恢复,测试调度器按队列逐帧执行。advanceUntilIdle 类 API 推进到队列清空;单步推进 API 可观察中间状态。具体 API 名称与能力以协程测试库版本为准。

原理流程

  1. 启动协程链。
  2. 调度器按挂起点逐帧恢复。
  3. 推进到空闲或指定时刻。
  4. 断言中间/最终状态。

代码或图示

runTest {
    launch { service.process() }
    advanceUntilIdle() // 推进至队列空闲(API 以版本为准)
    state shouldBe processed
}

常见误区

  • 用 sleep 等待帧推进:真实时序不可控。
  • 不推进就断言中间状态:协程尚未恢复。

追问

  • 如何观察两帧之间的状态?答:分步推进调度器,在帧间隙断言。
  • 调度器 API 随版本变化吗?答:是,以当前协程测试库文档为准,不确定处标待确认。

04.8.3.3-035 协程测试常见的 flaky 来源有哪些?

一句话结论

常见来源:真实调度器与真实时钟、未等待子协程完成、共享可变状态无同步、硬编码线程切换、异常未在作用域内收集;修正方向是注入调度器、用 runTest 汇合、线程安全收集。

概念解释

flaky 表现为偶发失败,根因多为时序假设。测试应在确定性调度器下汇合所有协程,断言聚合结果;并发共享状态用线程安全结构。未收集的异常可能在作用域收尾才暴露。

原理流程

  1. 识别偶发失败用例的时序假设。
  2. 替换测试调度器与虚拟时钟。
  3. 汇合子协程后再断言。
  4. 检查共享状态与异常传播。

代码或图示

flaky 排查:调度器 → 汇合等待 → 共享状态 → 异常收集

常见误区

  • 增加 sleep 时长"修复"偶发:根因未除,负载高时仍失败。
  • 忽略作用域内未处理异常:收尾时报错信息定位困难。

追问

  • 如何复现偶发竞态?答:重复执行用例、提高并发量、检查同步原语缺失。
  • CI 与本地结果不一致?答:核对调度器、时钟与环境并发度,优先保证测试不依赖真实时序。

04.8.3.3-036 fake、stub、mock、spy 如何取舍?

一句话结论

fake 是有简化可用实现的替身,stub 只返回预设应答,mock 记录交互供验证,spy 包装真实对象部分拦截;按"是否需要走真实逻辑、是否需要验证交互"选择。

概念解释

四类替身解决不同问题:需要可用简化逻辑用 fake;只喂固定返回值用 stub;要校验调用交互用 mock;保留真实实现只隔离一点用 spy。命名与职责应在测试代码中清晰区分。

原理流程

  1. 判断替身是否需要行为实现。
  2. 需要简化逻辑 → fake;仅预设返回 → stub。
  3. 需要验证交互 → mock;局部覆盖 → spy。
  4. 优先 fake,减少交互断言与实现耦合。

代码或图示

fake:内存仓储,真实存取逻辑
stub:固定返回查询结果
mock:验证 save 被调用
spy:真实对象 + 拦截外部调用

常见误区

  • 术语混用导致测试意图不清:类名/注释标明替身类型。
  • 能用 fake 的地方用 mock:测试与依赖方法签名过度耦合。

追问

  • stub 与 mock 区别?答:stub 只提供应答不验证交互;mock 记录并验证调用。
  • 一个替身可以兼具多种性质吗?答:可以,但职责混合后测试可读性下降,应尽量单一。

04.8.3.3-037 什么时候手写 fake 优于使用 mock?

一句话结论

当依赖有简单、确定的可简化逻辑(仓储、时钟、邮箱发送记录)时,手写 fake 能覆盖更多业务路径;mock 适合复杂协议、外部网关与只需验证交互的场景。

概念解释

fake 实现接口的内存版本,业务代码走完整分支;mock 只按桩返回,路径覆盖有限。手写 fake 成本是维护一份简化实现,换来测试稳定与少交互断言。内部协作依赖优先 fake。

原理流程

  1. 识别接口边界与可简化行为。
  2. 编写内存 fake 实现。
  3. 测试注入 fake 走业务流程。
  4. 必要时记录调用历史供断言。

代码或图示

class InMemoryUserRepository : UserRepository {
    private val store = mutableMapOf<Long, User>()
    override fun find(id: Long) = store[id]
    override fun save(user: User) { store[user.id] = user }
}

常见误区

  • fake 里复制业务规则:替身应简化而非复刻生产逻辑。
  • fake 状态不重置:用例间数据残留,每用例新建。

追问

  • fake 要实现全部接口方法吗?答:按测试需要实现,未用方法可抛未实现或返回空。
  • fake 与真实实现行为不一致怎么办?答:契约测试约束两侧行为一致,见契约测试专题。

04.8.3.3-038 测试替身与接口设计有什么耦合?

一句话结论

替身依赖抽象接口注入;难以替身的具体类、静态调用、全局单例暴露设计问题。良好的依赖反转让替身替换成为自然结果,而不是测试技巧。

概念解释

mock/fake 都面向接口或抽象类型编程。若业务直接 new 具体类、调用 object 单例,测试必须改造或 mockkObject。可测试性是设计约束:外部边界以接口暴露,内部实现可替换。

原理流程

  1. 依赖通过构造器/参数注入抽象类型。
  2. 测试注入替身实现。
  3. 业务代码面向接口调用。
  4. 替换实现不改动业务逻辑。

代码或图示

class OrderService(private val payment: PaymentGateway) // 依赖接口

常见误区

  • 为测试把具体类整体 mock:说明抽象不足,应先重构边界。
  • 替身接口随测试反复改签名:接口应服务业务语义,不为测试迁就。

追问

  • 遗留代码难以注入怎么办?答:先在边界包一层接口,逐步替换;测试用适配器隔离。
  • 静态工具函数如何处理?答:包装为接口方法注入,优于全局 mock。

04.8.3.3-039 内存 fake 如何保证与真实实现契约一致?

一句话结论

fake 与真实实现共享同一接口,通过契约测试用同一组用例验证两侧行为;关键业务规则(唯一约束、状态流转)在 fake 中按相同语义简化实现。

概念解释

fake 简化的是存储与外部通信,不是业务规则。契约测试定义接口期望行为,fake 与真实实现分别跑同一组断言。fake 遗漏规则会让单元测试通过、集成测试失败。

原理流程

  1. 抽取接口行为规范。
  2. 编写契约测试用例集。
  3. fake 与真实实现分别执行。
  4. 行为不一致时修正实现或明确差异。

代码或图示

契约测试用例集 ──▶ InMemoryRepo
              ──▶ PostgresRepo

常见误区

  • fake 只做 Map 存取不校验规则:唯一性、级联删除等行为与真实库不符。
  • 契约测试只跑 fake:集成侧行为未被覆盖。

追问

  • 性能特征需要 fake 模拟吗?答:单元测试不模拟性能;并发与容量由集成/压测覆盖。
  • fake 允许哪些简化?答:内存存储、同步返回、不持久化;业务规则不简化。

04.8.3.3-040 mock 出的依赖是否反映真实协议?

一句话结论

不自动反映:mock 按桩返回,可能与真实依赖的错误码、边界、并发行为不一致;协议兼容性需契约测试或集成测试验证,mock 只隔离单元测试环境。

概念解释

桩假设的请求/响应结构可能与真实网关协议漂移。mock 让单元测试快而稳定,但不保证对接正确。外部协议的正确性靠 API 测试、契约测试与集成环境验证。

原理流程

  1. 单元测试用 mock 隔离协议细节。
  2. 契约测试核对请求/响应格式。
  3. 集成测试连接真实/容器化依赖。
  4. 发现协议漂移时更新 mock 与真实适配。

代码或图示

单元测试:mock 协议响应
契约测试:真实 schema/格式核对
集成测试:容器化依赖联调

常见误区

  • mock 通过就认为对接成功:协议错误未在单元层暴露。
  • mock 桩假设错误响应总是同一类型:真实依赖错误种类可能更多。

追问

  • 如何防止 mock 与真实协议脱节?答:契约测试固定消息格式,响应样例来自真实/容器环境。
  • 外部依赖文档不可靠怎么办?答:以联调样例与契约测试为准,记录差异点。

04.8.3.3-041 外部网关的测试替身策略是什么?

一句话结论

单元测试用 mock/fake 隔离网关协议与延迟;契约测试验证请求响应格式;集成/端到端用沙箱或容器化替代服务覆盖真实交互;按测试分层选择替身。

概念解释

外部网关不可控、有网络与配额成本,单元层不直连。替身策略按层递进:内部业务规则用替身,跨系统协议用契约,真实链路用受控环境。不同层关注点不同。

原理流程

  1. 单元层:mock 网关成功/失败响应。
  2. 契约层:核对消息结构与错误码。
  3. 集成层:沙箱/容器化服务联调。
  4. 问题在对应层定位修复。

代码或图示

单元:mock 网关
契约:格式校验
集成:测试环境网关 / 容器替代

常见误区

  • 单元测试直连外部网关:不稳定、有成本且污染外部数据。
  • 集成测试仍 mock 网关:跨系统行为未验证。

追问

  • 第三方沙箱不可用时怎么办?答:容器化实现兼容协议的替代服务,或录制回放样例。
  • 网关超时/限流如何测?答:单元层用替身模拟延迟与错误;真实限流由预发环境验证。

04.8.3.3-042 测试数据库用 fake 还是 Testcontainers?

一句话结论

业务规则单元测试用内存 fake 仓储;涉及 SQL、约束、迁移与真实驱动行为的用 Testcontainers 启动真实数据库实例;H2 类内存库仅在兼容范围内作为轻量替代。

概念解释

fake 验证业务编排,不验证 SQL 与数据库特性;Testcontainers 提供真实数据库引擎,覆盖方言、索引、约束与迁移。选择按测试目的:规则逻辑 vs 持久化正确性。

原理流程

  1. 单元测试:fake 仓储走业务规则。
  2. 集成测试:容器启动真实数据库。
  3. 执行迁移初始化 schema。
  4. 断言持久化行为。

代码或图示

单元:InMemoryRepo
集成:PostgreSQL 容器 + 迁移 + DAO 测试

常见误区

  • 用 H2 替代 PostgreSQL 后不做真实库验证:方言与特性差异漏到生产。
  • 所有测试都起容器:反馈慢,单元层应保持轻量。

追问

  • 容器数据库每次都新建吗?答:按测试隔离策略新建/复用,见 Testcontainers 专题。
  • 持久层契约怎么测?答:容器库上跑 DAO/查询用例,核对 SQL 结果与约束。

04.8.3.3-043 属性测试的思想是什么?

一句话结论

属性测试不罗列固定用例,而是定义"对任意输入都应成立"的不变式,由生成器随机采样大量输入验证;发现反例后自动缩小到最小失败用例。

概念解释

传统测试给具体输入期望输出;属性测试刻画通用规律(如反转两次还原、序列化往返一致)。生成器覆盖边界与随机组合,弥补手工用例遗漏。失败反例被缩小后便于定位。

原理流程

  1. 定义输入生成器与不变式断言。
  2. 框架多次随机采样执行。
  3. 找到违反属性的输入。
  4. 缩小反例并报告最小复现。

代码或图示

属性:encode(decode(x)) == x
生成器:合法值随机采样 → 反复验证往返

常见误区

  • 把只在特定范围成立的规则写成全局属性:生成非法输入导致误报。
  • 不定义边界约束:生成器产出无意义极端值。

追问

  • 属性测试能替代示例用例吗?答:不能,关键业务场景仍需固定示例;属性测试补充随机与边界覆盖。
  • 生成器如何约束合法输入?答:按类型与范围定制生成器,排除非法组合。

04.8.3.3-044 Kotest 属性测试如何写?

一句话结论

用属性测试 DSL 组合输入生成器与断言函数,框架按迭代次数采样执行;具体 matcher 与生成器 API 以 Kotest 当前版本文档为准。

概念解释

声明式描述"输入如何生成 → 断言什么不变式"。基础类型有内置生成器,自定义类型组合字段生成器。迭代次数与配置可按用例调整。失败时附带反例输入。

原理流程

  1. 引入 Kotest 属性测试依赖。
  2. 组合生成器描述输入域。
  3. 写断言函数验证不变式。
  4. 框架采样执行并报告反例。

代码或图示

// 示意:数字绝对值非负(API 以 Kotest 版本为准)
property("abs 结果非负") {
    forAll<Int> { n ->
        abs(n) >= 0
    }
}

常见误区

  • 断言里隐藏外部随机源:属性测试不可复现。
  • 生成器未覆盖关键边界:边界值仍需示例用例补充。

追问

  • 自定义对象怎么生成?答:组合各字段生成器构造对象生成器。
  • 属性测试运行多少次?答:默认迭代次数可配置,复杂用例按时间/样本数平衡。

04.8.3.3-045 失败用例缩小(shrink)是如何工作的?

一句话结论

发现反例后,属性测试框架逐步缩小输入(减少长度、替换为更小值),在保持失败的前提下找到最小复现输入,便于定位根因。

概念解释

随机大输入失败时,直接看原始反例难定位;缩小过程尝试更小/更简单的变体,只要仍违反属性就继续收缩。缩小结果是最小触发失败的样本。并非所有类型都支持自动缩小。

原理流程

  1. 属性测试找到失败输入。
  2. 框架生成缩小候选。
  3. 候选仍失败则保留并继续收缩。
  4. 输出最小反例与原始失败样本。

代码或图示

反例:长度 50 的列表 → 缩小到长度 2 仍失败 → 报告最小样本

常见误区

  • 依赖缩小后输入理解业务边界:最小样本只定位触发条件,完整边界仍需分析。
  • 自定义类型未实现缩小支持:反例不可收缩,报告原始大输入。

追问

  • 缩小会改变输入合法性吗?答:在保持违反属性的前提下收缩,候选仍在输入域内。
  • 缩小过程耗时如何控制?答:框架按策略限制收缩步数,具体配置以库版本为准。

04.8.3.3-046 边界值与随机种子如何管理?

一句话结论

边界值(零、空、极值、非法输入)应在示例用例显式覆盖;属性测试固定随机种子可复现失败,默认随机采样保持广度。

概念解释

随机采样可能漏掉关键边界,边界场景靠显式用例锁定。偶发失败需要复现路径:记录失败种子/输入,重放定位。种子管理让 flaky 属性测试可重复调试。

原理流程

  1. 枚举等价类与边界值写示例测试。
  2. 属性测试随机采样补充组合。
  3. 失败记录种子与反例。
  4. 用记录种子重放复现。

代码或图示

显式:0、空串、最大值、非法格式
属性:随机合法组合 + 固定种子复现

常见误区

  • 只靠随机覆盖边界:关键边界可能长期未命中。
  • 失败后丢弃反例输入:无法稳定复现与回归验证。

追问

  • 种子在哪里配置?答:属性测试 DSL 提供种子配置,具体 API 以框架版本为准。
  • 随机测试在 CI 上每次不同怎么办?答:保留失败种子加入回归用例,转为固定示例。

04.8.3.3-047 Testcontainers 是什么定位?

一句话结论

Testcontainers 在测试中以 Docker 容器启动真实依赖(数据库、消息队列、缓存等),用真实引擎跑集成测试,替代内存库与模拟服务。

概念解释

容器在测试开始前启动镜像,测试结束后销毁。连接信息由容器对象获取。它解决内存库方言差异、模拟协议不真实的问题,代价是测试启动成本与 Docker 环境依赖。

原理流程

  1. 测试声明容器镜像与配置。
  2. 启动等待健康就绪。
  3. 获取连接串接入应用配置。
  4. 执行集成测试,结束后销毁容器。

代码或图示

// 示意:PostgreSQL 容器(坐标与 API 以 Testcontainers 当前版本为准)
val pg = PostgreSQLContainer("postgres:16")
pg.start()
// 用 pg.jdbcUrl 配置数据源

常见误区

  • 单元测试也起容器:反馈慢,容器应用于集成测试层。
  • 不等待健康就绪就连接:启动未完成导致连接失败。

追问

  • Testcontainers 需要本地 Docker 吗?答:测试环境需可用 Docker 守护进程,CI 按平台配置。
  • 容器镜像版本如何对齐生产?答:使用与生产一致的大版本镜像标签。

04.8.3.3-048 容器复用策略有哪些?

一句话结论

按测试隔离需求选择:每用例新容器、每类共享容器、或开启容器复用模式跨用例/跨会话复用;隔离性与启动速度权衡,复用需保证数据清理。

概念解释

新容器隔离最彻底但启动慢;测试类共享容器在用例间清理数据;复用模式减少重复拉起。共享/复用时必须在每个用例前后重置状态,避免数据污染。

原理流程

  1. 确定测试隔离级别。
  2. 配置容器生命周期(用例/类/会话)。
  3. 共享容器在用例间执行清理脚本。
  4. 测试结束按策略销毁。

代码或图示

每用例:新容器,强隔离
每类共享:启动一次,用例间清库
复用模式:跨用例保留容器(开启方式以文档为准)

常见误区

  • 共享容器不清数据:用例互相污染,出现偶发失败。
  • 复用容器残留会话状态:连接、事务、临时对象需清理。

追问

  • 容器复用模式有什么前提?答:测试环境支持、镜像与配置稳定;具体开关以 Testcontainers 文档为准。
  • 并行测试如何隔离容器?答:各测试组独立容器或独立 schema/数据库,避免共享数据。

04.8.3.3-049 Testcontainers 如何与后端框架测试集成?

一句话结论

测试启动容器后取连接信息,覆盖应用配置(数据源、队列地址),再按框架测试方式启动应用或连接客户端;框架测试钩子负责容器生命周期管理。

概念解释

Ktor/Spring 等测试启动方式不同,但接入点一致:先有容器连接串,再注入应用配置。容器可作为测试扩展/规则管理生命周期。应用内配置按测试环境读取覆盖值。

原理流程

  1. 测试扩展启动容器。
  2. 读取 jdbcUrl/端口/凭证。
  3. 覆盖应用对应配置项。
  4. 启动应用或客户端执行集成断言。

代码或图示

容器启动 → 连接串 → 覆盖数据源配置 → 应用测试启动 → 断言

常见误区

  • 应用配置写死本地库地址:测试无法接入容器。
  • 容器启动晚于应用配置读取:连接信息未注入成功。

追问

  • Spring 工程如何接入?答:用其测试扩展与属性覆盖机制;具体集成方式按框架文档。
  • Ktor 工程如何接入?答:测试环境配置容器连接后启动客户端/服务端,见 06 分册 Ktor 章节。

04.8.3.3-050 容器生命周期与并行测试隔离如何保证?

一句话结论

每个并行测试组使用独立容器或独立库/schema,生命周期由测试扩展管理;用例间清理数据,避免共享容器在并行下读写交错。

概念解释

并行执行时共享容器会出现数据竞争。隔离策略:独立容器成本高但彻底;同容器多 schema/库按测试组分隔。容器销毁随测试组结束,不跨组残留。

原理流程

  1. 并行规划测试组。
  2. 每组分配独立容器或独立命名空间。
  3. 用例前后清理该组数据。
  4. 测试组结束销毁容器。

代码或图示

并行组 A ──▶ 容器 A / schema A
并行组 B ──▶ 容器 B / schema B

常见误区

  • 并行共用一个数据库:表数据交叉污染。
  • 容器跨测试组复用但不重置:状态残留导致顺序依赖。

追问

  • 容器资源不足怎么办?答:限制并行度、共享隔离 schema、或分阶段执行集成测试。
  • 如何验证隔离有效?答:并发运行用例并检查各数据集互不影响。

04.8.3.3-051 网络访问与连接串如何从容器获取?

一句话结论

容器对象暴露主机、端口与连接串方法,测试据此配置客户端;容器映射的端口在测试主机可达,内部网络别名用于多容器互联。

概念解释

Testcontainers 自动映射容器端口到宿主随机端口。单容器测试从容器对象取连接串;多容器依赖网络时加入同一网络,用容器别名互联。连接信息不写死固定端口。

原理流程

  1. 容器启动并映射端口。
  2. 读取宿主地址与映射端口。
  3. 构造 JDBC/客户端连接串。
  4. 多容器通过共享网络别名互访。

代码或图示

val url = pg.jdbcUrl
val user = pg.username
val password = pg.password

常见误区

  • 假设固定宿主端口:容器映射随机端口,必须从容器对象读取。
  • 多容器用 localhost 互访:应走共享网络别名。

追问

  • 容器内部端口需要暴露吗?答:按镜像配置暴露;跨容器访问用内部端口与别名。
  • 连接串含凭证如何处理?答:测试本地占位凭证不属生产密钥;生产凭证按环境配置管理。

04.8.3.3-052 数据库迁移在集成测试中如何执行?

一句话结论

集成测试启动容器后先执行迁移(schema 建表、初始数据),再跑 DAO/业务用例;迁移脚本在干净库上反复执行,验证版本演进与回滚脚本。

概念解释

容器初始为空库,测试前置步骤运行迁移工具应用全部变更。这样验证 SQL 脚本在真实库上可执行、表结构与实体映射一致。测试间重建库保证迁移从头可跑。

原理流程

  1. 启动空数据库容器。
  2. 运行迁移工具应用 schema 版本。
  3. 执行集成测试断言持久化行为。
  4. 下一轮重建库重新迁移。

代码或图示

空容器 → 迁移建表 → 测试数据 → DAO 断言 → 销毁

常见误区

  • 测试手动建表跳过迁移:脚本问题未被验证。
  • 迁移与实体模型漂移:测试用旧 schema 跑新代码。

追问

  • 迁移工具选什么?答:按工程现有 Flyway/Liquibase 等方案;本节不展开工具细节。
  • 迁移失败如何定位?答:在容器库上重放迁移脚本,核对方言与约束。

04.8.3.3-053 容器测试慢有哪些优化手段?

一句话结论

优化方向:容器复用、按层分离轻量单元测试、并行分组、预热镜像、只启动必要服务;避免每个用例拉起全套依赖。

概念解释

容器耗时在镜像拉取、启动就绪与初始化。单元层用替身消化大部分用例,集成层只保留必要容器场景。复用与并行需平衡隔离性。镜像在 CI 节点预热减少拉取时间。

原理流程

  1. 统计容器测试启动与执行耗时。
  2. 提升单元测试占比,减少容器用例。
  3. 复用/并行优化容器生命周期。
  4. 预热镜像与依赖基础层。

代码或图示

优化:分层测试 → 复用容器 → 并行分组 → 镜像预热

常见误区

  • 为提速把集成断言下放到 mock:丢失真实依赖验证。
  • 全局复用容器不清理:隔离风险换速度不可取。

追问

  • 镜像拉取慢怎么办?答:CI 节点预拉基础镜像,私有镜像仓库缓存。
  • 容器健康检查过长?答:优化镜像启动脚本,按实际就绪条件等待。

04.8.3.3-054 CI 环境对 Docker 有什么要求?

一句话结论

执行 Testcontainers 的 CI 节点需可用 Docker 守护进程并具备容器镜像拉取权限;云流水线按平台选择 Docker-in-Docker 或挂载守护进程方案。

概念解释

容器测试依赖 Docker 运行时。CI 环境需配置权限、网络拉取镜像与存储空间。无 Docker 能力的节点不能跑容器测试,应路由到支持的执行环境。

原理流程

  1. 检测 CI 节点 Docker 可用性。
  2. 配置镜像仓库凭证与网络。
  3. 容器测试在支持节点执行。
  4. 失败时检查守护进程日志与镜像拉取。

代码或图示

CI 节点:Docker 守护进程 + 镜像拉取权限 + 磁盘空间

常见误区

  • 本地能跑就假设 CI 可跑:CI 守护进程权限/网络常缺失。
  • 容器测试与无 Docker 阶段混跑:阶段划分不清导致环境失败。

追问

  • 无 Docker 的 CI 如何跑数据库测试?答:使用服务容器(平台原生服务)替代,或迁移到支持 Docker 的执行节点。
  • 镜像拉取失败如何排查?答:检查仓库凭证、网络与镜像标签存在性。

04.8.3.3-055 Testcontainers 与 H2 内存库如何取舍?

一句话结论

H2 仅在方言兼容、功能受限时作为轻量替代;涉及 PostgreSQL/MySQL 特性、约束、JSON 类型或迁移脚本时必须用 Testcontainers 真实引擎。

概念解释

H2 启动快但方言与真实库有差异,容易出现本地通过生产失败。取舍标准是被测 SQL 是否依赖真实库特性。后端工程推荐容器库覆盖持久层,H2 只用于不碰 SQL 方言的纯规则测试。

原理流程

  1. 判断测试是否触及 SQL/方言/约束。
  2. 不触及:内存 fake 或 H2 轻量跑。
  3. 触及真实特性:Testcontainers 真实库。
  4. 两套测试结果交叉核对。

代码或图示

纯业务规则:内存 fake
简单 CRUD 兼容验证:H2(受限)
真实方言/约束/迁移:容器库

常见误区

  • H2 通过即认为数据库层没问题:方言差异未覆盖。
  • 用 H2 跑特定数据库函数:函数不存在或行为不同。

追问

  • H2 兼容模式能模拟 PostgreSQL 吗?答:部分兼容,仍不等同真实引擎;关键路径用容器验证。
  • 如何记录某测试用了哪种库?答:标签/源码集区分,报告中可见。

04.8.3.3-056 JaCoCo 如何接入 Kotlin 工程?

一句话结论

通过 JaCoCo Gradle 插件在测试执行时挂接字节码探针,采集覆盖率数据;Kotlin 编译产物为 class 文件,探针作用于字节码,接入方式与 Java 工程类似。

概念解释

JaCoCo 在 class 字节码插桩记录执行覆盖,测试运行后生成执行数据。Kotlin 语法(属性、默认参数、扩展函数)编译为字节码后被统计,覆盖率口径需结合 Kotlin 结构理解。

原理流程

  1. 应用 JaCoCo 插件。
  2. 测试任务附带探针与执行数据输出。
  3. 测试运行记录已执行字节码行/分支。
  4. 生成报告或聚合数据。

代码或图示

plugins {
    jacoco
}
// 测试任务配置执行数据与报告(具体 DSL 以 Gradle/JaCoCo 版本为准)

常见误区

  • 以为覆盖率统计 Kotlin 源码行直接对应:字节码结构与源码行映射需核对报告。
  • 测试任务未挂接探针:执行数据为空。

追问

  • JaCoCo 与 K2 编译兼容吗?答:字节码探针作用于 class;若遇兼容问题以 JaCoCo 发布说明为准,标待确认。
  • 覆盖率数据文件在哪?答:构建目录下 JaCoCo 输出,路径按插件约定。

04.8.3.3-057 覆盖率报告有哪些格式?

一句话结论

常见 HTML 人读报告、XML 供 CI 门禁与工具解析、CSV 表格汇总;按用途选择格式,CI 用 XML 解析阈值,本地调试用 HTML 浏览未覆盖行。

概念解释

HTML 按包/类展示红绿覆盖;XML 含行/分支计数供门禁比对;CSV 便于表格分析。多模块时先出各模块执行数据,再聚合生成总报告。

原理流程

  1. 测试执行产出 exec 数据。
  2. 报告任务结合 class 与源码生成各格式。
  3. CI 解析 XML 计数。
  4. HTML 供本地查看定位未覆盖代码。

代码或图示

exec 执行数据 ──▶ HTML(浏览)/ XML(门禁)/ CSV(汇总)

常见误区

  • 只看总覆盖率数字:未覆盖类与分支在报告明细中定位。
  • 报告不含源码映射:行号无法对应,需保留编译源码信息。

追问

  • 报告生成需要源码吗?答:HTML 展示源码行需关联源文件;XML 计数可基于 class 与 exec。
  • 多格式能否一次生成?答:报告任务配置多输出格式,具体以插件 DSL 为准。

04.8.3.3-058 覆盖率门禁阈值如何设置?

一句话结论

按模块成熟度设定行/分支覆盖率阈值,CI 解析报告比对,低于阈值阻断合并;阈值应渐进提升,避免一次性设高值导致门禁失效或形式化补测试。

概念解释

门禁防止覆盖率倒退,而非追求 100%。核心业务模块阈值高于工具/配置模块。阈值规则区分新增代码与整体代码的能力以工具版本为准;存量低覆盖模块先记录基线再提升。

原理流程

  1. 统计各模块当前覆盖率基线。
  2. 按重要性设定阈值。
  3. CI 解析 XML 比对阈值。
  4. 未达标阻断并报告缺口。

代码或图示

核心域:分支覆盖率阈值较高
外围工具:较低或仅防倒退
CI:XML 计数 < 阈值 → 失败

常见误区

  • 阈值设 100% 逼出无意义测试:覆盖率数字虚高,测试价值下降。
  • 门禁只看行覆盖:未覆盖分支逃逸。

追问

  • 覆盖率倒退如何度量?答:与基线/上次报告对比,新增未覆盖代码纳入门禁。
  • 阈值配置在哪个任务?答:JaCoCo 报告/校验任务中声明规则,具体 DSL 以版本为准。

04.8.3.3-059 覆盖率统计如何排除生成代码?

一句话结论

编译器生成的序列化器、DAO 实现、代理类不应计入业务覆盖率;在 JaCoCo 配置中按包名/类模式排除生成目录与生成类。

概念解释

生成代码由编译期框架产出,不是手写业务逻辑,统计它会稀释或虚增覆盖率。排除规则按生成类包名后缀或源码目录匹配。排除后覆盖率反映手写代码测试程度。

原理流程

  1. 识别生成类包名/目录模式。
  2. 在覆盖率配置中声明排除规则。
  3. 报告与门禁只统计手写代码。
  4. 新增生成框架时同步更新排除规则。

代码或图示

排除:*.gen.*、*Impl(生成实现)、序列化器类
保留:业务域模型与服务类

常见误区

  • 排除规则过宽删掉真实业务类:核对排除模式匹配范围。
  • 生成代码进覆盖率拉低指标:误以为业务测试不足。

追问

  • 生成类自身要测试吗?答:由框架保证;业务调用侧测试覆盖交互即可。
  • 排除规则写在哪里?答:JaCoCo 插件配置的类排除项,语法以插件版本为准。

04.8.3.3-060 行覆盖与分支覆盖有什么区别?

一句话结论

行覆盖衡量执行到哪些源码行,分支覆盖衡量 if/else、when、短路逻辑等分支是否都走通;行覆盖高不代表分支覆盖完整。

概念解释

一行代码可能含多个分支(条件短路、when 分支),行执行过不等于每个分支都覆盖。关键业务判断应看分支覆盖率。报告中两类计数分别统计。

原理流程

  1. 探针记录执行到的字节码行。
  2. 记录各分支跳转是否经过。
  3. 报告分别计算行/分支比例。
  4. 门禁按两类指标分别设阈值。

代码或图示

if (a && b) { ... } // 短路产生多个分支组合

常见误区

  • 只盯行覆盖率:条件分支遗漏未被发现。
  • 默认参数/合成方法分支被统计:结合 Kotlin 字节码结构解读。

追问

  • Kotlin when 覆盖算分支吗?答:各分支跳转纳入分支统计,未覆盖分支在报告中标注。
  • 异常分支如何覆盖?答:测试错误路径断言抛异常/失败结果。

04.8.3.3-061 多模块覆盖率如何聚合?

一句话结论

各模块测试产出执行数据,聚合任务合并 class 与 exec 数据生成跨模块总报告;门禁可分别按模块或按聚合结果校验。

概念解释

单模块报告只看本模块类;跨模块调用的覆盖需要聚合所有 exec 数据。聚合任务依赖各模块测试执行完成。报告层级:模块明细 + 工程总览。

原理流程

  1. 各模块测试产出 exec 文件。
  2. 聚合任务收集全部 class 与 exec。
  3. 合并生成总报告。
  4. 门禁按模块或聚合阈值校验。

代码或图示

module A.exec + module B.exec ──▶ 聚合报告 ──▶ 总覆盖率

常见误区

  • 聚合前未跑全量测试:部分模块数据缺失,总覆盖失真。
  • 只看聚合平均值:低覆盖模块被平均掩盖。

追问

  • 跨模块调用覆盖如何归属?答:覆盖记录在被调用类所在模块;聚合报告合并展示。
  • 聚合报告生成任务依赖什么?答:依赖各模块测试任务完成,任务图顺序配置正确。

04.8.3.3-062 覆盖率工具与 K2/编译器版本兼容需注意什么?

一句话结论

字节码探针作用于编译产物,原则上跟随 class 字节码工作;但新编译器前端、新语言特性的字节码结构变化可能影响探针插桩与行映射,升级时需核对工具兼容说明(待确认)。

概念解释

覆盖率工具依赖 class 结构与调试信息映射源码行。K2 重写前端后字节码生成细节可能调整。升级 Kotlin 大版本时同步验证覆盖率报告可用性与映射准确性。

原理流程

  1. 升级编译器后跑测试与报告生成。
  2. 检查 exec 数据与源码行映射。
  3. 核对工具发布说明兼容版本。
  4. 异常时锁定已知兼容组合。

代码或图示

待确认:JaCoCo 对 Kotlin 2.x/K2 字节码映射的兼容版本与已知限制

常见误区

  • 升级编译器后忽略覆盖率回归:探针报错或映射错位未发现。
  • 报告行号错位还据此补测试:先确认映射准确。

追问

  • 覆盖率工具版本需要随 Kotlin 升级吗?答:按工具兼容说明同步评估。
  • 探针报错如何排查?答:核对工具版本、字节码版本与已知 issue,必要时降级编译器或工具。

04.8.3.3-063 高覆盖率为什么不等于测试质量高?

一句话结论

覆盖率只衡量代码是否被执行,不衡量断言质量、边界覆盖与业务正确性;无断言的测试、重复走 happy path 也能拉高覆盖率。

概念解释

执行过代码 ≠ 验证了结果。测试质量看断言充分性、场景覆盖、边界与错误路径。高覆盖伴随弱断言可能掩盖缺陷。覆盖率是辅助指标,不是测试验收唯一标准。

原理流程

  1. 覆盖率统计执行到的代码。
  2. 断言是否检查结果不在统计范围。
  3. 评审测试看场景与断言强度。
  4. 结合代码评审与缺陷率评估质量。

代码或图示

覆盖率:代码被执行次数
质量:断言是否验证正确行为、边界是否覆盖

常见误区

  • 为提覆盖率写空断言测试:数字好看但无保护。
  • 只覆盖 happy path:错误分支与边界遗漏。

追问

  • 如何评估断言质量?答:评审用例场景、断言字段与错误路径覆盖;变异测试可辅助检验断言有效性。
  • 覆盖率目标定多少合理?答:按模块风险与基线渐进,不追求形式化满分。

04.8.3.3-064 detekt 的定位与规则配置是怎样的?

一句话结论

detekt 是 Kotlin 静态分析工具,内置代码风格、复杂度、坏味道、命名等规则集,通过 YAML 配置启用/禁用规则与阈值,在构建或 CI 中卡点。

概念解释

detekt 扫描源码不运行程序,发现潜在缺陷、复杂度超标与风格不一致。规则配置按类别调整严重级别与阈值;支持自定义规则与基线文件忽略存量问题。

原理流程

  1. 应用 detekt 插件并提供配置文件。
  2. 分析任务扫描 Kotlin 源码。
  3. 规则命中输出问题列表。
  4. CI 按严重级别决定是否阻断。

代码或图示

# detekt 配置示意(规则名以当前版本为准)
build:
  maxIssues: 0
style:
  MaxLineLength:
    active: true
    maxLineLength: 120

常见误区

  • 启用全部默认规则不调阈值:存量问题刷屏,团队抵触。
  • 规则配置与 ktlint 风格冲突:需协调两者规则集。

追问

  • detekt 能自动修复吗?答:部分规则支持格式化/修复,具体能力以版本为准。
  • 自定义规则怎么写?答:detekt 规则扩展机制,按官方文档实现规则类。

04.8.3.3-065 ktlint 的定位与格式化能力是什么?

一句话结论

ktlint 是 Kotlin 代码风格与格式化工具,基于规则检查排版、导入顺序等格式问题,可自动修复大部分格式;与 detekt 分工:ktlint 管格式,detekt 管复杂度与代码坏味道。

概念解释

ktlint 强调一致的代码风格(缩进、换行、导入排序),提供格式化命令自动修正。它不深度分析业务复杂度。团队配合 editorconfig 统一风格,提交前格式化。

原理流程

  1. 引入 ktlint 集成(Gradle 插件或独立 CLI)。
  2. 检查源码格式违规。
  3. 格式化命令自动修复可修复项。
  4. 不可自动修复项提交前人工处理。

代码或图示

ktlint:格式、排版、导入顺序(可自动修复)
detekt:复杂度、坏味道、潜在缺陷(多为人工修复)

常见误区

  • detekt 与 ktlint 规则重复且互相矛盾:对齐风格规则,避免同一问题两套报错。
  • 提交前不跑格式化:CI 格式卡点阻断合并。

追问

  • ktlint 与 editorconfig 关系?答:格式规则可由 editorconfig 约束,两者配合。
  • 格式化工具版本如何固定?答:构建依赖锁定版本,保证团队与 CI 结果一致。

04.8.3.3-066 detekt 与 ktlint 如何分工?

一句话结论

ktlint 负责机械格式(空格、换行、导入、行宽),detekt 负责结构与质量(复杂度、命名、坏味道、潜在 bug);两者互补,规则边界需在团队规范中明确。

概念解释

格式问题可自动修复,结构问题需人工判断。工具重叠部分(如行宽、命名)应只保留一处生效,避免重复告警。CI 中两者分别作为检查阶段。

原理流程

  1. ktlint 先做格式检查与修复。
  2. detekt 做静态质量分析。
  3. 重叠规则对齐配置。
  4. 报告分别汇总问题。

代码或图示

格式层:ktlint
质量层:detekt
重叠规则:单一来源配置

常见误区

  • 同一问题两边各报一次:噪音放大,评审困惑。
  • 用 detekt 规则追求格式化效果:格式交给 ktlint 更合适。

追问

  • 能否只用一个工具?答:小团队可简化;中大型项目通常两者配合。
  • 规则冲突以谁为准?答:团队规范明确格式归 ktlint,结构归 detekt。

04.8.3.3-067 静态分析在 CI 中如何卡点?

一句话结论

静态分析任务作为独立阶段在测试前/合并门禁中执行,问题超阈值或存在严重级别告警即阻断;本地提交前先跑同一套检查保证反馈前置。

概念解释

CI 卡点防止不合规代码入库。分析任务与测试任务分开,格式/质量问题快速反馈。基线文件允许存量问题暂存,新增问题必须清零。

原理流程

  1. 流水线执行 detekt/ktlint 检查任务。
  2. 汇总告警数量与级别。
  3. 超阈值或严重问题失败。
  4. 报告链接供开发者修复。

代码或图示

CI:构建 → 静态分析卡点 → 测试 → 覆盖率门禁

常见误区

  • 分析任务长期失败被忽略:门禁形同虚设。
  • 本地不跑分析直接推 CI:反馈链路变长。

追问

  • 存量问题如何过渡?答:基线文件记录既有告警,新增问题卡点,逐步清零。
  • 分析任务太慢怎么办?答:增量分析、缓存结果,按模块拆分任务。

04.8.3.3-068 抑制静态分析告警有什么规范?

一句话结论

抑制必须标注原因与适用范围,优先修复规则问题;@Suppress 类注解写明理由,禁止批量全局关闭规则。

概念解释

个别场景规则不适用(生成代码、特殊算法),局部抑制优于全局关规则。抑制注解附带说明,评审可判断合理性。定期复盘抑制清单,随代码演进清理。

原理流程

  1. 评估告警是否真的不适用。
  2. 局部抑制并写明原因。
  3. 评审检查抑制理由。
  4. 定期清理过时抑制。

代码或图示

@Suppress("Detekt.LongMethod") // 说明:数据映射顺序固定,拆分损失可读性
fun map(...) { /* ... */ }

常见误区

  • 整文件/全局 Suppress 掩盖问题:规则失效范围过大。
  • 抑制不写原因:后续无人判断是否仍需保留。

追问

  • 生成代码目录如何豁免?答:在分析配置中排除生成目录,而非逐类抑制。
  • 抑制清单在哪查看?答:规则报告与配置文件,纳入定期评审。

04.8.3.3-069 Dokka 文档生成是做什么的?

一句话结论

Dokka 是 Kotlin 文档生成工具,从源码注释与 API 结构生成文档站点,支持 KDoc 注释解析;用于对外/对内 API 文档,不替代 README 与设计文档。

概念解释

Dokka 提取公开声明签名与 KDoc 注释,渲染为 HTML 等格式。它理解 Kotlin 语法(可空性、类型参数),区别于 Javadoc 工具。文档生成可接入构建任务,随构建产出。

原理流程

  1. 源码含 KDoc 注释。
  2. Dokka 任务解析公开 API 与注释。
  3. 渲染输出文档格式。
  4. 发布到文档站点或归档。

代码或图示

/**
 * 下单服务。
 * @param repo 订单仓储
 */
class OrderService(repo: OrderRepository)

常见误区

  • 把内部实现细节写进公开 KDoc:文档暴露不必要内部 API。
  • 以为 Dokka 生成使用教程:它产出 API 参考,教程另写。

追问

  • Dokka 与 Javadoc 能互通吗?答:Dokka 有 Javadoc 输出格式选项;Kotlin 主源用 KDoc。
  • 私有成员进文档吗?答:按可见性配置过滤,公开 API 默认纳入。

04.8.3.3-070 Dokka 支持哪些输出格式?

一句话结论

Dokka 支持 HTML 站点、Javadoc 兼容格式、Markdown 等输出(具体格式列表以当前版本为准);后端库对外发布时常出 HTML 或 Javadoc 格式供消费方查阅。

概念解释

不同消费场景选格式:HTML 浏览导航,Javadoc 兼容传统工具链,Markdown 嵌入其他文档。格式配置在 Dokka 插件/任务中声明。多平台工程可按目标生成对应文档。

原理流程

  1. 配置 Dokka 任务输出格式。
  2. 解析源码 API 与注释。
  3. 按格式渲染输出目录。
  4. 归档或发布文档产物。

代码或图示

HTML:站点浏览
Javadoc:兼容传统 Java 工具链
Markdown:嵌入文档站点(格式支持以版本为准)

常见误区

  • 文档产物纳入版本管理:生成物应重新构建生成。
  • 注释缺失仍要求完整文档:Dokka 只呈现已有注释。

追问

  • 文档任务纳入 CI 吗?答:可作为发布前置任务检查注释缺失;日常构建不必每次生成。
  • 跨 Kotlin/Java 混合文档如何处理?答:Dokka 对混合源码的解析能力按版本文档核对。

04.8.3.3-071 静态分析规则自定义与基线文件怎么用?

一句话结论

团队可按规范新增自定义规则或调整阈值;基线文件记录存量问题位置,使 CI 只对新增问题卡点,避免历史问题阻断迁移。

概念解释

基线(baseline)导入现有告警清单,后续分析比对基线忽略已登记问题。新问题不在基线中即暴露。自定义规则针对团队特定坏味道。基线需随代码清理逐步缩减。

原理流程

  1. 首次生成存量问题基线。
  2. 分析任务比对基线与当前告警。
  3. 新增问题报错,基线内问题暂存。
  4. 修复后从基线移除对应条目。

代码或图示

基线文件:既有告警清单
CI:当前告警 − 基线 = 新增问题 → 卡点

常见误区

  • 基线长期只增不减:技术债累积,失去过渡意义。
  • 自定义规则脱离团队规范:规则维护成本高,先复用内置规则。

追问

  • 基线文件纳入版本管理吗?答:纳入,随代码演进更新;生成方式以工具文档为准。
  • 规则级别如何调整?答:配置文件中按规则设 severity,全局调低需评审。

04.8.3.3-072 分析工具在增量构建中如何缓存?

一句话结论

静态分析任务可利用增量与缓存:源码未变时复用上次分析结果,变更文件触发重新分析;缓存键基于源码与规则配置,规则变更使缓存失效。

概念解释

全量分析大工程耗时明显。增量分析按变更文件缩小范围,构建缓存复用历史报告。规则配置、自定义规则类版本属于缓存输入。分析缓存与编译缓存独立。

原理流程

  1. 记录上次分析的文件与结果。
  2. 检测源码与规则配置变更。
  3. 只分析受影响文件。
  4. 未变更任务 UP_TO_DATE 或命中缓存。

代码或图示

源码变更 → 增量分析受影响文件
规则配置变更 → 分析缓存失效

常见误区

  • 规则升级后不失效缓存:旧规则结果残留。
  • 分析任务读取未纳入输入的配置:缓存误命中。

追问

  • 分析缓存与编译缓存是一回事吗?答:独立任务各自判定,产物类型不同。
  • 增量分析漏报怎么办?答:定期全量分析复核,核对增量隔离声明。

04.8.3.3-073 editorconfig 如何统一代码风格?

一句话结论

.editorconfig 定义缩进、换行、字符集、行尾等基础格式约定,IDE 与 ktlint/格式化工具共同遵循,保证跨编辑器与平台风格一致。

概念解释

editorconfig 是跨工具的基础格式配置,不包含复杂质量规则。项目级约定与工具规则对齐:缩进宽度、换行符、编码。Windows/macOS 协作时换行符约定尤其重要。

原理流程

  1. 项目根放置 editorconfig 声明规则。
  2. IDE 打开文件时按配置格式化。
  3. ktlint/分析工具读取同一约定。
  4. 提交代码风格一致。

代码或图示

root = true

[*.kt]
charset = utf-8
indent_style = space
indent_size = 4

常见误区

  • editorconfig 与 ktlint 规则冲突:格式化结果不一致,需对齐。
  • 遗漏换行符/编码约定:跨平台协作出现整文件 diff。

追问

  • editorconfig 与项目 .gitattributes 关系?答:前者约束编辑器格式,后者约束 Git 换行符归一化,两者配合。
  • 配置文件缩进也要统一吗?答:按文件类型分别声明,YAML/Markdown 各有约定。

04.8.3.3-074 契约测试的定位是什么?

一句话结论

契约测试验证服务提供方与消费方之间的消息格式、字段语义与错误约定,确保双方遵守同一契约;它不替代业务行为测试,而是保护接口兼容性。

概念解释

契约固定请求/响应结构、必填字段、错误码与命名。提供方验证不破坏契约,消费方按契约 mock 提供方。常见形式:消费者驱动契约或 schema 校验。后端内部服务间与对外 API 都适用。

原理流程

  1. 定义接口契约(schema/样例/错误约定)。
  2. 提供方测试验证产出符合契约。
  3. 消费方测试按契约 stub 提供方。
  4. 契约变更双方同步验证。

代码或图示

契约:请求字段 / 响应结构 / 错误码
提供方测试:产出符合契约
消费方测试:按契约替身联调

常见误区

  • 契约测试只校验字段存在不校验语义:类型/取值范围遗漏。
  • 契约与文档脱节:字段变更未同步契约定义。

追问

  • 契约测试属于单元还是集成层?答:可按框架落在消费方/提供方两侧,独立于完整 e2e。
  • 契约由谁维护?答:接口双方评审确认,随 API 演进更新。

04.8.3.3-075 API 层测试如何组织?

一句话结论

API 层测试围绕路由/Handler 组织:启动测试服务或直接调用处理器,覆盖成功响应、参数校验、错误状态码与序列化格式;业务规则委托下层测试覆盖。

概念解释

API 测试关注 HTTP 协议层:路径、方法、状态码、请求响应体、鉴权。下层服务用 fake/mock 隔离,验证 API 适配层正确转换输入输出。测试按资源/路由分组。

原理流程

  1. 启动测试服务或调用 Handler。
  2. 构造请求(头、参数、体)。
  3. 调用 API 断言状态码与响应体。
  4. 必要时验证下层交互。

代码或图示

@Test
fun `创建订单返回 201 与订单号`() = runTest {
    val response = client.post("/orders") { setBody(request) }
    response.status shouldBe HttpStatusCode.Created
}

常见误区

  • API 测试深入业务规则断言:职责下沉,测试脆弱重复。
  • 不校验响应体结构:只看状态码,字段错误漏网。

追问

  • 测试服务端口如何处理?答:测试随机端口或绑定测试环境,连接信息从测试配置读取。
  • API 测试需要真实数据库吗?答:按分层,API 层可用服务 fake;持久化由集成测试覆盖。

04.8.3.3-076 API 测试用真实 HTTP 客户端还是直接调用?

一句话结论

验证路由、序列化与协议行为用真实 HTTP 客户端打测试端口;只验证 Handler 逻辑可直接调用函数。前者覆盖网络与序列化链路,后者快但漏掉协议层问题。

概念解释

真实客户端经过路由匹配、序列化、状态码映射;直接调用跳过 HTTP 层。API 契约相关用例应走真实客户端,纯业务编排可直接调 Handler。分层组合两种方式。

原理流程

  1. 确认测试目标是否含协议链路。
  2. 含:启动测试服务 + 真实客户端。
  3. 不含:直接调用处理器函数。
  4. 断言对应层级结果。

代码或图示

真实客户端:路由 → 序列化 → 状态码
直接调用:Handler 入参 → 返回值

常见误区

  • 直接调用 Handler 就声称 API 已测:路由与序列化未覆盖。
  • 所有 API 用例都起真实服务:反馈变慢,可分层选择。

追问

  • 真实客户端测试注意什么?答:连接配置、清理测试数据、响应体解析断言。
  • 框架测试工具怎么选?答:按后端框架提供的测试客户端,见 06 分册。

04.8.3.3-077 Schema 与序列化往返如何校验?

一句话结论

构造领域对象序列化后再反序列化,断言往返一致;API 测试核对响应 JSON 字段与 schema 一致,防止序列化配置漂移。

概念解释

往返测试捕获字段名策略、可选性、默认值与类型映射问题。API 层核对对外字段名与契约 schema。序列化器生成代码在编译期产出,往返测试验证运行期编解码正确。

原理流程

  1. 准备领域对象样例。
  2. 编码为 JSON/结构。
  3. 解码回对象断言相等。
  4. 对照 schema 检查字段名与类型。

代码或图示

val dto = OrderDto(id = 1, status = "PAID")
val json = Json.encodeToString(dto)
val back = Json.decodeFromString<OrderDto>(json)
back shouldBe dto

常见误区

  • 只测序列化不测反序列化:解码失败未覆盖。
  • 字段重命名后不更新往返样例:兼容问题漏测。

追问

  • 缺失字段/默认值如何测?答:构造缺字段 JSON 解码,断言默认值行为。
  • 对外 schema 来源是什么?答:契约定义/ OpenAPI 类描述,往返测试与其对齐。

04.8.3.3-078 错误响应如何断言?

一句话结论

断言错误状态码、错误码字段、消息与结构符合契约;区分参数错误、业务失败与系统异常,不同错误分支分别覆盖。

概念解释

错误响应是 API 契约的一部分。测试不仅断言非 2xx,还要核对错误体字段与类型。业务错误经结果类型映射到响应,异常经全局错误处理转换。

原理流程

  1. 触发对应错误场景。
  2. 调用 API 取得错误响应。
  3. 断言状态码与错误体字段。
  4. 核对日志/交互是否符合预期。

代码或图示

val resp = client.post("/orders") { setBody(badRequest) }
resp.status shouldBe HttpStatusCode.BadRequest
resp.body<ErrorResponse>().code shouldBe "INVALID_QUANTITY"

常见误区

  • 错误用例只断言抛异常:API 层错误响应格式未验证。
  • 错误消息断言过细:文案调整导致脆弱测试,关键错误码稳定断言。

追问

  • 未捕获异常返回什么?答:全局错误处理映射的统一错误结构,测试覆盖该映射。
  • 错误码与领域错误类型如何对应?答:见 Arrow/结果类型专题,API 层做映射断言。

04.8.3.3-079 鉴权测试夹具如何准备?

一句话结论

测试中构造合法/非法凭证注入请求头,按角色与权限覆盖通过、拒绝、越权场景;鉴权依赖用测试夹具提供令牌,不依赖真实认证服务。

概念解释

鉴权逻辑包括身份解析、权限校验与拒绝响应。测试夹具生成测试令牌/用户身份,覆盖有权限、无权限、过期/伪造凭证。真实认证服务由集成/预发环境验证。

原理流程

  1. 夹具生成测试身份与凭证。
  2. 请求注入对应头/令牌。
  3. 调用 API 断言通过或拒绝。
  4. 越权场景核对拒绝响应。

代码或图示

夹具:合法用户令牌 / 普通用户令牌 / 伪造令牌
用例:放行 200 / 拒绝 401/403

常见误区

  • 鉴权测试绕过过滤器直接调 Handler:链路鉴权未覆盖。
  • 夹具令牌签名使用真实密钥:测试凭证不应依赖生产密钥。

追问

  • 多角色权限矩阵怎么测?答:参数化测试遍历角色 × 操作组合。
  • 令牌过期场景如何模拟?答:夹具构造过期/无效令牌,不连真实认证服务。

04.8.3.3-080 端到端与集成测试的边界在哪里?

一句话结论

集成测试验证模块间与真实依赖协作(容器数据库、消息队列);端到端通过完整应用链路从入口跑到出口,覆盖多服务协同;边界按参与组件数量划分。

概念解释

集成测试通常单服务内连接真实依赖;e2e 启动完整应用甚至多服务,模拟真实用户操作。e2e 慢而少,集成测试中等规模,单元测试最快最多。三层反馈速度递减、覆盖范围递增。

原理流程

  1. 单元:单个类 + 替身。
  2. 集成:模块协作 + 容器依赖。
  3. e2e:完整链路 + 多服务/真实入口。
  4. 缺陷按层定位。

代码或图示

单元(快、多)→ 集成(中)→ e2e(慢、少)

常见误区

  • 把集成测试当 e2e:未经过完整入口与部署形态。
  • e2e 覆盖所有业务分支:维护成本高,分支细节留给下层。

追问

  • e2e 用什么入口?答:HTTP/UI/CLI 按应用形态;后端服务走 API 入口。
  • 三层比例如何把握?答:测试金字塔,单元占多数,e2e 覆盖关键链路。

04.8.3.3-081 unit、integration、e2e 如何划分标准?

一句话结论

按被测组件与外部依赖划分:单元测试隔离单个逻辑单元用替身;集成测试连接真实模块/中间件;e2e 运行完整应用链路;划分依据是真实依赖数量与覆盖范围。

概念解释

没有唯一硬性界限,团队按目录、标签与依赖类型约定。判断标准:是否启动真实容器/服务、是否跨模块、是否走完整入口。同一用例归属在团队规范中明确。

原理流程

  1. 列出用例涉及的组件与依赖。
  2. 全替身 → 单元。
  3. 真实中间件/多模块 → 集成。
  4. 完整链路 → e2e。

代码或图示

单元:被测类 + fake/mock
集成:DAO + 容器库;服务 + 真实模块
e2e:完整应用 + 关键业务链路

常见误区

  • 启动了容器却标单元测试:分层标签错误,CI 选择用例出错。
  • 划分只看测试框架:框架不决定层级,依赖形态决定。

追问

  • 测试数据库仓库算哪层?答:连接真实库属集成;内存 fake 仓储属单元。
  • 跨服务调用测试算哪层?答:完整跨服务链路属 e2e;单服务契约 stub 属集成/契约。

04.8.3.3-082 测试源码集如何组织?

一句话结论

默认 src/test 放单元测试;重型集成/e2e 可单独 sourceSet 或目录 + 标签隔离,配置独立依赖与执行任务,避免单元阶段加载重型环境。

概念解释

源码集决定编译 classpath 与执行任务。简单工程单 test 源集 + 标签分组即可;复杂工程拆分集成测试源集,单独任务在 CI 后续阶段运行。目录结构对齐主源码包。

原理流程

  1. 单元测试放入默认 test 源集。
  2. 重型测试按约定目录/标签或独立源集。
  3. 构建任务按源集/标签选择执行。
  4. 依赖按源集声明。

代码或图示

src/test/kotlin:单元测试
src/integrationTest/kotlin:集成测试(源集配置按工程)

常见误区

  • 集成测试混在单元源集:单元阶段拉起容器,反馈慢。
  • 独立源集依赖未配齐:编译 classpath 缺测试库。

追问

  • 多模块测试源码如何共享夹具?答:测试 fixture 模块或公共测试源集,按工程结构组织。
  • 源集拆分需要改构建脚本吗?答:需要配置 sourceSet 与任务,由主控维护的构建配置统一处理。

04.8.3.3-083 为什么单元测试要优先保证快速反馈?

一句话结论

单元测试快、隔离、定位准,是开发阶段主要反馈环;上层测试慢且环境依赖,只用于补充覆盖。快速反馈鼓励频繁运行测试,缺陷在编码早期暴露。

概念解释

测试金字塔底层单元测试数量最多、执行最快。开发者提交前跑单元集,CI 再跑集成与 e2e。若单元层薄弱,问题只能在慢测试中发现,修复成本上升。

原理流程

  1. 编码阶段频繁跑单元测试。
  2. 单元失败快速定位到类。
  3. 提交后 CI 跑集成/e2e 补充验证。
  4. 缺陷分层暴露与修复。

代码或图示

开发环:单元测试(秒级)
CI:集成 → e2e(分钟级)

常见误区

  • 业务逻辑全靠 e2e 验证:反馈慢、定位难。
  • 单元测试仍连真实依赖:失去快速隔离优势。

追问

  • 单元测试多快算合格?答:整套单元集秒级到分钟级,按工程规模评估;慢用例下沉集成层。
  • 如何识别伪单元测试?答:检查是否连真实数据库/网络/容器。

04.8.3.3-084 CI 流水线中的测试阶段如何安排?

一句话结论

按反馈速度分层执行:静态分析 → 单元测试 → 集成测试 → e2e/覆盖率门禁;前置阶段失败尽早终止,避免在慢阶段浪费资源。

概念解释

流水线阶段对应测试分层。每次提交先跑快检查,合并前跑完整集成与 e2e。覆盖率与质量门禁卡在对应阶段。阶段依赖产物清晰,失败可定位到层。

原理流程

  1. 代码检出与构建编译。
  2. 静态分析卡点。
  3. 单元测试快速反馈。
  4. 集成测试 + 容器环境。
  5. e2e 与覆盖率门禁。

代码或图示

build → lint/detekt/ktlint → unit test → integration test → e2e + coverage gate

常见误区

  • 所有测试一次性并行跑:环境资源竞争,失败难定位。
  • 集成测试在静态检查前执行:慢问题先于格式问题暴露。

追问

  • 哪些阶段可并行?答:无依赖的检查任务并行;有环境依赖的按顺序。
  • 门禁失败如何通知?答:报告附失败用例与日志链接,归入提交评审。

04.8.3.3-085 测试并行执行如何保证隔离?

一句话结论

并行测试各自使用独立实例、数据与容器/ schema,共享可变状态是并行失败主因;并行度受环境资源限制,按机器容量配置。

概念解释

并行加速测试执行,但用例间不能共享仓储数据、端口、文件。测试类实例隔离由框架保证;数据隔离靠夹具与清理。容器/数据库按并行组分隔命名空间。

原理流程

  1. 配置并行度与执行策略。
  2. 各用例独立构造夹具与数据。
  3. 共享依赖按组隔离。
  4. 用例结束清理各自数据。

代码或图示

并行 worker A:独立数据/容器
并行 worker B:独立数据/容器

常见误区

  • 静态可变缓存跨用例共享:并行下读写交错。
  • 并行度超过机器资源:容器/内存不足导致超时失败。

追问

  • 测试顺序依赖如何发现?答:单线程随机顺序执行仍通过、并行才失败,多为共享状态问题。
  • 端口冲突怎么避免?答:测试端口随机分配,从容器/测试配置读取。

04.8.3.3-086 测试报告与失败留存如何处理?

一句话结论

CI 产出结构化测试报告(用例、耗时、失败堆栈),失败时留存日志与必要产物;报告可被门禁解析,失败用例链接供开发者复查。

概念解释

报告聚合通过/失败/跳过与耗时分布。失败堆栈定位断言点;产物(容器日志、截图、数据快照)辅助复现。报告随构建归档,定期清理历史留存。

原理流程

  1. 测试引擎输出结果文件。
  2. CI 解析汇总报告。
  3. 失败用例归档日志与产物。
  4. 报告链接进入评审通知。

代码或图示

测试结果 ──▶ 结构化报告(通过/失败/耗时)
失败 ──▶ 堆栈 + 日志 + 产物留存

常见误区

  • 失败日志只保留摘要:堆栈与上下文不足,无法本地复现。
  • 报告不区分测试层:失败定位到错误阶段困难。

追问

  • 慢用例如何从报告识别?答:按耗时排序报告,优化 Top 慢用例。
  • 报告产物存多久?答:按团队留存策略,保留近期失败构建即可。

04.8.3.3-087 忽略测试(@Disabled)有什么规范?

一句话结论

忽略测试必须记录原因与恢复条件,纳入待办跟踪;禁止长期忽略失败用例而不处理,忽略清单定期评审。

概念解释

临时跳过用于阻塞外部依赖、已知缺陷修复中。被忽略用例不出现在通过计数中,但应可见于报告。无说明的忽略等于删除保护,评审必须拦截。

原理流程

  1. 用例标注忽略并写明原因/关联事项。
  2. 报告列出忽略用例。
  3. 定期评审忽略清单。
  4. 阻塞解除后恢复用例。

代码或图示

@Disabled("等待第三方沙箱恢复,关联事项 #123")
@Test
fun `第三方回调联调`() { /* ... */ }

常见误区

  • 失败后直接忽略绕过 CI:问题被掩盖。
  • 忽略注解不带原因:后续无人知晓为何跳过。

追问

  • 忽略用例计入覆盖率吗?答:不执行自然不计覆盖;门禁应关注忽略数量。
  • 过时忽略如何清理?答:评审时验证阻塞是否解除,恢复或删除用例。

04.8.3.3-088 测试数据清理策略如何制定?

一句话结论

按隔离级别选择:每用例新建实例/事务回滚、共享数据在用例间重置、容器库按组清理;清理策略保证用例间无数据残留。

概念解释

数据残留是顺序依赖与并行失败根源。单元测试靠新建对象;集成测试靠事务回滚、 truncate 或重建 schema;e2e 用独立数据集。清理动作在用例后钩子执行并验证。

原理流程

  1. 确定测试隔离级别。
  2. 选择清理机制:新建/回滚/清理表/重建容器。
  3. 用例后执行清理。
  4. 下一用例从干净状态开始。

代码或图示

单元:新建对象
集成:事务回滚 / 表清理
e2e:独立数据集 / 环境重置

常见误区

  • 清理依赖用例正常结束:异常退出时残留,需钩子保证清理执行。
  • 共享数据库不清表:用例顺序影响结果。

追问

  • 事务回滚适用哪些场景?答:单服务数据库写入测试;跨服务消息/外部调用不适用回滚。
  • 如何验证清理生效?答:检查用例后表行数/状态,并行跑无残留。

04.8.3.3-089 测试环境配置如何与生产分离?

一句话结论

测试使用独立配置源与占位凭证,不读生产环境配置;数据库、网关地址指向测试/容器替身,敏感信息不硬编码在测试代码。

概念解释

配置按环境分层:默认值、测试覆盖、生产环境变量。测试夹具提供测试值,生产配置由部署环境注入。测试代码不包含真实密钥与线上地址。

原理流程

  1. 应用配置支持环境覆盖。
  2. 测试源集提供测试配置。
  3. 容器/替身地址注入测试配置。
  4. 生产配置由环境变量/配置中心提供。

代码或图示

测试配置:容器连接串、替身开关
生产配置:环境变量/配置中心,不进测试代码

常见误区

  • 测试代码写死本地开发库地址:他人/CI 环境不可用。
  • 复用生产配置文件跑测试:误连线上数据风险。

追问

  • 测试需要真实凭证吗?答:替身/容器用占位凭证;第三方沙箱凭证按安全规则从环境读取。
  • 配置覆盖优先级如何设计?答:测试配置高于默认值,生产环境变量高于测试,避免串环境。

04.8.3.3-090 flaky 测试如何治理?

一句话结论

先隔离复现(固定种子/串行/重复执行),定位时序、共享状态、外部依赖根因,修复后加防回归约束;标记临时 quarantine 并跟踪清零,不长期容忍偶发失败。

概念解释

flaky 是同一份代码时而通过时而失败。常见根因:时序假设、共享可变状态、外部依赖不稳定、资源泄漏。治理流程:复现 → 定位 → 修复 → 防回归。临时隔离用例不删除保护。

原理流程

  1. 重复执行/调大并发复现失败。
  2. 区分时序、状态、外部依赖根因。
  3. 修复同步/替身/清理问题。
  4. 加入回归用例,监控偶发失败率。

代码或图示

复现 → 定位根因(时序/状态/外部)→ 修复 → 回归约束

常见误区

  • 重跑一次通过就关闭问题:根因未除,再次偶发。
  • flaky 用例长期 quarantine:测试保护能力逐步丧失。

追问

  • 如何统计 flaky 率?答:报告标记非确定性失败用例,按构建记录重复出现情况。
  • 外部依赖导致的 flaky 怎么办?答:隔离为替身/容器,稳定后再纳入常规集。

04.8.3.3-091 一个后端服务的测试金字塔如何落地?

一句话结论

底层大量单元测试覆盖业务规则与工具类,中层集成测试覆盖持久化与模块协作,顶层少量 e2e 覆盖关键链路;按层选择替身与环境,反馈速度与覆盖范围平衡。

概念解释

落地时先梳理业务域核心规则补单元测试,再为仓储/外部对接补集成测试,最后挑主流程做 e2e。每层职责清晰:单元验规则,集成验协作,e2e 验完整链路。

原理流程

  1. 核心业务类配单元测试 + fake。
  2. 持久化/消息对接配容器集成测试。
  3. 关键下单/查询流程配 e2e。
  4. 按缺陷分布补充薄弱层。

代码或图示

顶层:少量 e2e 关键链路
中层:集成测试(容器依赖)
底层:大量单元测试(fake/mock)

常见误区

  • 金字塔倒过来:e2e 臃肿、单元薄弱,反馈慢定位难。
  • 各层重复测同一规则:规则只在单元层断言,上层验协作。

追问

  • 新功能先写哪层测试?答:先单元覆盖规则,再接集成与 e2e 链路。
  • 团队如何监控金字塔健康度?答:统计各层用例数与耗时,识别层间失衡。

04.8.3.3-092 业务规则测试应该放在哪一层?

一句话结论

纯业务规则(状态流转、校验、计算)放单元测试,用替身隔离依赖;持久化规则在集成测试补充;e2e 只验证规则在链路中被触发。

概念解释

业务规则是测试价值最高的部分,应在快、隔离的单元层充分覆盖。依赖真实存储/消息的规则交互在集成层验证。同一规则不在多层重复断言细节。

原理流程

  1. 抽取纯规则逻辑到可单测的类/函数。
  2. 单元测试覆盖合法/边界/错误分支。
  3. 集成测试验证规则落地到真实依赖。
  4. e2e 验证链路触发该规则。

代码或图示

规则校验/计算:单元层
约束落库/消息发送:集成层
主流程触发:e2e

常见误区

  • 业务规则埋在 API/DB 层,只能 e2e 覆盖:应重构提取可单测的领域逻辑。
  • 单元测试 mock 掉规则本身:断言空转。

追问

  • 规则涉及外部决策怎么办?答:决策接口注入替身,单元测编排;真实决策由集成验证。
  • 复杂状态机如何测?答:单元层遍历状态转移用例,参数化覆盖迁移路径。

04.8.3.3-093 测试可读性为什么优先于复用?

一句话结论

测试代码首要职责是清晰描述场景与预期,过度抽象复用会掩盖用例意图;少量样板优于难以阅读的通用测试框架,复用通过数据工厂等轻量方式实现。

概念解释

测试读得多写得少。通用基类、反射拼装夹具会让单个用例的输入与预期不直观。复用应聚焦数据构造,用例步骤保持直白。评审先读测试能否理解业务场景。

原理流程

  1. 用例按场景直白编排步骤与断言。
  2. 重复数据构造抽工厂。
  3. 重复断言抽小工具,不隐去业务语义。
  4. 评审检查用例可读性。

代码或图示

优先:步骤显式、断言清晰
适度:数据工厂、通用 matcher
避免:深层基类钩子隐藏用例逻辑

常见误区

  • 为消除三行重复引入复杂测试框架:用例可读性下降。
  • 通用测试方法参数过多:场景意图需翻参数表才懂。

追问

  • 测试代码要不要追求 DRY?答:适度复用数据与工具,场景步骤允许重复以保可读。
  • 基类放什么内容?答:通用夹具构造与清理,不放业务断言逻辑。

04.8.3.3-094 为什么一个测试只验证一个行为?

一句话结论

单用例聚焦一个行为场景,失败时定位明确;多个行为塞在一个用例中,前一断言失败会跳过后续检查,且测试名无法概括全部场景。

概念解释

"一个测试一个行为"指一个用例验证一个输入条件下的预期。多行为用例依赖执行顺序,失败原因混杂。拆分后各用例独立失败、独立命名,覆盖矩阵更清晰。

原理流程

  1. 识别用例中的多个断言场景。
  2. 按条件拆分为独立用例。
  3. 各自命名与夹具。
  4. 共享数据走工厂复用。

代码或图示

// 拆分前:一个用例测成功 + 失败 + 边界
// 拆分后:成功用例 / 拒绝用例 / 边界用例

常见误区

  • 一个用例遍历多个输入分支:分支失败定位模糊。
  • 断言之间强依赖前序状态:用例不再独立。

追问

  • 关联断言算多个行为吗?答:同一行为的多个字段断言可保留在一个用例。
  • 拆分后夹具重复怎么办?答:工厂复用构造,步骤仍各自显式。

04.8.3.3-095 断言粒度如何把握?

一句话结论

断言覆盖业务关键结果与必要交互,不断言无关内部实现细节;粒度细到能定位错误字段,又不把测试绑定到实现结构。

概念解释

断言过粗只验成功标志,错误内容漏网;过细断言私有实现/调用顺序,重构即破坏测试。按对外可观察结果断言:返回值、状态变化、关键交互。内部实现变化不应迫使测试失败。

原理流程

  1. 明确行为的可观察结果。
  2. 断言结果字段与关键副作用。
  3. 不断言私有状态与实现步骤。
  4. 重构内部结构保持测试通过。

代码或图示

// 合适:断言对外结果
order.status shouldBe OrderStatus.PAID

// 过细:断言内部调用顺序/私有字段

常见误区

  • mock 验证每个内部调用:测试与实现强耦合。
  • 只断言非空:错误值被放过。

追问

  • 副作用如何断言?答:通过 fake 记录的对外交互(仓储保存、事件发布)验证。
  • 重构导致测试失败说明什么?答:可能断言了实现细节,应调整为行为断言。

04.8.3.3-096 遗留代码如何补测?

一句话结论

先梳理关键业务路径补特征性测试(提取接缝、用现有接口测行为),修复缺陷前先补回归用例;不追求一次性全覆盖,按风险优先级递进。

概念解释

遗留代码缺少测试且结构难测。先在外部行为层加 Characterization 测试锁定当前行为,再逐步提取可单测单元。改动某模块前优先覆盖其核心路径,防止回归。

原理流程

  1. 梳理核心路径与风险点。
  2. 在可触及的接缝补行为测试。
  3. 重构提取依赖边界,下沉单元测试。
  4. 缺陷修复先补复现用例。

代码或图示

遗留代码 → 行为特征测试锁定现状 → 提取接缝 → 单元测试下沉

常见误区

  • 试图先把全部代码重构再补测试:风险高,应测试保护下渐进重构。
  • 补测只覆盖 happy path:遗留缺陷多在错误分支。

追问

  • 无法注入依赖的遗留类怎么办?答:先包一层可测边界,测试覆盖新边界,内部逐步改造。
  • 特征测试记录的是正确行为还是现状?答:先锁定现状,发现缺陷后修正并更新测试。

04.8.3.3-097 测试中的时间与时钟如何抽象?

一句话结论

把当前时间、延迟、超时抽象为可注入时钟/调度器接口,测试替换为虚拟时钟;避免代码直接调用系统时间导致时间相关逻辑不可测。

概念解释

时间相关逻辑(过期、超时、有效期)依赖当前时刻。直接读系统时间使测试必须等待或篡改全局时间。注入时钟后测试可控推进时刻,稳定验证时间分支。

原理流程

  1. 定义时钟接口提供 now()。
  2. 生产实现包装系统时钟。
  3. 测试注入固定/虚拟时钟。
  4. 断言不同时刻的业务结果。

代码或图示

interface Clock { fun now(): Instant }

// 测试:固定时钟
class FixedClock(private val instant: Instant) : Clock {
    override fun now() = instant
}

常见误区

  • 代码内部直接单例取时间:测试无法替换。
  • 测试靠修改系统时区/时间:环境耦合且不可重复。

追问

  • 延迟/调度如何抽象?答:注入调度器或延时函数,协程测试用测试调度器替换。
  • 时钟抽象影响性能吗?答:一次接口调用开销可忽略,换来可测性。

04.8.3.3-098 测试随机数据生成如何保证确定性?

一句话结论

随机数据使用固定种子可复现;测试断言不依赖随机产生的具体巧合值,非法/边界用例用显式数据;并行执行时各用例生成器独立。

概念解释

随机生成用于丰富样例,但失败必须可复现。固定种子让生成序列确定;属性测试记录反例。数据工厂基线确定,随机只补充组合。共享随机源会造成用例间不确定。

原理流程

  1. 生成器配置固定种子。
  2. 用例取得确定序列数据。
  3. 失败记录种子与反例。
  4. 并行用例各自独立生成器。

代码或图示

固定种子 → 可复现序列
反例记录 → 转为固定回归用例

常见误区

  • 不设种子跑随机测试:偶发失败无法复现。
  • 断言随机值等于某个巧合输出:无意义耦合。

追问

  • 随机数据需要清理吗?答:测试数据在用例隔离环境内产生,随用例结束丢弃。
  • 随机字符串生成器注意什么?答:控制长度与字符集,覆盖边界长度。

04.8.3.3-099 测试依赖外部不可控服务如何处理?

一句话结论

单元/集成层用替身或沙箱隔离不可控服务;确需真实外部联调的用例单独标记、低频执行,不阻塞常规反馈;不把生产外部环境作为测试依赖。

概念解释

不可控服务存在配额、数据变更、可用性与网络波动。常规测试不能依赖其稳定响应。替代方案:mock/fake、录制样例、兼容协议容器、专属沙箱环境。

原理流程

  1. 识别外部不可控依赖。
  2. 常规测试用替身/容器隔离。
  3. 真实联调用例单独标签低频运行。
  4. 外部环境问题不阻断单元反馈。

代码或图示

常规:替身 / 容器 / 录制样例
低频:沙箱联调,单独标签

常见误区

  • 测试直连第三方生产环境:污染数据、受配额限制。
  • 外部服务波动导致 CI 误报:未隔离的依赖应移出常规集。

追问

  • 录制回放样例怎么维护?答:契约样例随接口更新,过期样例及时刷新。
  • 沙箱环境不可用时测试怎么标?答:跳过并记录原因,不忽略真实断言。

04.8.3.3-100 面试中如何讲清自己的测试体系?

一句话结论

按分层(单元/集成/e2e)、替身策略、关键工具链(框架、mock、容器、覆盖率、静态分析)、CI 门禁与质量度量组织回答,并结合实际项目举例覆盖与治理效果。

概念解释

面试官关注:测试金字塔落地、替身取舍、协程/异步测试、外部依赖隔离、质量门禁与 flaky 治理。回答先讲结构,再讲关键决策与权衡,最后给项目数据(覆盖、反馈时长、缺陷发现层)。

原理流程

  1. 说明分层与各层目的。
  2. 讲替身与外部依赖隔离策略。
  3. 列工具链与 CI 卡点。
  4. 举例治理问题与改进效果。

代码或图示

回答框架:分层 → 替身 → 工具链 → 门禁 → 项目实例与度量

常见误区

  • 只罗列用过的框架名:不说明选型理由与落地边界。
  • 声称高覆盖率但不讲断言质量:补充缺陷发现与 flaky 治理实例。

追问

  • 项目测试最大的挑战是什么?答:按真实经历讲外部依赖隔离、遗留代码补测或 flaky 治理。
  • 如何衡量测试投入产出?答:缺陷逃逸率、反馈时长、回归成本等维度结合说明。

参考来源

  • JUnit 5 官方文档:测试生命周期、参数化与扩展模型,https://junit.org/junit5/docs/current/user-guide/
  • Kotest 官方文档:Spec 风格、断言 matcher 与属性测试,https://kotest.io/docs/
  • MockK 官方文档:mock/stub/spy、协程 mock 与验证 API,https://mockk.io/
  • Kotlin 官方文档:kotlinx-coroutines-test 与 runTest 测试调度器,https://kotlinlang.org/docs/coroutines-testing.html
  • Testcontainers 官方文档:容器生命周期、复用策略与集成方式,https://testcontainers.com/

待整理清单

  • [ ] 核对 Kotest 属性测试与生成器当前 API 名称(见 04.8.3.3-044、04.8.3.3-045)
  • [ ] 核对 JaCoCo 插件在 Kotlin 2.x/K2 下的兼容版本与行映射限制(见 04.8.3.3-062)
  • [ ] 核对 Testcontainers 复用模式与容器网络配置的当前 API(见 04.8.3.3-048、04.8.3.3-051)
  • [ ] 补充本工程 detekt/ktlint 规则集与 editorconfig 实际配置样例
  • [ ] 补充多模块覆盖率聚合任务与门禁阈值的工程落地配置