Testing

pytest — The De-Facto Standard

The standard library ships unittest, but pytest has won the ecosystem. Better assertions, fixtures, plugins, and zero boilerplate.

(.venv) $ pip install pytest pytest-cov

Your First Test

# myapp/math.py
def add(a, b):
    return a + b

# tests/test_math.py
from myapp.math import add

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

def test_add_negative():
    assert add(-1, -1) == -2

(.venv) $ pytest -v
tests/test_math.py::test_add PASSED
tests/test_math.py::test_add_negative PASSED

pytest Conventions

• Files named test_*.py or *_test.py
• Functions named test_*
• Classes named Test* (no __init__)
• Use plain assert — pytest rewrites it for rich failure output

Fixtures

Fixtures provide reusable setup. Declare them with @pytest.fixture and inject by name.

import pytest

@pytest.fixture
def sample_user():
    return {"name": "Alice", "age": 30}

def test_user_name(sample_user):
    assert sample_user["name"] == "Alice"

Fixtures with Setup & Teardown

@pytest.fixture
def tmp_db():
    db = Database(":memory:")
    db.migrate()
    yield db          # test runs here
    db.close()        # teardown

Scopes — Reuse Across Tests

@pytest.fixture(scope="session")
def api_client():
    client = create_client()
    yield client
    client.close()
# Scopes: function (default), class, module, session

conftest.py

Place fixtures in conftest.py to share across all tests in the directory.

Parametrize

Run the same test against many inputs.

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

4 separate test cases, each shown individually in output. Failures point to the exact parameters.

Marking Tests

@pytest.mark.skip(reason="not yet implemented")
def test_feature(): ...

@pytest.mark.skipif(sys.version_info < (3, 12), reason="needs 3.12+")
def test_new_syntax(): ...

@pytest.mark.xfail             # expected to fail (known bug)
def test_broken(): ...

@pytest.mark.slow              # custom marker
def test_long_running(): ...

$ pytest -m "not slow"      # skip slow tests

Testing Exceptions

def test_divide_by_zero():
    with pytest.raises(ZeroDivisionError):
        1 / 0

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

Mocking

unittest.mock ships with the standard library. Use mocker from pytest-mock for cleaner integration.

from unittest.mock import patch, MagicMock

def test_get_user():
    with patch("myapp.api.requests.get") as mock_get:
        mock_get.return_value.json.return_value = {"name": "Alice"}
        result = get_user(42)
    assert result["name"] == "Alice"
    mock_get.assert_called_once_with("https://api.example.com/users/42")

monkeypatch — pytest's built-in

def test_env(monkeypatch):
    monkeypatch.setenv("API_KEY", "test123")
    monkeypatch.setattr("myapp.api.requests.get", fake_get)
    ...

Coverage

(.venv) $ pytest --cov=myapp --cov-report=term-missing
--------- coverage: platform darwin, python 3.12.3 ----------
Name                Stmts   Miss  Cover   Missing
-------------------------------------------------
myapp/core.py          45      2    96%   34-35
myapp/cli.py           28      0   100%

100% coverage is not the goal — meaningful tests are. But coverage reports highlight forgotten branches.