【Python从入门到精通】第 023 篇：单元测试与TDD：pytest实战完全指南

xyghehehehe

247人浏览 · 2026-04-12 10:12:36

xyghehehehe · 2026-04-12 10:12:36 发布

上一篇【第022篇】虚拟环境与包管理：pip、venv、Poetry完全指南
下一篇【第024篇】代码质量：格式化、Linting与CI自动化完全指南

系列说明：本系列共 30 篇，旨在帮助Python学习者从零基础到精通。本系列强调实战导向，每篇文章都配有可运行的代码示例。本文为第 023 篇，聚焦于单元测试与TDD实战。

摘要

在现代软件开发中，代码质量是衡量项目成功与否的关键指标之一。单元测试作为软件质量保障的第一道防线，能够帮助开发者在代码变更时快速发现潜在问题，确保系统的稳定性和可维护性。pytest作为Python生态中最流行的测试框架，以其简洁优雅的语法、强大的插件系统和丰富的功能特性，赢得了广大开发者的青睐。

本文将全面介绍pytest框架的核心功能和使用技巧，涵盖单元测试基础、断言机制、Fixtures系统、参数化测试等核心概念。同时，我们将深入探讨测试驱动开发（TDD）的核心理念和实践方法，通过红-绿-重构循环引导读者建立良好的测试习惯。此外，文章还将讲解测试覆盖率分析、Mock对象使用、异步代码测试等高级主题，帮助读者构建完善的测试体系。

通过本文的学习，读者将能够熟练运用pytest编写高质量的测试用例，掌握TDD开发流程，并具备独立构建测试套件的能力。

一、单元测试基础

1.1 什么是单元测试

单元测试（Unit Testing）是软件测试中最基础、最重要的环节，它针对软件的最小可测试单元进行验证。在Python中，这个最小单元通常是函数或类的方法。单元测试的核心目标是隔离代码的每个部分，验证其行为是否符合预期。

单元测试具有以下特征：首先，每个测试用例应该能够独立运行，不依赖于其他测试的执行结果；其次，测试应该具有确定性，同样的输入必须产生同样的输出；最后，测试代码应该与生产代码分离，保持清晰的代码结构。

一个好的单元测试应该具备以下特质：快速执行（通常在毫秒级别完成）、可重复运行、结果一致、易于理解和维护。单元测试是开发者编写生产代码的"活文档"，通过阅读测试代码可以快速了解函数或类的预期行为和使用方式。

1.2 单元测试的价值

单元测试在软件开发中具有不可替代的重要作用。首先，单元测试是质量保证的基石。通过编写全面的测试用例，开发者可以在代码提交前发现潜在的bug，减少生产环境中的故障率。研究表明，在软件开发早期发现的bug，修复成本仅为后期修复的百分之一甚至千分之一。

其次，单元测试为代码重构提供了安全保障。当我们需要优化代码结构、改进算法或进行性能调优时，如果拥有完善的测试覆盖，可以放心地进行修改，确保不会破坏现有功能。

第三，单元测试是代码文档的重要补充。与传统的注释文档不同，测试代码是"可执行的文档"，永远不会过时。

此外，单元测试还促进了代码设计的优化。为了使代码易于测试，我们不得不将代码设计成低耦合、高内聚的结构。

1.3 测试金字塔

测试金字塔是一个经典的测试分层模型，从底部到顶部依次是：单元测试（Unit Tests）、集成测试（Integration Tests）和端到端测试（End-to-End Tests）。

        /\
       /  \
      / E2E \         <- 少量端到端测试
     /--------\
    /Integration\     <- 适量集成测试
   /--------------\
  /   Unit Tests   \  <- 大量单元测试
 /------------------\

单元测试位于金字塔的底部，数量最多，执行最快，反馈也最及时。理想情况下，你的测试套件应该包含大量的单元测试（约占70%或更多），少量精心设计的集成测试，以及极少的端到端测试。

1.4 unittest vs pytest对比

Python标准库提供了unittest模块，它是Python最早的单元测试框架，遵循Java的JUnit设计模式。pytest是第三方测试框架，以其简洁的语法和强大的功能著称。

特性	unittest	pytest
安装	标准库，无需安装	需要安装
语法	必须使用assertEqual等方法	使用原生assert语句
发现规则	需要显式导入	自动发现
学习曲线	中等	低
插件生态	无	丰富

对于大多数项目，我们推荐使用pytest。

二、pytest快速入门

2.1 安装与配置

pytest的安装非常简单：

pip install pytest

推荐同时安装常用插件：

pip install pytest pytest-cov pytest-mock pytest-asyncio

pytest的配置文件可以是pytest.ini、pyproject.toml或setup.cfg。推荐使用pyproject.toml：

[tool.pytest.ini_options]
minversion = "8.0"
addopts = "-ra -q"
testpaths = ["tests"]
pythonpath = ["."]
asyncio_mode = "auto"

2.2 第一个测试用例

# tests/test_calculator.py
"""计算器模块的单元测试"""
import pytest

from calculator import add, subtract, multiply, divide


class TestCalculator:
    """计算器测试类"""
    
    def test_add_positive_numbers(self):
        """测试两个正数相加"""
        assert add(2, 3) == 5
    
    def test_add_negative_numbers(self):
        """测试两个负数相加"""
        assert add(-5, -3) == -8
    
    def test_divide_by_zero(self):
        """测试除数为零的情况"""
        with pytest.raises(ValueError, match="除数不能为零"):
            divide(10, 0)

2.3 pytest发现规则

pytest的发现规则：

测试文件必须以test_开头或以_test.py结尾
测试函数必须以test_开头
测试类必须以Test开头

运行测试：

pytest                          # 运行所有测试
pytest tests/unit/             # 运行指定目录
pytest tests/test_calc.py      # 运行指定文件
pytest -k "add"                # 运行包含"add"的测试

2.4 测试结果解读

========================= test session starts ==========================
collected 8 items

tests/test_calculator.py::TestCalculator::test_add PASSED [ 12%]
tests/test_calculator.py::TestCalculator::test_divide PASSED [ 25%]

========================= 2 passed in 0.15s ==========================

三、断言详解

3.1 简洁的assert语句

pytest使用原生Python的assert语句进行断言：

def test_basic_assertions():
    # 相等性断言
    assert 2 + 2 == 4
    assert "hello" == "hello"
    
    # 布尔断言
    assert True
    assert 1  # 非零数值在布尔上下文中为True
    
    # 包含性断言
    assert 3 in [1, 2, 3, 4, 5]

3.2 浮点数比较：pytest.approx

def test_float_comparison():
    result = 0.1 + 0.2
    expected = 0.3
    
    # 使用 pytest.approx 进行近似比较
    assert result == pytest.approx(expected)
    
    # 设置容差范围
    assert result == pytest.approx(expected, abs=1e-9)

3.3 异常断言：pytest.raises

def test_divide_by_zero():
    with pytest.raises(ValueError) as exc_info:
        divide(10, 0)
    
    assert "除数不能为零" in str(exc_info.value)

3.4 warnings断言

def test_deprecation_warning():
    with pytest.warns(DeprecationWarning, match="已弃用"):
        result = deprecated_function(5)
        assert result == 10

四、pytest Fixtures

4.1 fixture概念与作用

Fixtures是pytest中用于提供测试依赖和共享资源的机制。

4.2 @pytest.fixture装饰器

import pytest
from dataclasses import dataclass

@dataclass
class User:
    id: int
    name: str
    email: str


@pytest.fixture
def sample_user() -> User:
    """创建一个示例用户"""
    return User(id=1, name="张三", email="zhangsan@example.com")


class TestUserFixtures:
    def test_single_user(self, sample_user):
        assert sample_user.id == 1
        assert sample_user.name == "张三"

4.3 fixture的作用域

作用域	说明
function（默认）	每个测试函数执行一次
class	每个测试类执行一次
module	每个模块执行一次
session	整个测试会话只执行一次

@pytest.fixture(scope="module")
def database_connection():
    """模块级fixture"""
    db = connect_to_database()
    yield db
    db.close()

4.4 fixture的依赖注入

@pytest.fixture
def database():
    """创建数据库连接fixture"""
    db = Database()
    db.connect()
    yield db
    db.disconnect()


@pytest.fixture
def user_repository(database):
    """用户仓库依赖数据库fixture"""
    return UserRepository(db=database)

4.5 conftest.py共享fixtures

conftest.py用于在多个测试文件之间共享fixtures：

# tests/conftest.py
import pytest

@pytest.fixture
def mock_external_api():
    """模拟外部API的fixture"""
    class MockAPI:
        def get(self, url):
            return {"status": "ok", "data": url}
    return MockAPI()

4.6 autouse参数

使用autouse=True可以让fixture自动应用于所有测试：

@pytest.fixture(autouse=True)
def setup_logging():
    """自动配置日志"""
    logging.basicConfig(level=logging.INFO)

五、参数化测试

5.1 @pytest.mark.parametrize

import pytest

@pytest.mark.parametrize("n,expected", [
    (1, 1),
    (2, 1),
    (3, 2),
    (4, 3),
    (5, 5),
])
def test_fibonacci(n, expected):
    assert calculate_fibonacci(n) == expected

5.2 多参数组合测试

@pytest.mark.parametrize("a,b,operation,expected", [
    (2, 3, "add", 5),
    (2, 3, "subtract", -1),
    (2, 3, "multiply", 6),
    (2, 3, "divide", 2/3),
])
def test_calculator_operations(a, b, operation, expected):
    # 测试代码...
    pass

5.3 跳过测试

@pytest.mark.skip(reason="功能开发中")
def test_coming_feature():
    pass

@pytest.mark.skipif(sys.version_info < (3, 11), reason="需要Python 3.11+")
def test_python_version_feature():
    pass

六、TDD开发流程

6.1 TDD红-绿-重构循环

┌─────────────────────────────────────────────────────────┐
│                      TDD 循环                           │
│                                                         │
│      ┌─────────┐                                        │
│      │   RED   │  1. 编写一个失败的测试                 │
│      └────┬────┘                                        │
│           │                                             │
│           ▼                                             │
│      ┌─────────┐                                        │
│      │  GREEN  │  2. 编写最少的代码让测试通过            │
│      └────┬────┘                                        │
│           │                                             │
│           ▼                                             │
│      ┌─────────┐                                        │
│      │ REFACTOR│  3. 重构代码，保持测试通过              │
│      └─────────┘                                        │
└─────────────────────────────────────────────────────────┘

Red（红色）：编写一个会失败的测试
Green（绿色）：快速编写最少量代码让测试通过
Refactor（重构）：在测试保护下优化代码

6.2 简单TDD示例：栈数据结构

第一步：编写失败的测试（Red）

# tests/test_stack.py
import pytest
from stack import Stack


class TestStackTDD:
    def test_stack_is_empty_initially(self):
        stack = Stack()
        assert stack.is_empty() is True
    
    def test_push_and_pop(self):
        stack = Stack()
        stack.push(42)
        assert stack.pop() == 42

第二步：实现最小代码（Green）

# src/stack.py
class Stack:
    def __init__(self):
        self._items = []
    
    def is_empty(self) -> bool:
        return len(self._items) == 0
    
    def push(self, item):
        self._items.append(item)
    
    def pop(self):
        if self.is_empty():
            raise IndexError("pop from empty stack")
        return self._items.pop()

七、测试覆盖率和Mock

7.1 coverage.py使用

# 安装
pip install pytest-cov

# 运行测试并生成覆盖率报告
pytest --cov=src --cov-report=term-missing tests/

# 生成HTML报告
pytest --cov=src --cov-report=html tests/

配置覆盖率：

[tool.coverage.run]
source = ["src"]
omit = ["tests/*", "*/migrations/*"]

[tool.coverage.report]
exclude_lines = [
    "pragma: no cover",
    "raise NotImplementedError",
]

7.2 Mock对象简介

from unittest.mock import Mock, MagicMock, patch

def test_mock_basic():
    mock = Mock()
    mock.method()
    mock.attribute = "value"
    
    mock.method.assert_called()
    assert mock.attribute == "value"

7.3 patch装饰器

from unittest.mock import patch, MagicMock

class TestAPIFetching:
    @patch('myapp.services.requests.get')
    def test_fetch_user_success(self, mock_get):
        mock_response = MagicMock()
        mock_response.status_code = 200
        mock_response.json.return_value = {"id": 1, "name": "张三"}
        mock_get.return_value = mock_response
        
        result = fetch_user_data(1)
        
        assert result == {"id": 1, "name": "张三"}
        mock_get.assert_called_once_with("https://api.example.com/users/1")

八、异步代码测试

8.1 pytest-asyncio基础

pip install pytest-asyncio

import pytest
import asyncio

@pytest.mark.asyncio
async def test_simple_async():
    await asyncio.sleep(0.1)
    result = 1 + 1
    assert result == 2

8.2 异步Fixtures

import pytest_asyncio

@pytest_asyncio.fixture
async def async_database():
    connection = await create_async_connection()
    yield connection
    await connection.close()

8.3 异步异常测试

@pytest.mark.asyncio
async def test_async_exception():
    async def failing_async_func():
        await asyncio.sleep(0.01)
        raise ValueError("异步函数中的错误")
    
    with pytest.raises(ValueError, match="异步函数中的错误"):
        await failing_async_func()

九、常见问题与注意事项

9.1 测试运行慢的优化

减少不必要的I/O操作：使用内存数据库替代真实数据库
合理使用fixture作用域：重量级资源使用session或module级别
并行测试：使用pytest-xdist进行并行测试

pip install pytest-xdist
pytest -n 4  # 使用4个进程并行运行

9.2 测试隔离问题

def test_file_operations(self, tmp_path):
    """使用tmp_path fixture确保测试隔离"""
    test_file = tmp_path / "test.txt"
    test_file.write_text("content")
    assert test_file.read_text() == "content"