Python Testing

affaan-m/ECC/pi/core/skills/python-testing

作者 affaan-mef648e01899ba3e8dc6371642deaaf64b4477775无许可证275K 个星标收录于 2026年10月9日更新于 2026年10月9日仓库4天前更新

Python testing strategies using pytest, TDD methodology, fixtures, mocking, parametrization, and coverage requirements. Use when writing pytest tests — fixtures, mocks, parametrization, or coverage.

仅含说明Software Development
AI 生成的概览

指导使用 pytest 编写 Python 测试，涵盖 TDD、fixture、mock、参数化和覆盖率。

功能
该技能提供使用 pytest 编写 Python 测试的参考指导。内容涵盖 TDD 红-绿-重构循环、断言、fixture 及其作用域、参数化、标记、mock 与 patch、异步测试、异常测试、临时文件处理、测试组织以及 pytest 配置。它还给出覆盖率目标和最佳实践，并包含运行测试与测量覆盖率的示例命令。
适用场景
适用于为 Python 项目编写或审查 pytest 测试、设计测试套件或搭建测试基础设施时。在涉及 fixture、mock、参数化或覆盖率要求时也适用。
运行要求
需要 pytest；测量覆盖率需要 pytest-cov；异步示例假定使用 pytest-asyncio。该技能不附带脚本，仅为说明文档。

Python Testing Patterns

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

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

Core Testing Philosophy

Test-Driven Development (TDD)

Always follow the TDD cycle:

  1. RED: Write a failing test for the desired behavior
  2. GREEN: Write minimal code to make the test pass
  3. REFACTOR: Improve code while keeping tests green
python
# Step 1: Write failing test (RED)def test_add_numbers():    result = add(2, 3)    assert result == 5
# Step 2: Write minimal implementation (GREEN)def add(a, b):    return a + b
# Step 3: Refactor if needed (REFACTOR)

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

pytest Fundamentals

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

Assertions

python
# Equalityassert result == expected
# Inequalityassert result != unexpected
# Truthinessassert result  # Truthyassert not result  # Falsyassert result is True  # Exactly Trueassert result is False  # Exactly Falseassert result is None  # Exactly None
# Membershipassert item in collectionassert item not in collection
# Comparisonsassert result > 0assert 0 <= result <= 100
# Type checkingassert isinstance(result, str)
# Exception testing (preferred approach)with pytest.raises(ValueError):    raise ValueError("error message")
# Check exception messagewith pytest.raises(ValueError, match="invalid input"):    raise ValueError("invalid input provided")
# Check exception attributeswith pytest.raises(ValueError) as exc_info:    raise ValueError("error message")assert str(exc_info.value) == "error message"

Fixtures

Basic Fixture Usage

python
import pytest
@pytest.fixturedef 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

Fixture with Setup/Teardown

python
@pytest.fixturedef 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

Fixture Scopes

python
# Function scope (default) - runs for each test@pytest.fixturedef 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()

Fixture with Parameters

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

Using Multiple Fixtures

python
@pytest.fixturedef user():    return User(id=1, name="Alice")
@pytest.fixturedef 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)

Autouse Fixtures

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

Conftest.py for Shared Fixtures

python
# tests/conftest.pyimport pytest
@pytest.fixturedef client():    """Shared fixture for all tests."""    app = create_app(testing=True)    with app.test_client() as client:        yield client
@pytest.fixturedef 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}"}

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

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

Parametrize with IDs

python
@pytest.mark.parametrize("input,expected", [    ("[email protected]", 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

Parametrized Fixtures

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

Markers and Test Selection

Custom Markers

python
# Mark slow tests@pytest.mark.slowdef test_slow_operation():    time.sleep(5)
# Mark integration tests@pytest.mark.integrationdef test_api_integration():    response = requests.get("https://api.example.com")    assert response.status_code == 200
# Mark unit tests@pytest.mark.unitdef test_unit_logic():    assert calculate(2, 3) == 5

Run Specific Tests

bash
# Run only fast testspytest -m "not slow"
# Run only integration testspytest -m integration
# Run integration or slow testspytest -m "integration or slow"
# Run tests marked as unit but not slowpytest -m "unit and not slow"

Configure Markers in 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

Mocking and Patching

Mocking Functions

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"

Mocking Return Values

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")

Mocking Exceptions

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()

Mocking Context Managers

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"

Using 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()

Mock Class Instances

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()

Mock Property

python
@pytest.fixturedef 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"

Testing Async Code

Async Tests with pytest-asyncio

python
import pytest
@pytest.mark.asyncioasync def test_async_function():    """Test async function."""    result = await async_add(2, 3)    assert result == 5
@pytest.mark.asyncioasync def test_async_with_fixture(async_client):    """Test async with async fixture."""    response = await async_client.get("/api/users")    assert response.status_code == 200

Async Fixture

python
@pytest.fixtureasync def async_client():    """Async fixture providing async test client."""    app = create_app()    async with app.test_client() as client:        yield client
@pytest.mark.asyncioasync def test_api_endpoint(async_client):    """Test using async fixture."""    response = await async_client.get("/api/data")    assert response.status_code == 200

Mocking Async Functions

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"

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")

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)

Testing Side Effects

Testing File Operations

python
import tempfileimport 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)

Testing with pytest's 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

Testing with 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"

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

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)

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

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

Common Patterns

Testing API Endpoints (FastAPI/Flask)

python
@pytest.fixturedef 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": "[email protected]"    })    assert response.status_code == 201    assert response.json["name"] == "Alice"

Testing Database Operations

python
@pytest.fixturedef 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="[email protected]")    db_session.add(user)    db_session.commit()
    retrieved = db_session.query(User).filter_by(name="Alice").first()    assert retrieved.email == "[email protected]"

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)

pytest Configuration

pytest.ini

ini
[pytest]testpaths = testspython_files = test_*.pypython_classes = Test*python_functions = test_*addopts =    --strict-markers    --disable-warnings    --cov=mypackage    --cov-report=term-missing    --cov-report=htmlmarkers =    slow: marks tests as slow    integration: marks tests as integration tests    unit: marks tests as unit tests

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",]

Running Tests

bash
# Run all testspytest
# Run specific filepytest tests/test_utils.py
# Run specific testpytest tests/test_utils.py::test_function
# Run with verbose outputpytest -v
# Run with coveragepytest --cov=mypackage --cov-report=html
# Run only fast testspytest -m "not slow"
# Run until first failurepytest -x
# Run and stop on N failurespytest --maxfail=3
# Run last failed testspytest --lf
# Run tests with patternpytest -k "test_user"
# Run with debugger on failurepytest --pdb

Quick Reference

PatternUsage
pytest.raises()Test expected exceptions
@pytest.fixture()Create reusable test fixtures
@pytest.mark.parametrize()Run tests with multiple inputs
@pytest.mark.slowMark slow tests
pytest -m "not slow"Skip slow tests
@patch()Mock functions and classes
tmp_path fixtureAutomatic temp directory
pytest --covGenerate coverage report
assertSimple and readable assertions

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

来源与署名

来源：affaan-m/ECC位于pi/core/skills/python-testing提交ef648e0

许可证： 无许可证

内容归原作者所有。SourceWeft 从公开仓库中收录这些内容。

举报或申请下架

更多来自 affaan-m/ECC 的技能

Unified Notifications Ops

affaan-m

设计统一的通知策略，对来自 GitHub、Linear、钩子和聊天工具的通知进行分类、路由、去重和升级。

Productivity & Workflow275K4天前更新

Verification Loop

affaan-m

执行六阶段代码验证流程，并生成 PASS/FAIL 就绪报告。

Software Development275K4天前更新

Ui To Vue

affaan-m

将批量 UI 设计截图转换为使用 Vant、Element Plus 或 Ant Design Vue 的 Vue 3 组件。

Software Development275K4天前更新

Unified Memory

affaan-m

指导智能体通过本地 ECC Memory Vault 在不同执行框架之间共享持久上下文与交接信息。

AI & Agents275K4天前更新

Visa Doc Translate

affaan-m

通过 OCR 将签证文件图片翻译成英文，并生成原图与译文对照的双语 PDF。

Documents & Office275K4天前更新

Team Builder

affaan-m

交互式选择器：发现可用的智能体角色，让用户最多选择五个，并行执行同一任务并汇总结果。

AI & Agents275K4天前更新

更多Software Development技能

Playground

anthropics

精选

构建自包含的交互式 HTML 演练场，包含控件、实时预览和可复制的提示词输出。

Software Development37K今天更新

M5 Onboard

anthropics

精选

通过 USB 检测 M5Stack ESP32 开发板，刷写 UIFlow 2.0 固件并安装 MicroPython 应用包。

Software Development37K今天更新

Cardputer Buddy

anthropics

精选

指导迭代 Cardputer-Adv 的 MicroPython 应用包：添加应用、通过 USB 串口推送文件、查看日志并运行 REPL 命令。

Software Development37K今天更新

Web Design Guidelines

vercel-labs

精选

依据从远程来源获取的 Web Interface Guidelines 审查 UI 代码，并以 file:line 形式报告问题。

Software Development32K5周前更新

Vercel React Native Skills

vercel-labs

精选

React Native 与 Expo 最佳实践规则，涵盖列表性能、动画、导航、UI 模式、状态与 monorepo 配置。

Software Development32K5周前更新

Vercel React Best Practices

vercel-labs

精选

Vercel 的 React 与 Next.js 性能指南，以 70 条规则的形式用于编写、审查和重构代码。

Software Development32K5周前更新