python单元测试详解

为什么选择Pytest？

在Python的世界里，单元测试框架并不少，但Pytest凭借其简洁优雅的语法和强大的功能，已经成为众多开发者的首选。记得我第一次接触Pytest时，就被它的简洁所震撼------相比Python自带的unittest，Pytest让测试代码的编写变得如此自然，几乎就像在写普通的Python脚本。

Pytest的核心优势

极低的入门门槛：如果你会写Python函数，你就已经掌握了Pytest的基础
强大的断言机制 ：无需记忆复杂的断言方法，直接使用assert关键字
自动发现测试：智能识别测试文件和测试函数，无需手动添加
丰富的插件生态：从测试覆盖率到并行执行，应有尽有
完美的兼容性：无缝运行unittest、nose等框架编写的测试用例

快速开始

安装Pytest

最基础的安装方式，一条命令即可：

bash 复制代码

pip install -U pytest

建议在虚拟环境中安装，避免依赖冲突：

bash 复制代码

# 创建虚拟环境
python -m venv pytest_env

# 激活虚拟环境 (Windows)
pytest_env\Scripts\activate

# 激活虚拟环境 (Mac/Linux)
source pytest_env/bin/activate

# 安装pytest
pip install pytest

验证安装是否成功：

bash 复制代码

pytest --version
# 输出示例: pytest 8.0.0

第一个测试用例

最简单的测试函数

创建一个名为test_calculator.py的文件：

python 复制代码

# test_calculator.py

def add(x, y):
    """加法函数"""
    return x + y

def test_add():
    """测试加法函数"""
    assert add(3, 5) == 8
    assert add(-1, 1) == 0
    assert add(0, 0) == 0

def test_add_negative():
    """测试负数相加"""
    assert add(-2, -3) == -5

运行测试：

bash 复制代码

pytest test_calculator.py -v

-v参数会输出更详细的信息，让你清楚看到哪些测试通过了，哪些失败了。

测试失败时的表现

故意写一个会失败的测试：

python 复制代码

def test_add_fail():
    assert add(2, 2) == 5  # 这个断言会失败

运行后会看到非常详细的错误信息：

复制代码

=================================== FAILURES ===================================
_______________________________ test_add_fail ________________________________

    def test_add_fail():
>       assert add(2, 2) == 5
E       assert 4 == 5
E        +  where 4 = add(2, 2)

test_calculator.py:16: AssertionError

Pytest会告诉你：

哪一行出错了（箭头>指向）
期望值和实际值是什么
函数调用链（where部分）

组织测试用例

使用测试类

当需要对同一个功能进行多方面测试时，可以将相关测试组织在同一个类中：

python 复制代码

# test_string_operations.py

class TestStringOperations:
    """字符串操作测试类"""
    
    def test_upper(self):
        """测试字符串大写转换"""
        assert "hello".upper() == "HELLO"
    
    def test_lower(self):
        """测试字符串小写转换"""
        assert "WORLD".lower() == "world"
    
    def test_contains(self):
        """测试字符串包含关系"""
        assert "h" in "hello"
        assert "x" not in "hello"
    
    def test_split(self):
        """测试字符串分割"""
        result = "a,b,c".split(",")
        assert result == ["a", "b", "c"]
        assert len(result) == 3

注意：测试类必须以Test开头，并且不能有__init__方法。

运行特定的测试

Pytest提供了灵活的运行方式：

bash 复制代码

# 运行所有测试
pytest

# 运行指定文件
pytest test_string_operations.py

# 运行指定类中的所有测试
pytest test_string_operations.py::TestStringOperations

# 运行类中的指定测试方法
pytest test_string_operations.py::TestStringOperations::test_upper

# 根据名称模式匹配（关键字表达式）
pytest -k "upper or lower"

# 根据标记运行
pytest -m "slow"  # 需要提前用@pytest.mark.slow标记

进阶特性

参数化测试

参数化是Pytest最强大的特性之一，避免编写重复代码：

python 复制代码

import pytest

def multiply(a, b):
    return a * b

@pytest.mark.parametrize("a, b, expected", [
    (2, 3, 6),
    (0, 5, 0),
    (-2, 3, -6),
    (2.5, 4, 10.0),
    (-3, -3, 9),
])
def test_multiply(a, b, expected):
    assert multiply(a, b) == expected

运行时会看到每个参数组合都被当作独立的测试用例：

复制代码

test_math.py::test_multiply[2-3-6] PASSED
test_math.py::test_multiply[0-5-0] PASSED
test_math.py::test_multiply[-2-3--6] PASSED
...

如果某个组合失败，其他组合仍会继续执行，并且错误信息会明确指出是哪个参数组合出了问题。

标记和跳过测试

在某些场景下，你可能需要跳过某些测试或标记它们为预期失败：

python 复制代码

import pytest
import sys

class TestConditional:
    
    @pytest.mark.skip(reason="尚未实现该功能")
    def test_not_implemented(self):
        assert 1 == 2
    
    @pytest.mark.skipif(
        sys.version_info < (3, 8),
        reason="需要Python 3.8或更高版本"
    )
    def test_python_version(self):
        assert sys.version_info >= (3, 8)
    
    @pytest.mark.xfail(reason="已知的边界情况问题")
    def test_known_issue(self):
        result = 1 / 0  # 预期会失败
        assert result == "anything"
    
    @pytest.mark.slow
    def test_slow_operation(self):
        """标记为慢速测试，可以用 -m "not slow" 跳过"""
        import time
        time.sleep(2)
        assert True

运行时的选项：

bash 复制代码

# 只运行普通测试，跳过慢速测试
pytest -m "not slow"

# 显示跳过和预期失败的原因
pytest -rsx

# -r 参数选项：s(跳过), x(预期失败), X(预期失败但实际成功)

Fixture：测试的前置和后置处理

Fixture是Pytest的精髓，它让测试数据的准备和清理变得异常优雅：

python 复制代码

import pytest
from datetime import datetime

@pytest.fixture
def sample_data():
    """创建测试数据，每个测试函数都会获得全新的实例"""
    return {"name": "Alice", "age": 30, "city": "Beijing"}

@pytest.fixture
def database_connection():
    """模拟数据库连接，测试完成后自动关闭"""
    print("\n[Setup] 创建数据库连接")
    connection = {"connected": True, "data": []}
    
    yield connection  # 测试函数在这里执行
    
    print("\n[Teardown] 关闭数据库连接")
    connection["connected"] = False

@pytest.fixture(scope="module")
def expensive_setup():
    """模块级别的fixture，整个模块只运行一次"""
    print("\n[Module Setup] 执行昂贵的一次性初始化")
    data = {"initialized": True}
    yield data
    print("\n[Module Teardown] 清理模块级资源")

class TestWithFixtures:
    
    def test_fixture_basic(self, sample_data):
        """使用fixture"""
        assert sample_data["name"] == "Alice"
        sample_data["age"] = 31  # 修改只影响当前测试
    
    def test_fixture_isolated(self, sample_data):
        """每个测试都有独立的fixture实例"""
        assert sample_data["age"] == 30  # 不受上一个测试影响
    
    def test_database(self, database_connection):
        """使用数据库fixture"""
        assert database_connection["connected"] is True
        database_connection["data"].append("test record")

Fixture的作用域：

function（默认）：每个测试函数执行一次
class：每个测试类执行一次
module：每个模块执行一次
session：整个测试会话执行一次

临时文件和目录

Pytest内置了tmp_path fixture，用于处理临时文件：

python 复制代码

def test_file_operations(tmp_path):
    """使用临时目录进行文件操作测试"""
    # tmp_path是pathlib.Path对象
    file_path = tmp_path / "test.txt"
    
    # 写入文件
    file_path.write_text("Hello, Pytest!")
    
    # 读取并验证
    content = file_path.read_text()
    assert content == "Hello, Pytest!"
    
    # 测试结束后，tmp_path会被自动清理

实战案例：测试一个用户管理系统

让我们通过一个完整的例子来展示Pytest的强大：

python 复制代码

# user_manager.py
class UserManager:
    def __init__(self):
        self.users = {}
    
    def add_user(self, user_id, name, email):
        if user_id in self.users:
            raise ValueError(f"用户 {user_id} 已存在")
        
        if not email or "@" not in email:
            raise ValueError("无效的邮箱地址")
        
        self.users[user_id] = {
            "id": user_id,
            "name": name,
            "email": email,
            "active": True
        }
        return True
    
    def get_user(self, user_id):
        return self.users.get(user_id)
    
    def deactivate_user(self, user_id):
        if user_id not in self.users:
            raise KeyError(f"用户 {user_id} 不存在")
        self.users[user_id]["active"] = False
    
    def get_active_users(self):
        return [u for u in self.users.values() if u["active"]]

# test_user_manager.py
import pytest
from user_manager import UserManager

@pytest.fixture
def user_manager():
    """每个测试都使用全新的UserManager实例"""
    manager = UserManager()
    
    # 添加一些测试数据
    manager.add_user(1, "Alice", "alice@example.com")
    manager.add_user(2, "Bob", "bob@example.com")
    
    return manager

@pytest.fixture
def empty_manager():
    """空的用户管理器"""
    return UserManager()

class TestUserManager:
    
    def test_add_user_success(self, empty_manager):
        """测试成功添加用户"""
        result = empty_manager.add_user(1, "Tom", "tom@example.com")
        assert result is True
        assert len(empty_manager.users) == 1
        assert empty_manager.users[1]["name"] == "Tom"
    
    @pytest.mark.parametrize("user_id, name, email, error_msg", [
        (1, "Alice", "alice@test.com", "用户 1 已存在"),
        (3, "Bob", "invalid-email", "无效的邮箱地址"),
        (3, "Charlie", "", "无效的邮箱地址"),
    ])
    def test_add_user_failures(self, user_manager, user_id, name, email, error_msg):
        """测试添加用户的失败情况（参数化）"""
        with pytest.raises(ValueError) as exc_info:
            user_manager.add_user(user_id, name, email)
        
        assert error_msg in str(exc_info.value)
    
    def test_get_user_exists(self, user_manager):
        """测试获取存在的用户"""
        user = user_manager.get_user(1)
        assert user is not None
        assert user["name"] == "Alice"
        assert user["email"] == "alice@example.com"
        assert user["active"] is True
    
    def test_get_user_not_exists(self, user_manager):
        """测试获取不存在的用户"""
        user = user_manager.get_user(999)
        assert user is None
    
    def test_deactivate_user(self, user_manager):
        """测试停用用户"""
        user_manager.deactivate_user(1)
        user = user_manager.get_user(1)
        assert user["active"] is False
    
    def test_deactivate_nonexistent_user(self, user_manager):
        """测试停用不存在的用户"""
        with pytest.raises(KeyError, match="用户 999 不存在"):
            user_manager.deactivate_user(999)
    
    def test_get_active_users(self, user_manager):
        """测试获取活跃用户列表"""
        # 初始状态：两个用户都活跃
        active = user_manager.get_active_users()
        assert len(active) == 2
        
        # 停用一个用户
        user_manager.deactivate_user(1)
        active = user_manager.get_active_users()
        assert len(active) == 1
        assert active[0]["id"] == 2

测试报告

快速概览报告

bash 复制代码

# 简洁模式（不显示详细信息）
pytest -q

# 详细模式（显示每个测试的结果）
pytest -v

# 显示最慢的10个测试
pytest --durations=10

生成HTML报告

首先安装插件：

bash 复制代码

pip install pytest-html

生成HTML报告：

bash 复制代码

pytest --html=report.html --self-contained-html

生成XML报告（用于CI/CD集成）

bash 复制代码

pytest --junitxml=test-results.xml

这个格式可以被Jenkins、GitLab CI、Azure DevOps等工具直接解析。

常用插件推荐

bash 复制代码

# 测试覆盖率
pip install pytest-cov

# 并行执行测试（加速）
pip install pytest-xdist

# 失败时自动重试
pip install pytest-rerunfailures

# 更漂亮的输出
pip install pytest-sugar

# 超时控制
pip install pytest-timeout

使用示例：

bash 复制代码

# 生成覆盖率报告
pytest --cov=myproject --cov-report=html

# 并行执行（使用4个CPU核心）
pytest -n 4

# 失败时自动重试2次
pytest --reruns 2

# 设置测试超时（5秒）
pytest --timeout=5

最佳实践总结

保持测试独立性：每个测试应该能够独立运行，不依赖其他测试的执行顺序
使用有意义的命名：测试函数名应该清晰表达测试的内容和预期行为
一个测试只测一个功能点：避免在一个测试函数中测试多个不相关的功能
利用fixture减少重复代码：共同的测试准备和清理工作都应该放在fixture中
参数化替代循环 ：需要测试多组数据时，使用@pytest.mark.parametrize而不是在测试中写循环
测试也应该保持简洁：如果测试代码变得复杂，说明需要重构了
在虚拟环境中运行：确保测试环境的一致性和隔离性

bash 复制代码

# 推荐的测试运行命令
pytest -v --tb=short --strict-markers --disable-warnings

Pytest的学习曲线非常平缓，但掌握它后，你的测试代码质量会有一个质的飞跃。开始在你的项目中使用Pytest吧，你会很快发现它的魅力所在！