返回专栏
· 21 分钟阅读

单元测试与测试框架


一、什么是单元测试?

单元测试(Unit Testing)是一种软件测试方法,用于验证程序中最小的、可独立测试的代码单元是否符合预期。

这里的“单元”通常指:

  • 一个函数或方法。
  • 一个类的某项行为。
  • 一个独立的模块功能。
  • 一个具有明确输入和输出的业务逻辑。

例如,一个计算订单折扣的函数:

def calculate_discount(price, rate):
    if price < 0:
        raise ValueError("price cannot be negative")

    if not 0 <= rate <= 1:
        raise ValueError("invalid discount rate")

    return price * (1 - rate)

可以针对它编写多个单元测试:

def test_normal_discount():
    assert calculate_discount(100, 0.2) == 80


def test_zero_discount():
    assert calculate_discount(100, 0) == 100


def test_full_discount():
    assert calculate_discount(100, 1) == 0


def test_negative_price():
    try:
        calculate_discount(-100, 0.2)
    except ValueError:
        return

    raise AssertionError("Expected ValueError")

这些测试分别验证正常折扣、零折扣、全额折扣和非法输入。

单元测试的核心不是验证代码能否运行,而是验证代码在不同输入和边界条件下是否表现正确。

1. 单元测试的主要目标

目标 说明
验证正确性 检查函数输出是否符合预期
发现缺陷 尽早发现逻辑错误和边界问题
防止回归 修改代码后确认已有功能没有被破坏
明确行为 通过测试表达函数和模块的预期行为
支持重构 在保持行为不变的前提下调整内部实现
改善设计 通过测试暴露模块之间的过度耦合

2. 单元测试不等于简单运行代码

普通运行主要关注程序是否能够执行,而单元测试需要明确验证结果。

例如:

result = calculate_discount(100, 0.2)
print(result)

这段代码只输出结果,并没有自动判断结果是否正确。

而:

assert calculate_discount(100, 0.2) == 80

会在实际结果不符合预期时直接失败。

测试的关键在于建立明确的预期,并将实际结果与预期进行比较。


二、单元测试的基本结构

一个完整的单元测试通常包含三个阶段:

  1. Arrange:准备测试数据和依赖。
  2. Act:执行被测试的代码。
  3. Assert:验证执行结果。

这种结构也称为 AAA 模式。

def test_calculate_discount():
    # Arrange:准备数据
    price = 100
    rate = 0.2

    # Act:执行目标函数
    result = calculate_discount(price, rate)

    # Assert:验证结果
    assert result == 80

1. Arrange:准备阶段

准备测试所需的输入和环境。

包括:

  • 构造测试对象。
  • 准备输入数据。
  • 初始化依赖。
  • 配置 Mock 对象。
  • 设置必要的测试状态。

准备阶段应尽量简单,避免引入与测试目标无关的复杂操作。

2. Act:执行阶段

调用需要验证的函数、方法或模块。

一个测试通常应聚焦一个主要行为,避免同时执行大量无关操作。

例如:

result = user_service.register("alice", "123456")

3. Assert:断言阶段

将实际结果与预期结果进行比较。

常见断言包括:

assert result == expected
assert result is not None
assert len(result) == 3
assert "admin" in roles

对于异常行为,也需要明确验证:

import pytest

def test_invalid_price():
    with pytest.raises(ValueError):
        calculate_discount(-100, 0.2)

4. 测试执行流程

flowchart TD
    A["选择测试目标"] --> B["准备测试数据和依赖"]
    B --> C["执行被测试代码"]
    C --> D["获取实际结果"]
    D --> E{"断言是否通过"}
    E -->|"通过"| F["记录测试成功"]
    E -->|"失败"| G["记录失败信息"]
    G --> H["定位缺陷"]
    H --> I["修复代码"]
    I --> C

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#FBE9E9,stroke:#D9AAAA,color:#334155
    style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style I fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

三、测试框架是什么?

测试框架(Testing Framework)是一套用于编写、组织、执行和管理测试代码的软件工具。

它通常提供:

  • 测试用例发现与执行。
  • 断言机制。
  • 测试环境初始化与清理。
  • 测试数据管理。
  • Mock 和 Stub 等测试替身。
  • 测试结果统计。
  • 测试报告生成。
  • 并行测试执行。

没有测试框架,也可以通过普通代码编写测试,但随着测试数量增加,测试发现、执行、结果统计和环境管理会变得复杂。

测试框架将这些通用能力标准化,使开发者能够专注于测试业务行为。

1. 测试框架的核心组成

组成 作用
Test Case 定义一个具体的测试用例
Test Suite 将多个测试用例组织在一起
Assertion 判断实际结果是否符合预期
Fixture 管理测试前后的初始化和清理
Test Runner 发现并执行测试用例
Mock 模拟外部依赖的行为
Reporter 输出测试结果和报告

2. 测试框架的工作机制

flowchart TD
    A["测试代码"] --> B["测试发现"]
    B --> C["构建测试集合"]
    C --> D["准备 Fixture"]
    D --> E["执行 Test Case"]
    E --> F["运行 Assertion"]
    F --> G{"测试结果"}
    G -->|"通过"| H["记录 Pass"]
    G -->|"失败"| I["记录 Fail"]
    H --> J["清理测试环境"]
    I --> J
    J --> K["生成测试报告"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style G fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style H fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style I fill:#FBE9E9,stroke:#D9AAAA,color:#334155
    style J fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style K fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

需要注意:不同测试框架的内部实现并不完全相同。例如,有些框架采用类和方法组织测试,有些则以普通函数为核心;Fixture、测试发现和并行执行的具体机制也存在差异。


四、常见测试框架

不同编程语言拥有不同的测试生态。

1. Python:pytest 与 unittest

Python 常见的测试框架包括 pytest 和 unittest。

pytest

pytest 是 Python 生态中广泛使用的第三方测试框架,语法简洁,扩展能力强。

安装:

pip install pytest

测试代码:

def add(a, b):
    return a + b
def test_add():
    assert add(2, 3) == 5

运行:

pytest

pytest 会自动发现符合命名约定的测试文件和测试函数。

常用能力:

  • 简洁的 assert 断言。
  • Fixture 测试环境管理。
  • 参数化测试。
  • Mock 集成。
  • 插件扩展。
  • 并行测试支持(通常通过 pytest-xdist 等插件)。

参数化测试示例:

import pytest
@pytest.mark.parametrize(
    "a,b,expected",
    [
        (1, 2, 3),
        (2, 3, 5),
        (10, 20, 30),
    ]
)
def test_add(a, b, expected):
    assert a + b == expected

一个测试函数可以使用多组输入执行,减少重复代码。

unittest

unittest 是 Python 标准库提供的测试框架,不需要额外安装。

import unittest
def add(a, b):
    return a + b
class TestMath(unittest.TestCase):
def test_add(self):
        self.assertEqual(add(2, 3), 5)
def test_positive(self):
        self.assertGreater(add(2, 3), 0)
if __name__ == "__main__":
    unittest.main()

运行:

python -m unittest

pytest 和 unittest 的主要区别:

对比 pytest unittest
来源 第三方框架 Python 标准库
语法 函数式风格简洁 基于测试类
断言 直接使用 assert 使用 assertEqual 等方法
Fixture 灵活的 Fixture 系统 setUp、tearDown 等
参数化 内置支持 通常需要扩展或自行组织
插件生态 丰富 相对传统

2. Java:JUnit

JUnit 是 Java 生态中广泛使用的单元测试框架。

以 JUnit 5 为例:

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
class CalculatorTest {
@Test
    void testAdd() {
        Calculator calculator = new Calculator();
int result = calculator.add(2, 3);
assertEquals(5, result);
    }
}

常见注解:

注解 作用
@Test 声明测试方法
@BeforeEach 每个测试方法执行前运行
@AfterEach 每个测试方法执行后运行
@BeforeAll 所有测试开始前运行
@AfterAll 所有测试结束后运行
@ParameterizedTest 声明参数化测试
@Disabled 暂时禁用测试

JUnit 5 的架构主要由三个部分组成:

  • JUnit Platform:测试执行平台。
  • JUnit Jupiter:JUnit 5 的编程模型和扩展模型。
  • JUnit Vintage:兼容运行 JUnit 3 和 JUnit 4 测试。

JUnit 通常与 Maven 或 Gradle 集成,支持在构建过程中自动执行测试。

3. JavaScript / TypeScript:Jest 与 Vitest

JavaScript 和 TypeScript 项目常见的测试框架包括 Jest 和 Vitest。

Jest

Jest 是一个功能较完整的 JavaScript 测试框架。

function add(a, b) {
    return a + b;
}
test("add should return the sum", () => {
    expect(add(2, 3)).toBe(5);
});

运行:

npx jest

常见能力:

  • 测试发现和执行。
  • 断言和匹配器。
  • Mock 函数。
  • 模块 Mock。
  • Snapshot Testing。
  • 覆盖率统计。

Vitest

Vitest 是面向现代 JavaScript 工具链的测试框架,与 Vite 生态结合紧密。

import { describe, it, expect } from "vitest";
function add(a, b) {
    return a + b;
}
describe("add", () => {
    it("should return the sum", () => {
        expect(add(2, 3)).toBe(5);
    });
});

运行:

npx vitest

Jest 与 Vitest 都支持常见测试能力,但 Vitest 在 Vite 项目中通常具有更自然的配置集成。

4. Go:testing

Go 语言内置 testing 包,不需要安装第三方测试框架就可以完成基础单元测试。

生产代码:

package calculator
func Add(a, b int) int {
    return a + b
}

测试代码:

package calculator
import "testing"
func TestAdd(t *testing.T) {
    result := Add(2, 3)
if result != 5 {
        t.Errorf("expected 5, got %d", result)
    }
}

文件命名通常采用:

calculator.go
calculator_test.go

运行:

go test ./...

Go 的测试体系还支持:

  • 表驱动测试(Table-driven Tests)。
  • 子测试(Subtests)。
  • 基准测试(Benchmark)。
  • 模糊测试(Fuzzing)。
  • 示例测试(Example Tests)。

表驱动测试:

func TestAdd(t *testing.T) {
    cases := []struct {
        a, b, expected int
    }{
        {1, 2, 3},
        {2, 3, 5},
        {10, 20, 30},
    }
for _, tc := range cases {
        result := Add(tc.a, tc.b)
if result != tc.expected {
            t.Errorf(
                "Add(%d, %d) = %d, want %d",
                tc.a, tc.b, result, tc.expected,
            )
        }
    }
}

5. Rust:内置测试机制

Rust 提供了内置测试机制,通过 #[test] 标记测试函数。

fn add(a: i32, b: i32) -> i32 {
    a + b
}
#[test]
fn test_add() {
    assert_eq!(add(2, 3), 5);
}

运行:

cargo test

Rust 还支持:

  • assert!:验证布尔条件。
  • assert_eq!:验证相等。
  • assert_ne!:验证不相等。
  • #[should_panic]:验证测试是否发生预期的 panic。
  • #[cfg(test)]:控制测试代码的编译条件。

示例:

#[test]
#[should_panic]
fn test_invalid_operation() {
    panic!("expected panic");
}

Rust 的测试机制与 Cargo 深度集成,适合将测试作为项目构建流程的一部分。


五、Fixture:测试环境管理

Fixture 是测试框架提供的一种测试资源管理机制,用于在测试执行前准备环境,并在测试结束后进行清理。

例如,一个用户服务可能依赖:

  • 数据库连接。
  • 测试用户。
  • 临时文件。
  • 模拟对象。
  • 测试配置。

如果每个测试都重复准备这些资源,会产生大量重复代码。

Fixture 可以统一管理这些准备和清理操作。

1. pytest Fixture 示例

import pytest
@pytest.fixture
def user():
    return {
        "id": 1,
        "name": "Alice"
    }
def test_user_name(user):
    assert user["name"] == "Alice"

pytest 会自动将 Fixture 作为参数传递给测试函数。

2. Fixture 的作用域

pytest 提供不同的 Fixture 生命周期:

Scope 生命周期
function 每个测试函数
class 每个测试类
module 每个测试模块
package 每个测试包
session 整个测试会话

例如:

@pytest.fixture(scope="session")
def database_connection():
    connection = create_connection()
yield connection
connection.close()

这里的 yield 将资源准备和资源清理分隔开。

3. Fixture 生命周期

flowchart TD
    A["启动测试"] --> B["初始化 Fixture"]
    B --> C["准备测试资源"]
    C --> D["执行测试用例"]
    D --> E["收集测试结果"]
    E --> F{"是否还有测试"}
    F -->|"是"| D
    F -->|"否"| G["执行清理逻辑"]
    G --> H["释放资源"]
    H --> I["结束测试"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style I fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

Fixture 的作用域越大,资源复用程度通常越高,但测试之间共享状态的风险也会增加。

例如,多个测试共用同一个数据库记录,如果其中一个测试修改了数据,可能影响其他测试。

因此,Fixture 设计需要平衡资源创建成本和测试隔离性。


六、Mock、Stub 与测试替身

实际开发中,一个函数可能依赖数据库、网络服务、消息队列或第三方 API。

如果单元测试直接调用这些真实依赖,会出现几个问题:

  • 测试执行速度较慢。
  • 依赖外部网络和服务状态。
  • 测试数据难以控制。
  • 外部服务故障可能导致测试失败。
  • 测试结果不稳定。

因此,单元测试经常使用测试替身(Test Double)隔离外部依赖。

1. 测试替身的常见类型

类型 作用
Dummy 占位对象,仅用于满足参数要求
Stub 提供预先设定的返回结果
Mock 验证依赖是否按照预期被调用
Fake 提供可工作的简化实现
Spy 记录真实调用过程,便于事后验证

这些概念描述的是不同的测试替身角色。在实际工具中,一个对象可能同时具有多种特征。

2. Stub 示例

假设订单服务需要调用支付服务:

class PaymentService:
    def pay(self, amount):
        raise NotImplementedError
class OrderService:
    def __init__(self, payment_service):
        self.payment_service = payment_service
def create_order(self, amount):
        return self.payment_service.pay(amount)

测试时,可以使用 Stub 模拟支付结果:

class FakePaymentService:
    def pay(self, amount):
        return {
            "success": True,
            "amount": amount
        }
def test_create_order():
    payment = FakePaymentService()
    order = OrderService(payment)
result = order.create_order(100)
assert result["success"] is True
    assert result["amount"] == 100

这里使用简化的支付实现,避免调用真实支付系统。

3. Mock 示例

如果希望验证支付服务是否被正确调用,可以使用 Mock:

from unittest.mock import Mock
def test_create_order_calls_payment():
    payment = Mock()
    payment.pay.return_value = {
        "success": True
    }
order = OrderService(payment)
    result = order.create_order(100)
assert result["success"] is True
    payment.pay.assert_called_once_with(100)

这个测试不仅验证返回结果,还验证了订单服务是否以正确参数调用支付服务。

4. Mock 的使用边界

Mock 并不是越多越好。

过度 Mock 可能导致:

  • 测试只验证实现细节,而不是业务行为。
  • 代码重构后大量测试需要修改。
  • 测试通过,但真实依赖集成时仍然失败。
  • 测试代码与生产代码的内部结构高度耦合。

一个重要原则是:

优先验证外部可观察的行为,而不是过度验证内部调用过程。

对于复杂的数据库交互、消息队列和第三方 API,还需要结合集成测试验证真实协作行为。


七、单元测试的覆盖率

测试覆盖率(Test Coverage)用于衡量测试执行过程中代码被覆盖的程度。

常见指标包括:

1. 语句覆盖率(Statement Coverage)

衡量有多少可执行语句被测试执行过。

例如:

def calculate(value):
    if value > 0:
        return value * 2
return 0

如果只测试:

calculate(10)

那么 return 0 对应的语句没有执行。

语句覆盖率不能证明所有分支都被测试。

2. 分支覆盖率(Branch Coverage)

衡量程序中的条件分支是否都被执行。

例如:

if value > 0:
    return "positive"
else:
    return "non-positive"

需要至少测试:

  • value > 0 成立。
  • value > 0 不成立。

分支覆盖比单纯语句覆盖更能反映条件判断的测试情况。

3. 条件覆盖率(Condition Coverage)

针对复合条件中的每个布尔子表达式,检查其真假结果是否都得到测试。

例如:

if age >= 18 and has_permission:
    allow()

这里包含两个条件:

  • age >= 18
  • has_permission

条件覆盖关注两个条件分别是否取过 True 和 False。

需要注意,条件覆盖与分支覆盖并不相同。

4. 路径覆盖率(Path Coverage)

衡量程序中不同执行路径是否被覆盖。

对于存在多个条件和循环的程序,路径数量可能非常庞大,甚至随着循环次数增加而难以穷举。

因此,完整路径覆盖在复杂程序中通常不现实。

5. 覆盖率指标对比

指标 检查内容 局限
语句覆盖 语句是否执行 不保证分支完整
分支覆盖 判断分支是否执行 不保证所有条件组合
条件覆盖 子条件真假情况 不一定覆盖全部分支组合
路径覆盖 执行路径 复杂程序难以穷举
函数覆盖 函数是否被调用 不代表函数行为正确

6. 如何理解覆盖率?

假设一个项目的单元测试覆盖率达到 90%,并不意味着代码有 90% 的正确性。

覆盖率只能说明测试执行触及了多少代码,无法直接证明断言是否充分。

例如:

def divide(a, b):
    return a / b