pytest高级测试框架

Python进阶编程专题 · 掌握pytest的强大测试能力

专题：Python进阶编程系统学习

关键词：Python, pytest, fixture, conftest, parametrize, 测试框架, 钩子, 覆盖率

一、pytest概述与核心优势

pytest是Python生态中最流行、最强大的测试框架之一，以其简洁的语法、丰富的插件体系和强大的fixture机制深受开发者喜爱。与Python内置的unittest相比，pytest大幅减少了测试代码的样板（boilerplate），让开发者更专注于测试逻辑本身。

pytest的核心优势可以概括为六个方面：第一，简洁的断言语法，直接使用Python原生的assert语句，无需记忆self.assertEqual、self.assertTrue等API；第二，自动发现测试用例，无需手动注册，默认递归查找文件名匹配test_*.py或*_test.py的文件以及函数名以test_开头的函数；第三，强大的fixture机制，支持依赖注入和多种作用域管理；第四，丰富的插件生态，官方和社区提供了数百个插件；第五，参数化测试，用@pytest.mark.parametrize一行代码实现多组数据驱动；第六，与unittest完全兼容，可以增量迁移现有测试。

快速安装： 使用 pip install pytest 即可安装。运行测试时在项目根目录执行 pytest 命令，pytest会自动发现并执行所有测试。

# 最简单的pytest测试用例
# test_sample.py
def test_addition():
    assert 1 + 1 == 2

def test_string():
    assert "hello".upper() == "HELLO"

# 命令行运行: pytest test_sample.py -v
# 输出:
# test_sample.py::test_addition PASSED
# test_sample.py::test_string PASSED

二、快速入门与基础用法

pytest的测试执行流程非常直观。在项目目录下执行pytest命令，它会按照默认规则自动收集测试。默认收集规则包括：文件名以test_开头或以_test结尾的Python文件；文件内部以test_开头的函数；以Test开头的类中的test_开头的方法。注意，测试类不能包含__init__方法。

pytest提供了丰富的命令行选项。使用-v（verbose）输出详细测试结果；-k按名称筛选测试，如pytest -k "user or login"只运行名称包含user或login的测试；-x在第一个测试失败时立即停止；--maxfail=N在第N次失败时停止；-s允许在测试中输出print内容（默认捕获输出）；--tb=short缩短错误回溯信息；-q简洁输出模式。

# 测试类示例
# test_calc.py
class TestCalculator:
    def setup_method(self, method):
        self.numbers = [1, 2, 3, 4, 5]

    def test_sum(self):
        assert sum(self.numbers) == 15

    def test_max(self):
        assert max(self.numbers) == 5

    def test_min(self):
        assert min(self.numbers) == 1

# 指定运行单个测试类
# 命令: pytest test_calc.py::TestCalculator::test_sum -v

最佳实践：测试文件应放在项目根目录下的tests/目录中，与源代码保持分离。每个测试函数只测试一个关注点（single responsibility），测试函数命名应清晰描述测试场景和预期行为。

三、Fixture详解（作用域与自动使用）

fixture是pytest最核心的功能之一。它通过依赖注入的方式为测试函数提供固定的测试环境、数据或资源，替代了unittest中的setUp和tearDown方法。装饰器@pytest.fixture将一个函数标记为fixture，测试函数通过参数名引用fixture，pytest自动注入fixture的返回值。

Fixture作用域

fixture通过scope参数控制其生命周期，支持五种作用域。默认作用域是function，即每个测试函数都会重新创建fixture。class作用域让fixture在每个测试类中只创建一次，类的所有测试方法共享同一个fixture实例。module作用域让fixture在每个模块（即每个.py文件）中只创建一次。package作用域作用于整个包。session作用域在整次pytest运行中只创建一次，全局共享。

import pytest

# function作用域（默认）—— 每个测试函数都创建新实例
@pytest.fixture
def fresh_data():
    return {"count": 0}

# session作用域 —— 整个测试会话只创建一次
@pytest.fixture(scope="session")
def db_connection():
    # 创建数据库连接（仅一次）
    conn = create_expensive_connection()
    yield conn
    conn.close()  # 会话结束后清理

# module作用域 —— 每个测试模块只创建一次
@pytest.fixture(scope="module")
def config():
    return load_config_from_file()

def test_one(fresh_data):
    fresh_data["count"] += 1
    assert fresh_data["count"] == 1

def test_two(fresh_data):
    # 因为是function作用域，fresh_data是全新的
    assert fresh_data["count"] == 0

自动使用（autouse）

通过@pytest.fixture(autouse=True)可以将fixture设为自动使用，即无需在测试函数参数中显式声明，pytest会自动为每个符合条件的测试应用该fixture。这非常适合那些需要全局执行但又不想污染每个测试函数签名的场景，例如设置环境变量、创建临时目录、记录测试执行时间等。

import pytest
import time

@pytest.fixture(autouse=True)
def timing():
    """自动记录每个测试的执行时间"""
    start = time.time()
    yield
    elapsed = time.time() - start
    print(f"测试耗时: {elapsed:.4f}秒")

# autouse fixture无需在参数中引用
def test_slow_operation():
    data = [i**2 for i in range(10000)]
    assert len(data) == 10000

def test_fast_operation():
    assert sum(range(100)) == 4950

四、Fixture进阶（参数化与工厂模式）

除了基本用法外，fixture还支持参数化和工厂模式两种进阶用法，极大地提升了测试代码的复用性和灵活性。

Fixture参数化

使用@pytest.fixture(params=[...])可以对fixture进行参数化，fixture会依次使用params列表中的每个值执行，所有引用该fixture的测试也会相应地运行多次。pytest还提供了一个内置的request对象，在fixture函数中通过request.param获取当前参数值。

import pytest

@pytest.fixture(params=["mysql", "postgresql", "sqlite"])
def database(request):
    """参数化fixture：依次使用不同的数据库"""
    db = connect_to_db(request.param)
    yield db
    db.close()

def test_insert(database):
    # 该测试会对三种数据库各执行一次
    assert database.insert({"key": "value"}) is True

# 多组参数组合
@pytest.fixture(params=[(1024, 768), (1920, 1080), (375, 667)])
def screen_resolution(request):
    width, height = request.param
    return {"width": width, "height": height}

def test_layout(screen_resolution):
    assert screen_resolution["width"] > 0

工厂模式

工厂模式的fixture不直接返回数据，而是返回一个创建数据的函数。这样测试可以在需要时灵活地生成不同配置的数据，同时保持fixture的复用性。

import pytest

@pytest.fixture
def user_factory():
    """工厂模式fixture：返回创建用户的函数"""
    def _create_user(name, age=18, role="user"):
        return {
            "name": name,
            "age": age,
            "role": role,
            "active": True
        }
    return _create_user

def test_admin_user(user_factory):
    admin = user_factory("admin", role="admin")
    assert admin["role"] == "admin"
    assert admin["active"] is True

def test_underage_user(user_factory):
    teen = user_factory("teen", age=15)
    assert teen["age"] == 15

五、conftest.py分层配置

conftest.py是pytest的特殊配置文件，它的核心作用是跨文件共享fixture、钩子和插件配置。conftest.py的最大特点是作用域分层：放在项目根目录的conftest.py对整个项目可见；放在某个包或目录中的conftest.py仅对该目录及子目录中的测试文件可见。这种分层机制使得大型项目的fixture管理变得清晰有序。

# 项目结构示例
project/
  conftest.py           # 全局fixture（整个项目可见）
  tests/
    conftest.py         # 测试层fixture（tests/下所有测试可见）
    unit/
      conftest.py       # 单元测试专用fixture
      test_user.py
      test_product.py
    integration/
      conftest.py       # 集成测试专用fixture
      test_api.py
      test_database.py

conftest.py的搜索机制是自底向上的：当测试文件引用一个fixture时，pytest首先在同级目录的conftest.py中查找，然后逐级向上搜索父目录的conftest.py，直到项目根目录。同名的fixture遵循就近原则，子目录中的fixture会覆盖父目录的同名fixture。

# tests/conftest.py - 测试层通用fixture
import pytest

@pytest.fixture
def sample_data():
    return {"id": 1, "name": "test"}

@pytest.fixture(scope="session")
def base_url():
    return "http://localhost:8000/api"

# tests/unit/conftest.py - 单元测试专用fixture
import pytest

@pytest.fixture
def mock_db():
    """单元测试中模拟数据库"""
    class MockDB:
        def query(self, sql):
            return [{"id": 1, "name": "mock"}]
    return MockDB()

# unit/test_user.py 可以同时使用上两层conftest中的fixture
def test_get_user(sample_data, mock_db):
    result = mock_db.query("SELECT * FROM users")
    assert result[0]["name"] == "mock"

六、parametrize参数化测试

@pytest.mark.parametrize是pytest中最常用的装饰器之一，它允许用一组参数多次执行同一个测试函数，每个参数组合生成独立的测试用例。其基本语法是传入参数名（字符串，多个参数用逗号分隔）和参数值列表（每个元素是对应参数组的值）。

import pytest

# 单参数参数化
@pytest.mark.parametrize("input_value", [1, 2, 3, 4, 5])
def test_is_positive(input_value):
    assert input_value > 0

# 多参数参数化
@pytest.mark.parametrize("a, b, expected", [
    (1, 2, 3),
    (0, 0, 0),
    (-1, 1, 0),
    (100, 200, 300),
])
def test_add(a, b, expected):
    assert a + b == expected

# 参数组合（笛卡尔积）：先内层后外层
@pytest.mark.parametrize("username", ["alice", "bob"])
@pytest.mark.parametrize("role", ["admin", "user", "guest"])
def test_user_role(username, role):
    # 会生成 2 * 3 = 6 个测试用例
    assert isinstance(username, str)
    assert role in ["admin", "user", "guest"]

参数化测试中，每个用例都可以拥有自己的ID，便于在测试报告中识别。使用pytest.param可以为特定用例设置ID或标记。

import pytest

# 自定义测试用例ID
@pytest.mark.parametrize("text, expected", [
    ("hello", "HELLO"),
    pytest.param("world", "WORLD", id="upper-world"),
    pytest.param("pytest", "PYTEST", id="upper-pytest"),
])
def test_upper(text, expected):
    assert text.upper() == expected

# 参数化与fixture结合
@pytest.fixture
def multiplier():
    return 2

@pytest.mark.parametrize("value", [10, 20, 30])
def test_multiply(value, multiplier):
    assert value * multiplier == value * 2

# 从外部数据源加载参数
import json

def load_test_data():
    with open("test_data.json") as f:
        return json.load(f)

@pytest.mark.parametrize("input_data, expected", load_test_data())
def test_from_external_source(input_data, expected):
    assert process(input_data) == expected

性能提示：当参数组合数量很大时（如数百组），考虑使用@pytest.mark.parametrize结合indirect=True或使用外部数据文件动态生成参数，避免测试代码过于臃肿。也可以在命令行使用-k筛选特定ID的用例。

七、内置Fixture（tmpdir/capsys/monkeypatch/request）

pytest内置了多个开箱即用的fixture，这些fixture覆盖了测试中最常见的需求场景，无需额外安装任何插件。

tmpdir / tmp_path：临时目录

tmpdir提供临时目录fixture（基于py.path.local），tmp_path提供基于Python标准库pathlib.Path的临时目录。每个测试函数都会获得一个独立的临时目录，测试结束后自动清理。

import pytest

def test_file_operations(tmp_path):
    """测试文件读写操作"""
    data_dir = tmp_path / "data"
    data_dir.mkdir()
    file = data_dir / "config.json"
    file.write_text('{"key": "value"}')
    assert file.read_text() == '{"key": "value"}'
    assert file.stat().st_size > 0

def test_multiple_temp_dirs(tmpdir):
    """使用传统tmpdir"""
    d1 = tmpdir.mkdir("sub1")
    d2 = tmpdir.mkdir("sub2")
    f1 = d1.join("test.txt")
    f1.write("hello")
    assert f1.read() == "hello"

capsys：捕获标准输出

capsys用于捕获测试中产生的标准输出（stdout）和标准错误（stderr），非常适合测试打印输出或日志记录的逻辑。

import pytest

def greet(name):
    print(f"Hello, {name}!")
    return len(name)

def test_greet_output(capsys):
    greet("Alice")
    captured = capsys.readouterr()
    assert captured.out.strip() == "Hello, Alice!"
    assert captured.err == ""

def test_error_output(capsys):
    import sys
    print("error message", file=sys.stderr)
    captured = capsys.readouterr()
    assert "error" in captured.err

monkeypatch：动态修改对象

monkeypatch是pytest中最强大的内置fixture之一，用于临时修改对象属性、环境变量、字典或模块行为。它支持setattr、setenv、setitem、delattr、delenv、delitem等方法，所有修改在测试结束后自动还原。

import pytest
import os

def get_api_key():
    return os.environ.get("API_KEY", "default-key")

def test_api_key_from_env(monkeypatch):
    monkeypatch.setenv("API_KEY", "test-key-123")
    assert get_api_key() == "test-key-123"

def test_api_key_default(monkeypatch):
    monkeypatch.delenv("API_KEY", raising=False)
    assert get_api_key() == "default-key"

# mock函数和对象属性
import time

def test_time_sleep(monkeypatch):
    calls = []
    def fake_sleep(seconds):
        calls.append(seconds)
    monkeypatch.setattr(time, "sleep", fake_sleep)

    time.sleep(2)
    assert calls == [2]

# 模拟datetime
from datetime import datetime

def test_current_year(monkeypatch):
    class MockDatetime:
        @classmethod
        def now(cls):
            return datetime(2025, 1, 1)
    monkeypatch.setattr(datetime, "now", MockDatetime.now)
    assert datetime.now().year == 2025

request：获取测试上下文

request是pytest内置的fixture，提供对当前测试用例的完整上下文信息，包括测试函数名称、类名、模块、marker标记、fixture参数等。

import pytest

@pytest.fixture
def context(request):
    """打印当前测试的上下文信息"""
    print(f"\n测试函数: {request.function.__name__}")
    print(f"测试模块: {request.module.__name__}")
    print(f"测试节点ID: {request.node.nodeid}")
    return request

@pytest.mark.smoke
def test_with_context(context):
    assert context.function.__name__ == "test_with_context"

# 在fixture中根据调用者动态配置
@pytest.fixture
def dynamic_fixture(request):
    marker = request.node.get_closest_marker("db")
    if marker:
        db_type = marker.args[0]
        return connect_to(db_type)
    return connect_to("default")

@pytest.mark.db("postgresql")
def test_postgres(dynamic_fixture):
    assert dynamic_fixture.type == "postgresql"

八、钩子函数

pytest的钩子函数（Hook Functions）是其插件体系的基石。钩子函数允许开发者在pytest执行生命周期的特定节点插入自定义逻辑。所有钩子函数都定义在conftest.py或插件文件中，函数名以pytest_开头。

常用钩子函数详解

以下是几个最常用的钩子函数。第一个是pytest_configure(config)，在pytest解析命令行参数后、收集测试前调用，用于注册自定义标记、修改配置。第二个是pytest_collection_modifyitems(config, items)，在所有测试用例收集完成后调用，此时可以检查、修改、排序或过滤测试用例列表。第三个是pytest_runtest_setup(item)，在每个测试用例执行前调用，可用于动态跳过或标记测试。第四个是pytest_addoption(parser)，用于添加自定义命令行参数。

# conftest.py - 钩子函数综合示例
import pytest

def pytest_configure(config):
    """注册自定义标记，避免pytest发出warnings"""
    config.addinivalue_line("markers", "slow: 慢速测试，默认跳过")
    config.addinivalue_line("markers", "smoke: 冒烟测试，快速检查核心功能")
    config.addinivalue_line("markers", "db: 需要数据库连接的测试")

def pytest_addoption(parser):
    """添加自定义命令行参数"""
    parser.addoption(
        "--env",
        action="store",
        default="test",
        choices=["test", "staging", "production"],
        help="指定测试环境: test, staging 或 production"
    )

def pytest_collection_modifyitems(config, items):
    """收集测试后按名称排序，并根据--env过滤"""
    # 按测试名称排序
    items.sort(key=lambda x: x.name)

    # 根据自定义参数跳过标记
    env = config.getoption("--env")
    if env != "production":
        skip_prod = pytest.mark.skip(reason="非生产环境不执行")
        for item in items:
            if "production_only" in item.keywords:
                item.add_marker(skip_prod)

    # 添加自定义属性，方便后续处理
    for item in items:
        item._test_env = env

def pytest_runtest_setup(item):
    """检查测试是否标记为slow且未指定--runslow"""
    if "slow" in item.keywords:
        if not item.config.getoption("--runslow", False):
            pytest.skip("需要 --runslow 选项来运行此测试")

# 结合自定义命令行参数
# conftest.py 中定义的 --env 选项
@pytest.fixture
def env(request):
    return request.config.getoption("--env")

def test_environment(env):
    # 通过 --env 参数控制测试行为
    base_urls = {
        "test": "http://test.api.com",
        "staging": "http://staging.api.com",
        "production": "https://api.com",
    }
    assert base_urls[env].startswith("http")

# 命令行: pytest --env=staging test_env.py

九、自定义标记Mark

pytest的标记（mark）机制允许给测试用例附加元数据，进而实现条件跳过、预期失败、分组执行等功能。标记通过@pytest.mark.xxx装饰器应用，多个标记可以叠加使用。自定义标记需要先在pytest_configure钩子中注册，避免pytest发出PytestUnknownMarkWarning。

内置标记详解

pytest提供了多个内置标记。@pytest.mark.skip无条件跳过测试，@pytest.mark.skipif在条件满足时跳过测试。@pytest.mark.xfail标记预期失败的测试，如果实际执行失败则显示xfail（预期失败），如果意外通过则显示xpass（意外通过），可以通过strict=True将xpass视为失败。@pytest.mark.filterwarnings为特定测试添加警告过滤器。

import pytest
import sys

# 条件跳过
@pytest.mark.skipif(sys.version_info < (3, 8), reason="需要Python 3.8+")
def test_walrus_operator():
    # Python 3.8+ 的海象运算符
    assert (n := len("hello")) == 5

# 预期失败
@pytest.mark.xfail(reason="已知问题 #1234，将在下一版本修复")
def test_known_bug():
    assert 1 / 0  # ZeroDivisionError

# strict模式：意外通过视为失败
@pytest.mark.xfail(strict=True, reason="预期失败但应该修复")
def test_regression():
    # 如果这个测试通过了，会在报告中标记为FAILED
    assert False

# 自定义标记 + 按标记运行
@pytest.mark.smoke
def test_login():
    assert login("admin", "pass") is True

@pytest.mark.smoke
@pytest.mark.slow
def test_full_database_query():
    assert query_database() is not None

# 命令行运行冒烟测试: pytest -m smoke
# 排除慢速测试: pytest -m "smoke and not slow"

标记的组合筛选非常灵活。使用pytest -m "mark1 and mark2"运行同时拥有两个标记的测试；pytest -m "mark1 or mark2"运行拥有任一标记的测试；pytest -m "not mark1"运行不包含mark1的测试。还可以通过--markers命令查看所有已注册的标记及其说明。

十、插件体系

pytest的插件生态是其成功的关键因素之一。插件的本质就是包含钩子函数的Python模块或包。pytest的插件加载有三种方式：第一，通过pip install安装第三方插件后自动生效；第二，将插件代码放在conftest.py中；第三，在pytest.ini或pyproject.toml的[tool.pytest.ini_options]中通过plugins字段显式注册。

常用第三方插件

以下是生产环境中不可或缺的pytest插件。pytest-cov是最流行的覆盖率插件，与coverage.py深度集成，支持HTML和XML格式的覆盖率报告。pytest-xdist支持多CPU并行执行测试，通过-n auto自动利用所有CPU核心。pytest-mock对unittest.mock做了封装，提供了更简洁的mockerfixture。pytest-timeout为测试设置超时时间，防止测试卡死影响CI流水线。pytest-html生成美观的HTML格式测试报告。pytest-sugar让测试输出更美观，并显示实时进度条。

# 安装常用插件
# pip install pytest-cov pytest-xdist pytest-mock pytest-timeout pytest-html

# pytest.ini 配置
"""
[pytest]
addopts = -v --tb=short --strict-markers
testpaths = tests
python_files = test_*.py
markers =
    slow: 慢速测试
    smoke: 冒烟测试
"""

# pyproject.toml 配置（现代方式）
"""
[tool.pytest.ini_options]
addopts = ["-v", "--tb=short", "--strict-markers", "--cov=src", "--cov-report=html"]
testpaths = ["tests"]
python_files = ["test_*.py"]
markers = { slow = "慢速测试", smoke = "冒烟测试" }
"""

# 使用pytest-mock编写mock测试
def test_external_api(mocker):
    mock_response = {"status": "ok", "data": [1, 2, 3]}
    mocker.patch("requests.get", return_value=mock_response)
    result = call_external_api()
    assert result["status"] == "ok"

# pytest-xdist并行执行
# 命令: pytest -n auto  # 自动使用所有CPU核心
# 命令: pytest -n 4      # 使用4个并行worker

插件开发入门：创建一个pytest_xxx.py文件，在其中实现以pytest_开头的钩子函数即可。例如，pytest_report_header可以添加自定义头部信息，pytest_terminal_summary可以在测试报告末尾添加自定义摘要。插件发布后可通过pip安装，命名规范为pytest-xxx。

十一、pytest与unittest兼容

pytest对Python标准库unittest有极佳的兼容性。pytest可以自动发现和运行unittest编写的测试用例，这意味着团队可以逐步将unittest测试迁移到pytest，而无需一次性重写所有代码。pytest通过pytest_unittest插件（内置于pytest中）实现兼容支持。

在兼容模式下，unittest的setUp、tearDown、setUpClass、tearDownClass等生命周期方法依然有效。assertEqual、assertTrue等断言方法也可以继续使用。同时，pytest的大部分功能也能在unittest测试类中工作，包括fixture注入和参数化。

import unittest
import pytest

class TestLegacy(unittest.TestCase):
    """传统的unittest风格的测试类"""

    @classmethod
    def setUpClass(cls):
        cls.shared_data = [1, 2, 3]

    def setUp(self):
        self.value = 42

    def test_addition(self):
        self.assertEqual(1 + 1, 2)

    def test_shared_data(self):
        self.assertIn(2, self.shared_data)

    # pytest的fixture也可以在unittest TestCase中使用
    @pytest.fixture(autouse=True)
    def inject_tmpdir(self, tmp_path):
        self.tmp_dir = tmp_path

    def test_with_tmpdir(self):
        """使用pytest的tmp_path fixture"""
        f = self.tmp_dir / "hello.txt"
        f.write_text("pytest兼容unittest")
        self.assertTrue(f.exists())

# 混用pytest和unittest风格
class TestHybrid(unittest.TestCase):
    def setUp(self):
        self.data = {"a": 1, "b": 2}

    def test_pytest_assert(self):
        # 可以使用pytest风格的assert
        assert self.data["a"] == 1

    def test_unittest_assert(self):
        # 也可以使用unittest风格的断言
        self.assertDictEqual(self.data, {"a": 1, "b": 2})

# 使用pytest参数化在unittest测试上
@pytest.mark.parametrize("value, expected", [
    (2, 4), (3, 9), (4, 16)
])
def test_squares(value, expected):
    assert value ** 2 == expected

迁移建议：推荐在unittest测试类中使用pytest.fixture(autouse=True)的方式逐步引入pytest功能，而无需改变测试类的继承结构。新测试建议直接使用纯pytest风格编写，这样可以充分利用fixture、参数化等高级功能。

十二、测试覆盖率（pytest-cov）

测试覆盖率是衡量测试质量的量化指标之一。pytest-cov插件将pytest与coverage.py无缝集成，让开发者在运行测试的同时收集覆盖率数据。覆盖率通常包括四种粒度：行覆盖率（statement coverage）、分支覆盖率（branch coverage）、函数覆盖率（function coverage）和路径覆盖率（path coverage），其中行覆盖率是最常用的指标。

pytest-cov的核心用法是在pytest命令中添加参数。使用--cov=src指定要检测覆盖率的源代码目录；--cov-report=term在终端输出覆盖率摘要；--cov-report=html生成详细的HTML覆盖率报告；--cov-report=xml生成XML格式报告，便于集成到CI/CD系统。多个--cov-report可以同时使用。

# 安装
# pip install pytest-cov

# 命令示例
# pytest --cov=src --cov-report=term --cov-report=html tests/

# 输出示例:
"""
----------- coverage: platform win32, python 3.12 -----------
Name                 Stmts   Miss  Cover
----------------------------------------
src/calculator.py       20      0   100%
src/user_service.py     45      5    89%
src/utils.py            30      3    90%
----------------------------------------
TOTAL                   95      8    92%
"""

# HTML报告会在项目根目录生成 coverage_html_report/ 目录

# .coveragerc 配置
"""
[run]
source = src
omit = */tests/*,*/migrations/*

[report]
exclude_lines =
    pragma: no cover
    def __repr__
    raise NotImplementedError
    if __name__ == "__main__":
    pass

fail_under = 80  # 覆盖率低于80%视为失败
"""

# 在pyproject.toml中配置pytest-cov
"""
[tool.pytest.ini_options]
addopts = [
    "--cov=src",
    "--cov-report=term-missing",  # 显示缺失行号
    "--cov-report=html",
    "--cov-fail-under=80",        # 覆盖率低于80%退出码非0
]
"""

# 在CI流水线中强制执行覆盖率门槛
# 如果覆盖率低于设定值，pytest会以非零退出码退出，导致CI任务失败

注意事项：覆盖率数据只反映代码被执行过，不代表代码的正确性。100%覆盖率并不意味着没有bug。覆盖率应作为质量保障的参考指标之一，而非唯一标准。建议将覆盖率门槛设定在80%左右，同时对核心业务逻辑要求更高覆盖。

十三、断言内省机制

pytest最令人赞叹的特性之一是其断言内省（assertion introspection）机制。当assert语句失败时，pytest不仅报告断言失败，还会通过AST重写技术（assert rewriting）智能分析断言表达式的每个子表达式的值，生成详细的失败信息，帮助开发者快速定位问题根源。

与Python原生的assert相比，pytest增强后的断言信息丰富得多。对于简单的等式比较，pytest会显示实际值、期望值和差值。对于容器类型（列表、字典、集合）的比较，pytest会高亮显示不匹配的元素。对于更复杂的表达式，pytest会递归分解并显示每个中间结果的值。

# 示例1: 等式比较失败
def test_equality():
    expected = {"name": "Alice", "age": 30, "city": "New York"}
    actual = {"name": "Alice", "age": 25, "city": "Beijing"}
    assert actual == expected

# 失败信息会显示:
# AssertionError:
#   Left contains 2 mismatches:
#   age: 25 != 30
#   city: 'Beijing' != 'New York'

# 示例2: 容器包含关系
def test_contains():
    actual = [1, 2, 3, 4, 5]
    assert 6 in actual

# 失败信息:
# assert 6 in [1, 2, 3, 4, 5]

# 示例3: 复杂表达式
def test_complex():
    x, y = 5, 10
    assert x * y == 100

# 失败信息:
# assert (5 * 10) == 100
# assert 50 == 100

断言内省的底层机制是AST重写（Assertion Rewriting）。pytest在导入测试模块时，会分析其AST（抽象语法树），将所有的assert语句重写为包含增强内省信息的函数调用。这也是为什么pytest需要在启动时导入测试模块的原因——重写发生在导入阶段。为了确保自定义插件也能受益于断言重写，插件模块需要调用pytest.register_assert_rewrite。

# 自定义断言帮助函数的断言重写
# 在 conftest.py 或插件 __init__.py 中注册
import pytest

# 注册自定义模块以支持断言重写
pytest.register_assert_rewrite("tests.helpers")

# 现在 tests/helpers.py 中的 assert 语句也会获得内省增强
# tests/helpers.py
def assert_user_valid(user):
    assert user.age >= 0, "年龄不能为负数"
    assert user.name.strip(), "用户名不能为空"
    assert "@" in user.email, "邮箱格式无效"

# 测试用例中使用自定义断言
def test_user_validation():
    from tests.helpers import assert_user_valid
    user = User(name="", age=-1, email="invalid")
    assert_user_valid(user)
    # pytest会显示每个子断言的详细信息

十四、核心要点总结

Fixtures：pytest的依赖注入核心，支持function/class/module/package/session五种作用域，autouse实现自动注入，params实现参数化，工厂模式提供灵活的数据创建。
conftest.py分层：按目录层级组织fixture和钩子，子目录覆盖父目录同名fixture，实现大型项目的清晰管理。
参数化测试：@pytest.mark.parametrize支持单参数和多参数组合，与fixture灵活配合，可自定义用例ID便于识别。
内置fixture：tmpdir/tmp_path管理临时文件，capsys捕获输出，monkeypatch动态修改环境，request获取测试上下文。
钩子函数：pytest_configure注册标记，pytest_collection_modifyitems过滤排序，pytest_addoption添加命令行参数，pytest_runtest_setup动态跳过。
自定义标记：skip/skipif条件跳过，xfail预期失败，-m选项灵活筛选组合，先注册后使用避免警告。
插件体系：pytest-cov覆盖率，pytest-xdist并行执行，pytest-mock简化mock，pytest-timeout超时控制，插件开发本质是编写钩子函数。
unittest兼容：pytest可直接运行unittest测试，支持在TestCase中注入pytest fixture，推荐增量迁移策略。
断言内省：通过AST重写技术提供详尽的断言失败信息，自动分解复杂表达式并显示子表达式值，大幅提升调试效率。

pytest推荐用法

纯pytest函数式测试
fixture显式声明依赖
参数化替代数据循环
conftest.py分层管理
插件增强功能

需要避免的用法

过度依赖unittest.TestCase
fixture作用域过大
在测试之间共享可变状态
conftest.py过于臃肿
忽略断言内省写自定义断言

十五、进一步思考

掌握pytest的高级特性后，测试策略的设计就成为了关键。在实际项目中，应该根据测试类型选择不同的策略：单元测试注重函数级别的输入输出验证，使用fixture模拟外部依赖；集成测试关注模块间的交互，使用conftest.py组织分层fixture；端到端测试覆盖完整业务流程，通常配合pytest-base-url和pytest-selenium等插件使用。

测试金字塔模型依然适用于pytest项目：底层是大量快速运行的单元测试（占70%），中间层是较慢的集成测试（占20%），顶层是少量端到端测试（占10%）。利用pytest的自定义标记（@pytest.mark.unit、@pytest.mark.integration、@pytest.mark.e2e）可以方便地分层运行不同粒度的测试。

在CI/CD流水线中，pytest的集成尤为重要。建议的配置策略包括：在提交阶段快速运行冒烟测试（pytest -m smoke -x），在PR阶段运行完整单元测试并报告覆盖率（pytest --cov=src --cov-fail-under=80），在合并到主干后并行运行所有测试（pytest -n auto）。通过junitxml报告格式（pytest --junitxml=report.xml）可以集成到Jenkins、GitLab CI等平台。

最后，值得深入研究的进阶方向包括：使用pytest-benchmark进行性能基准测试，确保代码修改不引入性能退化；使用pytest-asyncio测试异步代码；编写自定义pytest插件并发布到PyPI，为团队贡献可复用的测试工具；深入理解pytest的fixture解析算法（依赖图拓扑排序），编写更高效的fixture链。