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
• Choosing the correct scope (function, module, session) for a pytest fixture
• Debugging flaky tests caused by shared mutable state or incorrect mock namespaces
• Parametrizing tests to cover multiple inputs without duplicating test logic
• Enforcing 80%+ coverage with pytest --cov and understanding which lines are uncovered

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

# 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

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

pytest Fundamentals

Basic Test Structure

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

# 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

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

Fixtures

Basic Fixture Usage

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

Fixture with Setup/Teardown

@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

Fixture Scopes

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

Fixture with Parameters

@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

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

Autouse Fixtures

@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

# 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}"}

Parametrization

Basic Parametrization

@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

@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

@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

Parametrized Fixtures

@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

# 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

Run Specific Tests

# 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
pytest -m "unit and not slow"

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

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

@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

@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

@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

@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

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

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

Anti-Patterns

Patching the Wrong Namespace

Wrong:

# Patching where the function is defined, not where it is used
@patch("mypackage.utils.requests.get")
def test_fetch(mock_get):
    mock_get.return_value.json.return_value = {"ok": True}
    result = mypackage.service.fetch_data()  # imports requests.get directly
    mock_get.assert_called_once()  # never called — wrong target

Correct:

# Patch the name as it is imported in the module under test
@patch("mypackage.service.requests.get")
def test_fetch(mock_get):
    mock_get.return_value.json.return_value = {"ok": True}
    result = mypackage.service.fetch_data()
    mock_get.assert_called_once()

Why: @patch replaces the name in the namespace where it is looked up, not where it is defined.

---

Sharing Mutable State Between Tests via Module-Level Variables

Wrong:

SHARED_LIST = []  # module-level mutable state

def test_append_item():
    SHARED_LIST.append("a")
    assert "a" in SHARED_LIST

def test_list_is_empty():
    assert SHARED_LIST == []  # fails if test_append_item ran first

Correct:

@pytest.fixture
def items():
    return []

def test_append_item(items):
    items.append("a")
    assert "a" in items

def test_list_is_empty(items):
    assert items == []  # always a fresh list

Why: Module-level mutable state leaks between tests, making order-dependent failures that are hard to diagnose.

---

Asserting on Exceptions Without Checking the Message

Wrong:

def test_invalid_email_raises():
    with pytest.raises(ValueError):
        create_user(email="not-an-email")
    # passes even if ValueError is raised for a completely different reason

Correct:

def test_invalid_email_raises():
    with pytest.raises(ValueError, match="invalid email"):
        create_user(email="not-an-email")

Why: Without match=, any ValueError — including ones from unrelated bugs — makes the test pass silently.

---

Using assert Inside a Loop Without Identifying the Failing Case

Wrong:

def test_all_users_active():
    for user in get_users():
        assert user.is_active  # failure output: "assert False" — no context

Correct:

@pytest.mark.parametrize("user", get_users())
def test_user_is_active(user):
    assert user.is_active, f"Expected user {user.id!r} to be active"

Why: Parametrized tests identify exactly which input failed; a loop gives no context and stops at the first failure.

---

Using time.sleep in Tests to Wait for Async Behaviour

Wrong:

def test_background_job_runs():
    trigger_job()
    time.sleep(2)  # hope it finishes in time — flaky on slow CI
    assert job_completed()

Correct:

def test_background_job_runs():
    trigger_job()
    # poll with a timeout, or use pytest-asyncio / mock the scheduler
    deadline = time.monotonic() + 5
    while not job_completed():
        assert time.monotonic() < deadline, "Job did not complete within 5s"
        time.sleep(0.1)

Why: Fixed sleeps cause flaky tests on slow machines and waste time on fast ones; polling with a deadline is both reliable and fast.

For advanced testing — async code (pytest-asyncio), exception attribute testing, file/side-effect testing, test organization (directory structure, test classes), best practices, API endpoint patterns, database testing, pytest configuration, and CLI reference — see skill: python-testing-advanced.