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:

• 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

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"

Testing Async Code

Async Tests with pytest-asyncio

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

Async Fixture

@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

Mocking Async Functions

@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

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

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

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)

Testing with pytest's tmp_path Fixture

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

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

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)

@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

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

Testing Class Methods

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

[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

pyproject.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

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

pytest --maxfail=3

Run last failed tests

pytest --lf

Run tests with pattern

pytest -k "test_user"

Run with debugger on failure

pytest --pdb

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.