python-testing

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Python Testing Patterns

Python测试模式

Comprehensive testing strategies for Python applications using pytest, TDD methodology, and best practices.

使用pytest、TDD方法论和最佳实践的Python应用程序综合测试策略。

When to Activate

适用场景

Writing new Python code (follow TDD: red, green, refactor)
Designing test suites for Python projects
Reviewing Python test coverage
Setting up testing infrastructure

编写新的Python代码（遵循TDD：红-绿-重构流程）
为Python项目设计测试套件
检查Python测试覆盖率
搭建测试基础设施

Core Testing Philosophy

核心测试理念

Test-Driven Development (TDD)

测试驱动开发（TDD）

Always follow the TDD cycle:

RED: Write a failing test for the desired behavior
GREEN: Write minimal code to make the test pass
REFACTOR: Improve code while keeping tests green

python

undefined

始终遵循TDD循环：

RED（红）：为期望的行为编写失败的测试
GREEN（绿）：编写最少的代码使测试通过
REFACTOR（重构）：在保持测试通过的同时改进代码

python

undefined

Step 1: Write failing test (RED)

步骤1：编写失败的测试（RED阶段）

def test_add_numbers(): result = add(2, 3) assert result == 5

Step 2: Write minimal implementation (GREEN)

步骤2：编写最简实现（GREEN阶段）

def add(a, b): return a + b

Step 3: Refactor if needed (REFACTOR)

步骤3：按需重构（REFACTOR阶段）

undefined

undefined

Coverage Requirements

覆盖率要求

Target: 80%+ code coverage
Critical paths: 100% coverage required
Use
```
pytest --cov
```
to measure coverage

bash

pytest --cov=mypackage --cov-report=term-missing --cov-report=html

目标：80%+的代码覆盖率
关键路径：要求100%覆盖率
使用
```
pytest --cov
```
测量覆盖率

bash

pytest --cov=mypackage --cov-report=term-missing --cov-report=html

pytest Fundamentals

pytest基础

Basic Test Structure

基本测试结构

python

import pytest

def test_addition():
    """Test basic addition."""
    assert 2 + 2 == 4

def test_string_uppercase():
    """Test string uppercasing."""
    text = "hello"
    assert text.upper() == "HELLO"

def test_list_append():
    """Test list append."""
    items = [1, 2, 3]
    items.append(4)
    assert 4 in items
    assert len(items) == 4

python

import pytest

def test_addition():
    """测试基本加法运算。"""
    assert 2 + 2 == 4

def test_string_uppercase():
    """测试字符串转大写。"""
    text = "hello"
    assert text.upper() == "HELLO"

def test_list_append():
    """测试列表追加操作。"""
    items = [1, 2, 3]
    items.append(4)
    assert 4 in items
    assert len(items) == 4

Assertions

断言用法

python

undefined

python

undefined

Equality

相等断言

assert result == expected

Inequality

不等断言

assert result != unexpected

Truthiness

真假断言

assert result # Truthy assert not result # Falsy assert result is True # Exactly True assert result is False # Exactly False assert result is None # Exactly None

assert result # 真值 assert not result # 假值 assert result is True # 严格为True assert result is False # 严格为False assert result is None # 严格为None

Membership

成员断言

assert item in collection assert item not in collection

Comparisons

比较断言

assert result > 0 assert 0 <= result <= 100

Type checking

类型检查

assert isinstance(result, str)

Exception testing (preferred approach)

异常测试（推荐方式）

with pytest.raises(ValueError): raise ValueError("error message")

Check exception message

检查异常消息

with pytest.raises(ValueError, match="invalid input"): raise ValueError("invalid input provided")

Check exception attributes

检查异常属性

with pytest.raises(ValueError) as exc_info: raise ValueError("error message") assert str(exc_info.value) == "error message"

undefined

with pytest.raises(ValueError) as exc_info: raise ValueError("error message") assert str(exc_info.value) == "error message"

undefined

Fixtures

Basic Fixture Usage

基础Fixture用法

python

import pytest

@pytest.fixture
def sample_data():
    """Fixture providing sample data."""
    return {"name": "Alice", "age": 30}

def test_sample_data(sample_data):
    """Test using the fixture."""
    assert sample_data["name"] == "Alice"
    assert sample_data["age"] == 30

python

import pytest

@pytest.fixture
def sample_data():
    """提供示例数据的Fixture。"""
    return {"name": "Alice", "age": 30}

def test_sample_data(sample_data):
    """使用Fixture的测试。"""
    assert sample_data["name"] == "Alice"
    assert sample_data["age"] == 30

Fixture with Setup/Teardown

包含初始化/清理的Fixture

python

@pytest.fixture
def database():
    """Fixture with setup and teardown."""
    # Setup
    db = Database(":memory:")
    db.create_tables()
    db.insert_test_data()

    yield db  # Provide to test

    # Teardown
    db.close()

def test_database_query(database):
    """Test database operations."""
    result = database.query("SELECT * FROM users")
    assert len(result) > 0

python

@pytest.fixture
def database():
    """包含初始化和清理的Fixture。"""
    # 初始化
    db = Database(":memory:")
    db.create_tables()
    db.insert_test_data()

    yield db  # 提供给测试使用

    # 清理
    db.close()

def test_database_query(database):
    """测试数据库操作。"""
    result = database.query("SELECT * FROM users")
    assert len(result) > 0

Fixture Scopes

Fixture作用域

python

undefined

python

undefined

Function scope (default) - runs for each test

函数作用域（默认）- 每个测试运行一次

@pytest.fixture def temp_file(): with open("temp.txt", "w") as f: yield f os.remove("temp.txt")

Module scope - runs once per module

模块作用域 - 每个模块运行一次

@pytest.fixture(scope="module") def module_db(): db = Database(":memory:") db.create_tables() yield db db.close()

Session scope - runs once per test session

会话作用域 - 整个测试会话运行一次

@pytest.fixture(scope="session") def shared_resource(): resource = ExpensiveResource() yield resource resource.cleanup()

undefined

@pytest.fixture(scope="session") def shared_resource(): resource = ExpensiveResource() yield resource resource.cleanup()

undefined

Fixture with Parameters

参数化Fixture

python

@pytest.fixture(params=[1, 2, 3])
def number(request):
    """Parameterized fixture."""
    return request.param

def test_numbers(number):
    """Test runs 3 times, once for each parameter."""
    assert number > 0

python

@pytest.fixture(params=[1, 2, 3])
def number(request):
    """参数化的Fixture。"""
    return request.param

def test_numbers(number):
    """测试会运行3次，每次使用一个参数。"""
    assert number > 0

Using Multiple Fixtures

使用多个Fixture

python

@pytest.fixture
def user():
    return User(id=1, name="Alice")

@pytest.fixture
def admin():
    return User(id=2, name="Admin", role="admin")

def test_user_admin_interaction(user, admin):
    """Test using multiple fixtures."""
    assert admin.can_manage(user)

python

@pytest.fixture
def user():
    return User(id=1, name="Alice")

@pytest.fixture
def admin():
    return User(id=2, name="Admin", role="admin")

def test_user_admin_interaction(user, admin):
    """使用多个Fixture的测试。"""
    assert admin.can_manage(user)

Autouse Fixtures

自动启用的Fixture

python

@pytest.fixture(autouse=True)
def reset_config():
    """Automatically runs before every test."""
    Config.reset()
    yield
    Config.cleanup()

def test_without_fixture_call():
    # reset_config runs automatically
    assert Config.get_setting("debug") is False

python

@pytest.fixture(autouse=True)
def reset_config():
    """自动在每个测试前运行。"""
    Config.reset()
    yield
    Config.cleanup()

def test_without_fixture_call():
    # reset_config会自动运行
    assert Config.get_setting("debug") is False

Conftest.py for Shared Fixtures

用Conftest.py共享Fixture

python

undefined

python

undefined

tests/conftest.py

import pytest

@pytest.fixture def client(): """Shared fixture for all tests.""" app = create_app(testing=True) with app.test_client() as client: yield client

@pytest.fixture def auth_headers(client): """Generate auth headers for API testing.""" response = client.post("/api/login", json={ "username": "test", "password": "test" }) token = response.json["token"] return {"Authorization": f"Bearer {token}"}

undefined

import pytest

@pytest.fixture def client(): """所有测试共享的Fixture。""" app = create_app(testing=True) with app.test_client() as client: yield client

@pytest.fixture def auth_headers(client): """为API测试生成认证头。""" response = client.post("/api/login", json={ "username": "test", "password": "test" }) token = response.json["token"] return {"Authorization": f"Bearer {token}"}

undefined

Parametrization

参数化

Basic Parametrization

基础参数化

python

@pytest.mark.parametrize("input,expected", [
    ("hello", "HELLO"),
    ("world", "WORLD"),
    ("PyThOn", "PYTHON"),
])
def test_uppercase(input, expected):
    """Test runs 3 times with different inputs."""
    assert input.upper() == expected

python

@pytest.mark.parametrize("input,expected", [
    ("hello", "HELLO"),
    ("world", "WORLD"),
    ("PyThOn", "PYTHON"),
])
def test_uppercase(input, expected):
    """测试会运行3次，使用不同的输入。"""
    assert input.upper() == expected

Multiple Parameters

多参数参数化

python

@pytest.mark.parametrize("a,b,expected", [
    (2, 3, 5),
    (0, 0, 0),
    (-1, 1, 0),
    (100, 200, 300),
])
def test_add(a, b, expected):
    """Test addition with multiple inputs."""
    assert add(a, b) == expected

python

@pytest.mark.parametrize("a,b,expected", [
    (2, 3, 5),
    (0, 0, 0),
    (-1, 1, 0),
    (100, 200, 300),
])
def test_add(a, b, expected):
    """使用多输入测试加法。"""
    assert add(a, b) == expected

Parametrize with IDs

带ID的参数化

python

@pytest.mark.parametrize("input,expected", [
    ("valid@email.com", True),
    ("invalid", False),
    ("@no-domain.com", False),
], ids=["valid-email", "missing-at", "missing-domain"])
def test_email_validation(input, expected):
    """Test email validation with readable test IDs."""
    assert is_valid_email(input) is expected

python

@pytest.mark.parametrize("input,expected", [
    ("valid@email.com", True),
    ("invalid", False),
    ("@no-domain.com", False),
], ids=["有效邮箱", "缺少@符号", "缺少域名"])
def test_email_validation(input, expected):
    """使用易读测试ID的邮箱验证测试。"""
    assert is_valid_email(input) is expected

Parametrized Fixtures

参数化Fixture

python

@pytest.fixture(params=["sqlite", "postgresql", "mysql"])
def db(request):
    """Test against multiple database backends."""
    if request.param == "sqlite":
        return Database(":memory:")
    elif request.param == "postgresql":
        return Database("postgresql://localhost/test")
    elif request.param == "mysql":
        return Database("mysql://localhost/test")

def test_database_operations(db):
    """Test runs 3 times, once for each database."""
    result = db.query("SELECT 1")
    assert result is not None

python

@pytest.fixture(params=["sqlite", "postgresql", "mysql"])
def db(request):
    """针对多种数据库后端进行测试。"""
    if request.param == "sqlite":
        return Database(":memory:")
    elif request.param == "postgresql":
        return Database("postgresql://localhost/test")
    elif request.param == "mysql":
        return Database("mysql://localhost/test")

def test_database_operations(db):
    """测试会运行3次，每次使用一种数据库。"""
    result = db.query("SELECT 1")
    assert result is not None

Markers and Test Selection

标记与测试选择

Custom Markers

自定义标记

python

undefined

python

undefined

Mark slow tests

标记慢测试

@pytest.mark.slow def test_slow_operation(): time.sleep(5)

Mark integration tests

标记集成测试

@pytest.mark.integration def test_api_integration(): response = requests.get("https://api.example.com") assert response.status_code == 200

Mark unit tests

标记单元测试

@pytest.mark.unit def test_unit_logic(): assert calculate(2, 3) == 5

undefined

@pytest.mark.unit def test_unit_logic(): assert calculate(2, 3) == 5

undefined

Run Specific Tests

运行特定测试

bash

undefined

bash

undefined

Run only fast tests

仅运行快速测试

pytest -m "not slow"

Run only integration tests

仅运行集成测试

pytest -m integration

Run integration or slow tests

运行集成测试或慢测试

pytest -m "integration or slow"

Run tests marked as unit but not slow

运行标记为unit但不是slow的测试

pytest -m "unit and not slow"

undefined

pytest -m "unit and not slow"

undefined

Configure Markers in pytest.ini

在pytest.ini中配置标记

ini

[pytest]
markers =
    slow: marks tests as slow
    integration: marks tests as integration tests
    unit: marks tests as unit tests
    django: marks tests as requiring Django

ini

[pytest]
markers =
    slow: 标记为慢测试
    integration: 标记为集成测试
    unit: 标记为单元测试
    django: 标记为需要Django的测试

Mocking and Patching

Mock与补丁

Mocking Functions

Mock函数

python

from unittest.mock import patch, Mock

@patch("mypackage.external_api_call")
def test_with_mock(api_call_mock):
    """Test with mocked external API."""
    api_call_mock.return_value = {"status": "success"}

    result = my_function()

    api_call_mock.assert_called_once()
    assert result["status"] == "success"

python

from unittest.mock import patch, Mock

@patch("mypackage.external_api_call")
def test_with_mock(api_call_mock):
    """使用Mock外部API的测试。"""
    api_call_mock.return_value = {"status": "success"}

    result = my_function()

    api_call_mock.assert_called_once()
    assert result["status"] == "success"

Mocking Return Values

Mock返回值

python

@patch("mypackage.Database.connect")
def test_database_connection(connect_mock):
    """Test with mocked database connection."""
    connect_mock.return_value = MockConnection()

    db = Database()
    db.connect()

    connect_mock.assert_called_once_with("localhost")

python

@patch("mypackage.Database.connect")
def test_database_connection(connect_mock):
    """使用Mock数据库连接的测试。"""
    connect_mock.return_value = MockConnection()

    db = Database()
    db.connect()

    connect_mock.assert_called_once_with("localhost")

Mocking Exceptions

Mock异常

python

@patch("mypackage.api_call")
def test_api_error_handling(api_call_mock):
    """Test error handling with mocked exception."""
    api_call_mock.side_effect = ConnectionError("Network error")

    with pytest.raises(ConnectionError):
        api_call()

    api_call_mock.assert_called_once()

python

@patch("mypackage.api_call")
def test_api_error_handling(api_call_mock):
    """使用Mock异常的错误处理测试。"""
    api_call_mock.side_effect = ConnectionError("Network error")

    with pytest.raises(ConnectionError):
        api_call()

    api_call_mock.assert_called_once()

Mocking Context Managers

Mock上下文管理器

python

@patch("builtins.open", new_callable=mock_open)
def test_file_reading(mock_file):
    """Test file reading with mocked open."""
    mock_file.return_value.read.return_value = "file content"

    result = read_file("test.txt")

    mock_file.assert_called_once_with("test.txt", "r")
    assert result == "file content"

python

@patch("builtins.open", new_callable=mock_open)
def test_file_reading(mock_file):
    """使用Mock open的文件读取测试。"""
    mock_file.return_value.read.return_value = "file content"

    result = read_file("test.txt")

    mock_file.assert_called_once_with("test.txt", "r")
    assert result == "file content"

Using Autospec

使用Autospec

python

@patch("mypackage.DBConnection", autospec=True)
def test_autospec(db_mock):
    """Test with autospec to catch API misuse."""
    db = db_mock.return_value
    db.query("SELECT * FROM users")

    # This would fail if DBConnection doesn't have query method
    db_mock.assert_called_once()

python

@patch("mypackage.DBConnection", autospec=True)
def test_autospec(db_mock):
    """使用autospec捕获API误用的测试。"""
    db = db_mock.return_value
    db.query("SELECT * FROM users")

    # 如果DBConnection没有query方法，这里会失败
    db_mock.assert_called_once()

Mock Class Instances

Mock类实例

python

class TestUserService:
    @patch("mypackage.UserRepository")
    def test_create_user(self, repo_mock):
        """Test user creation with mocked repository."""
        repo_mock.return_value.save.return_value = User(id=1, name="Alice")

        service = UserService(repo_mock.return_value)
        user = service.create_user(name="Alice")

        assert user.name == "Alice"
        repo_mock.return_value.save.assert_called_once()

python

class TestUserService:
    @patch("mypackage.UserRepository")
    def test_create_user(self, repo_mock):
        """使用Mock仓库的用户创建测试。"""
        repo_mock.return_value.save.return_value = User(id=1, name="Alice")

        service = UserService(repo_mock.return_value)
        user = service.create_user(name="Alice")

        assert user.name == "Alice"
        repo_mock.return_value.save.assert_called_once()

Mock Property

Mock属性

python

@pytest.fixture
def mock_config():
    """Create a mock with a property."""
    config = Mock()
    type(config).debug = PropertyMock(return_value=True)
    type(config).api_key = PropertyMock(return_value="test-key")
    return config

def test_with_mock_config(mock_config):
    """Test with mocked config properties."""
    assert mock_config.debug is True
    assert mock_config.api_key == "test-key"

python

@pytest.fixture
def mock_config():
    """创建带属性的Mock。"""
    config = Mock()
    type(config).debug = PropertyMock(return_value=True)
    type(config).api_key = PropertyMock(return_value="test-key")
    return config

def test_with_mock_config(mock_config):
    """使用Mock配置属性的测试。"""
    assert mock_config.debug is True
    assert mock_config.api_key == "test-key"

Testing Async Code

异步代码测试

Async Tests with pytest-asyncio

使用pytest-asyncio测试异步函数

python

import pytest

@pytest.mark.asyncio
async def test_async_function():
    """Test async function."""
    result = await async_add(2, 3)
    assert result == 5

@pytest.mark.asyncio
async def test_async_with_fixture(async_client):
    """Test async with async fixture."""
    response = await async_client.get("/api/users")
    assert response.status_code == 200

python

import pytest

@pytest.mark.asyncio
async def test_async_function():
    """测试异步函数。"""
    result = await async_add(2, 3)
    assert result == 5

@pytest.mark.asyncio
async def test_async_with_fixture(async_client):
    """使用异步Fixture的测试。"""
    response = await async_client.get("/api/users")
    assert response.status_code == 200

Async Fixture

异步Fixture

python

@pytest.fixture
async def async_client():
    """Async fixture providing async test client."""
    app = create_app()
    async with app.test_client() as client:
        yield client

@pytest.mark.asyncio
async def test_api_endpoint(async_client):
    """Test using async fixture."""
    response = await async_client.get("/api/data")
    assert response.status_code == 200

python

@pytest.fixture
async def async_client():
    """提供异步测试客户端的Fixture。"""
    app = create_app()
    async with app.test_client() as client:
        yield client

@pytest.mark.asyncio
async def test_api_endpoint(async_client):
    """使用异步Fixture的测试。"""
    response = await async_client.get("/api/data")
    assert response.status_code == 200

Mocking Async Functions

Mock异步函数

python

@pytest.mark.asyncio
@patch("mypackage.async_api_call")
async def test_async_mock(api_call_mock):
    """Test async function with mock."""
    api_call_mock.return_value = {"status": "ok"}

    result = await my_async_function()

    api_call_mock.assert_awaited_once()
    assert result["status"] == "ok"

python

@pytest.mark.asyncio
@patch("mypackage.async_api_call")
async def test_async_mock(api_call_mock):
    """使用Mock的异步函数测试。"""
    api_call_mock.return_value = {"status": "ok"}

    result = await my_async_function()

    api_call_mock.assert_awaited_once()
    assert result["status"] == "ok"

Testing Exceptions

异常测试

Testing Expected Exceptions

测试预期异常

python

def test_divide_by_zero():
    """Test that dividing by zero raises ZeroDivisionError."""
    with pytest.raises(ZeroDivisionError):
        divide(10, 0)

def test_custom_exception():
    """Test custom exception with message."""
    with pytest.raises(ValueError, match="invalid input"):
        validate_input("invalid")

python

def test_divide_by_zero():
    """测试除以零是否会抛出ZeroDivisionError。"""
    with pytest.raises(ZeroDivisionError):
        divide(10, 0)

def test_custom_exception():
    """测试带消息的自定义异常。"""
    with pytest.raises(ValueError, match="invalid input"):
        validate_input("invalid")

Testing Exception Attributes

测试异常属性

python

def test_exception_with_details():
    """Test exception with custom attributes."""
    with pytest.raises(CustomError) as exc_info:
        raise CustomError("error", code=400)

    assert exc_info.value.code == 400
    assert "error" in str(exc_info.value)

python

def test_exception_with_details():
    """测试带自定义属性的异常。"""
    with pytest.raises(CustomError) as exc_info:
        raise CustomError("error", code=400)

    assert exc_info.value.code == 400
    assert "error" in str(exc_info.value)

Testing Side Effects

副作用测试

Testing File Operations

测试文件操作

python

import tempfile
import os

def test_file_processing():
    """Test file processing with temp file."""
    with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt') as f:
        f.write("test content")
        temp_path = f.name

    try:
        result = process_file(temp_path)
        assert result == "processed: test content"
    finally:
        os.unlink(temp_path)

python

import tempfile
import os

def test_file_processing():
    """使用临时文件测试文件处理。"""
    with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt') as f:
        f.write("test content")
        temp_path = f.name

    try:
        result = process_file(temp_path)
        assert result == "processed: test content"
    finally:
        os.unlink(temp_path)

Testing with pytest's tmp_path Fixture

使用pytest的tmp_path Fixture测试

python

def test_with_tmp_path(tmp_path):
    """Test using pytest's built-in temp path fixture."""
    test_file = tmp_path / "test.txt"
    test_file.write_text("hello world")

    result = process_file(str(test_file))
    assert result == "hello world"
    # tmp_path automatically cleaned up

python

def test_with_tmp_path(tmp_path):
    """使用pytest内置临时路径Fixture的测试。"""
    test_file = tmp_path / "test.txt"
    test_file.write_text("hello world")

    result = process_file(str(test_file))
    assert result == "hello world"
    # tmp_path会自动清理

Testing with tmpdir Fixture

使用tmpdir Fixture测试

python

def test_with_tmpdir(tmpdir):
    """Test using pytest's tmpdir fixture."""
    test_file = tmpdir.join("test.txt")
    test_file.write("data")

    result = process_file(str(test_file))
    assert result == "data"

python

def test_with_tmpdir(tmpdir):
    """使用pytest的tmpdir Fixture的测试。"""
    test_file = tmpdir.join("test.txt")
    test_file.write("data")

    result = process_file(str(test_file))
    assert result == "data"

Test Organization

测试组织

Directory Structure

目录结构

tests/
├── conftest.py                 # Shared fixtures
├── __init__.py
├── unit/                       # Unit tests
│   ├── __init__.py
│   ├── test_models.py
│   ├── test_utils.py
│   └── test_services.py
├── integration/                # Integration tests
│   ├── __init__.py
│   ├── test_api.py
│   └── test_database.py
└── e2e/                        # End-to-end tests
    ├── __init__.py
    └── test_user_flow.py

tests/
├── conftest.py                 # 共享Fixture
├── __init__.py
├── unit/                       # 单元测试
│   ├── __init__.py
│   ├── test_models.py
│   ├── test_utils.py
│   └── test_services.py
├── integration/                # 集成测试
│   ├── __init__.py
│   ├── test_api.py
│   └── test_database.py
└── e2e/                        # 端到端测试
    ├── __init__.py
    └── test_user_flow.py

Test Classes

测试类

python

class TestUserService:
    """Group related tests in a class."""

    @pytest.fixture(autouse=True)
    def setup(self):
        """Setup runs before each test in this class."""
        self.service = UserService()

    def test_create_user(self):
        """Test user creation."""
        user = self.service.create_user("Alice")
        assert user.name == "Alice"

    def test_delete_user(self):
        """Test user deletion."""
        user = User(id=1, name="Bob")
        self.service.delete_user(user)
        assert not self.service.user_exists(1)

python

class TestUserService:
    """将相关测试分组到类中。"""

    @pytest.fixture(autouse=True)
    def setup(self):
        """在该类的每个测试前运行初始化。"""
        self.service = UserService()

    def test_create_user(self):
        """测试用户创建。"""
        user = self.service.create_user("Alice")
        assert user.name == "Alice"

    def test_delete_user(self):
        """测试用户删除。"""
        user = User(id=1, name="Bob")
        self.service.delete_user(user)
        assert not self.service.user_exists(1)

Best Practices

最佳实践

DO

建议

Follow TDD: Write tests before code (red-green-refactor)
Test one thing: Each test should verify a single behavior

Use descriptive names:

test_user_login_with_invalid_credentials_fails

Use fixtures: Eliminate duplication with fixtures
Mock external dependencies: Don't depend on external services
Test edge cases: Empty inputs, None values, boundary conditions
Aim for 80%+ coverage: Focus on critical paths
Keep tests fast: Use marks to separate slow tests

遵循TDD：先写测试再写代码（红-绿-重构）
单一职责：每个测试应验证单一行为

使用描述性名称：例如

test_user_login_with_invalid_credentials_fails

使用Fixture：用Fixture消除重复代码
Mock外部依赖：不要依赖外部服务
测试边界情况：空输入、None值、边界条件
目标覆盖率80%+：重点关注关键路径
保持测试快速：使用标记区分慢测试

DON'T

不建议

Don't test implementation: Test behavior, not internals
Don't use complex conditionals in tests: Keep tests simple
Don't ignore test failures: All tests must pass
Don't test third-party code: Trust libraries to work
Don't share state between tests: Tests should be independent
Don't catch exceptions in tests: Use
```
pytest.raises
```
Don't use print statements: Use assertions and pytest output
Don't write tests that are too brittle: Avoid over-specific mocks

不测试实现细节：测试行为而非内部逻辑
测试中不要使用复杂条件：保持测试简单
不要忽略测试失败：所有测试必须通过
不测试第三方代码：信任库的正确性
测试间不要共享状态：测试应独立
测试中不要捕获异常：使用
```
pytest.raises
```
不要使用print语句：使用断言和pytest输出
不要编写过于脆弱的测试：避免过度特定的Mock

Common Patterns

常见模式

Testing API Endpoints (FastAPI/Flask)

测试API端点（FastAPI/Flask）

python

@pytest.fixture
def client():
    app = create_app(testing=True)
    return app.test_client()

def test_get_user(client):
    response = client.get("/api/users/1")
    assert response.status_code == 200
    assert response.json["id"] == 1

def test_create_user(client):
    response = client.post("/api/users", json={
        "name": "Alice",
        "email": "alice@example.com"
    })
    assert response.status_code == 201
    assert response.json["name"] == "Alice"

python

@pytest.fixture
def client():
    app = create_app(testing=True)
    return app.test_client()

def test_get_user(client):
    response = client.get("/api/users/1")
    assert response.status_code == 200
    assert response.json["id"] == 1

def test_create_user(client):
    response = client.post("/api/users", json={
        "name": "Alice",
        "email": "alice@example.com"
    })
    assert response.status_code == 201
    assert response.json["name"] == "Alice"

Testing Database Operations

测试数据库操作

python

@pytest.fixture
def db_session():
    """Create a test database session."""
    session = Session(bind=engine)
    session.begin_nested()
    yield session
    session.rollback()
    session.close()

def test_create_user(db_session):
    user = User(name="Alice", email="alice@example.com")
    db_session.add(user)
    db_session.commit()

    retrieved = db_session.query(User).filter_by(name="Alice").first()
    assert retrieved.email == "alice@example.com"

python

@pytest.fixture
def db_session():
    """创建测试数据库会话。"""
    session = Session(bind=engine)
    session.begin_nested()
    yield session
    session.rollback()
    session.close()

def test_create_user(db_session):
    user = User(name="Alice", email="alice@example.com")
    db_session.add(user)
    db_session.commit()

    retrieved = db_session.query(User).filter_by(name="Alice").first()
    assert retrieved.email == "alice@example.com"

Testing Class Methods

测试类方法

python

class TestCalculator:
    @pytest.fixture
    def calculator(self):
        return Calculator()

    def test_add(self, calculator):
        assert calculator.add(2, 3) == 5

    def test_divide_by_zero(self, calculator):
        with pytest.raises(ZeroDivisionError):
            calculator.divide(10, 0)

python

class TestCalculator:
    @pytest.fixture
    def calculator(self):
        return Calculator()

    def test_add(self, calculator):
        assert calculator.add(2, 3) == 5

    def test_divide_by_zero(self, calculator):
        with pytest.raises(ZeroDivisionError):
            calculator.divide(10, 0)

pytest Configuration

pytest配置

pytest.ini

ini

[pytest]
testpaths = tests
python_files = test_*.py
python_classes = Test*
python_functions = test_*
addopts =
    --strict-markers
    --disable-warnings
    --cov=mypackage
    --cov-report=term-missing
    --cov-report=html
markers =
    slow: marks tests as slow
    integration: marks tests as integration tests
    unit: marks tests as unit tests

ini

[pytest]
testpaths = tests
python_files = test_*.py
python_classes = Test*
python_functions = test_*
addopts =
    --strict-markers
    --disable-warnings
    --cov=mypackage
    --cov-report=term-missing
    --cov-report=html
markers =
    slow: 标记为慢测试
    integration: 标记为集成测试
    unit: 标记为单元测试

pyproject.toml

toml

[tool.pytest.ini_options]
testpaths = ["tests"]
python_files = ["test_*.py"]
python_classes = ["Test*"]
python_functions = ["test_*"]
addopts = [
    "--strict-markers",
    "--cov=mypackage",
    "--cov-report=term-missing",
    "--cov-report=html",
]
markers = [
    "slow: marks tests as slow",
    "integration: marks tests as integration tests",
    "unit: marks tests as unit tests",
]

toml

[tool.pytest.ini_options]
testpaths = ["tests"]
python_files = ["test_*.py"]
python_classes = ["Test*"]
python_functions = ["test_*"]
addopts = [
    "--strict-markers",
    "--cov=mypackage",
    "--cov-report=term-missing",
    "--cov-report=html",
]
markers = [
    "slow: 标记为慢测试",
    "integration: 标记为集成测试",
    "unit: 标记为单元测试",
]

Running Tests

运行测试

bash

undefined

bash

undefined

Run all tests

运行所有测试

pytest

Run specific file

运行特定文件

pytest tests/test_utils.py

Run specific test

运行特定测试

pytest tests/test_utils.py::test_function

Run with verbose output

带详细输出运行

pytest -v

Run with coverage

带覆盖率运行

pytest --cov=mypackage --cov-report=html

Run only fast tests

仅运行快速测试

pytest -m "not slow"

Run until first failure

遇到第一个失败就停止

pytest -x

Run and stop on N failures

遇到N个失败就停止

pytest --maxfail=3

Run last failed tests

运行上次失败的测试

pytest --lf

Run tests with pattern

运行匹配指定模式的测试

pytest -k "test_user"

Run with debugger on failure

失败时启动调试器

pytest --pdb

undefined

pytest --pdb

undefined

Quick Reference

快速参考

Pattern	Usage
`pytest.raises()`	Test expected exceptions
`@pytest.fixture()`	Create reusable test fixtures
`@pytest.mark.parametrize()`	Run tests with multiple inputs
`@pytest.mark.slow`	Mark slow tests
`pytest -m "not slow"`	Skip slow tests
`@patch()`	Mock functions and classes
`tmp_path` fixture	Automatic temp directory
`pytest --cov`	Generate coverage report
`assert`	Simple and readable assertions

Remember: Tests are code too. Keep them clean, readable, and maintainable. Good tests catch bugs; great tests prevent them.

模式	用途
`pytest.raises()`	测试预期异常
`@pytest.fixture()`	创建可复用的测试Fixture
`@pytest.mark.parametrize()`	使用多组输入运行测试
`@pytest.mark.slow`	标记慢测试
`pytest -m "not slow"`	跳过慢测试
`@patch()`	Mock函数和类
`tmp_path` fixture	自动创建临时目录
`pytest --cov`	生成覆盖率报告
`assert`	简洁易读的断言

记住：测试也是代码。保持测试整洁、易读且可维护。好的测试能发现bug；优秀的测试能预防bug。