Python Testing Skill

Generate high-quality pytest tests following best practices for this project.

Core Principles

1. •

   Minimal Mocking: Only mock external dependencies (APIs, databases, file I/O). Test with real Python objects whenever possible. Mocking internal logic can hide breaking changes.

2. •

   Parametrization: Use @pytest.mark.parametrize for testing multiple cases instead of writing separate test functions. Keeps tests DRY and readable.

3. •

   Shared Fixtures in conftest.py: Place reusable fixtures in conftest.py to avoid duplication. Fixtures are automatically discovered by pytest.

4. •

   1-1 File Correspondence: Each source file has a corresponding test file (src/game.py → tests/test_game.py).

Instructions

Step 1: Analyze the Module

Use the Read tool to understand:

• •Function signatures and parameters
• •Return types and expected behavior
• •Dependencies (what needs mocking vs what can be real)
• •Error conditions and edge cases
• •Existing patterns in the codebase

Step 2: Identify Fixtures and Parametrization

Check existing conftest.py:

• •Read tests/conftest.py to see what fixtures already exist
• •Identify what new fixtures are needed
• •Decide if fixtures should be in conftest.py (reusable) or local (test-specific)

Plan parametrization:

• •Group similar test cases that vary by input/output
• •Identify boundary conditions (0, None, empty, negative, max)
• •Consider happy path + error cases

Step 3: Determine What to Mock

Mock ONLY these:

• •External HTTP/API calls (use mocker.patch or requests_mock)
• •Database connections
• •File I/O when not using tmp_path
• •System calls and environment variables
• •Time-dependent operations

Do NOT mock:

• •Pure functions (calculations, transformations)
• •Internal helper functions
• •Data classes and models
• •Business logic
• •Other modules in your project (integration is good!)

Step 4: Write Tests

Follow this structure:

"""Tests for <module_name> (src/<path>/<module>.py)"""

import pytest
# Import what you're testing
# Import any mocking utilities if absolutely needed


class Test<ClassName>:
    """Test <ClassName> functionality"""

    def test_basic_happy_path(self, fixture_from_conftest):
        """Test normal operation"""
        # Arrange
        # Act
        # Assert

    @pytest.mark.parametrize("input,expected", [
        (case1_in, case1_out),
        (case2_in, case2_out),
        (edge_case, expected),
    ])
    def test_with_various_inputs(self, input, expected):
        """Test behavior with multiple inputs"""
        assert function(input) == expected

    def test_error_condition(self):
        """Test exception handling"""
        with pytest.raises(SpecificException):
            function_that_should_fail()

Step 5: Update conftest.py

If you created reusable fixtures, add them to tests/conftest.py:

@pytest.fixture
def descriptive_name():
    """Clear docstring explaining what this provides"""
    # Setup
    obj = create_object()
    yield obj
    # Teardown (if needed)

Quality Checklist

Before finishing:

• • All public methods/functions have tests
• • Edge cases tested (None, 0, empty, max, negative)
• • Error conditions raise expected exceptions
• • Similar tests are parametrized (not duplicated)
• • Reusable fixtures in conftest.py
• • Mocking limited to external dependencies only
• • Test names describe behavior clearly
• • Each test checks one specific behavior
• • Tests run in isolation (no shared state between tests)

Current Project Structure

tests/
├── conftest.py              # Shared fixtures
├── entities/
│   ├── test_player.py      # Tests for src/entities/player.py
│   └── test_zombie.py      # Tests for src/entities/zombie.py
├── test_config.py           # Tests for src/config.py
└── test_game.py             # Tests for src/game.py

Examples

See EXAMPLES.md for detailed examples.