Recap — Fixtures, Mocking, Coverage, Test Organization

# Fixtures, Mocking, Coverage, Test Organization pytest is the standard Python test framework. Knowing it well separates "I write some tests" from "I have a real test suite". ## Why pytest over unittest - Less boilerplate (functions, not classes). - Better assertions (`assert x == y` with rich diff output). - Fixtures (composable test setup). - Parametrization (run same test with many inputs). - Rich plugin ecosystem (pytest-cov, pytest-asyncio, pytest-mock). ## The basics ```python # tests/test_math.py def test_addition(): assert 1 + 1 == 2 def test_division_by_zero(): import pytest with pytest.raises(ZeroDivisionError): 1 / 0 ``` Run: ```bash pytest # all tests pytest tests/test_math.py # specific file pytest -k "addition" # tests matching name pytest -v # verbose pytest -x # stop on first failure pytest --pdb # drop into debugger on failure ``` ## Fixtures Reusable test setup: ```python import pytest @pytest.fixture def user_data(): return {"name": "Alice", "email": "alice@example.com"} def test_user_name(user_data): assert user_data["name"] == "Alice" def test_user_email(user_data): assert "@" in user_data["email"] ``` pytest injects the fixture value based on parameter name. Each test gets a fresh instance (by default). ### Fixture scopes ```python @pytest.fixture(scope="function") # default: new instance per test @pytest.fixture(scope="class") # one per test class @pytest.fixture(scope="module") # one per test file @pytest.fixture(scope="session") # one per pytest run ``` Use session-scoped for expensive setup (DB connection, app startup). ### Fixture cleanup ```python @pytest.fixture def temp_file(): path = "/tmp/test.txt" open(path, "w").write("data") yield path # test runs here os.remove(path) # cleanup after test ``` `yield` is the test boundary; code before = setup; after = teardown. ### Fixture composition ```python @pytest.fixture def db_connection(): return create_connection() @pytest.fixture def user(db_connection): return create_user(db_connection, name="Alice") def test_login(user): assert user.login("password") ``` Fixtures can depend on fixtures. pytest resolves the chain. ### conftest.py Fixtures defined in `conftest.py` are available to all tests in that directory and below — no import needed. ``` tests/ ├── conftest.py # fixtures available everywhere ├── api/ │ ├── conftest.py # additional fixtures for api tests │ └── test_users.py ``` ## Parametrization Run the same test with multiple inputs: ```python @pytest.mark.parametrize("input,expected", [ (1, 1), (2, 4), (3, 9), (-1, 1), ]) def test_square(input, expected): assert input * input == expected ``` Generates 4 distinct tests; each appears separately in output. ### Parametrize ids for readability ```python @pytest.mark.parametrize("input,expected", [ (1, 1), (2, 4), ], ids=["one_squared", "two_squared"]) ``` Shows nice names in test output. ### Parametrize fixtures ```python @pytest.fixture(params=[1, 2, 3]) def number(request): return request.param def test_positive(number): assert number > 0 ``` Each test runs 3 times, once per param value. ## Mocking Replace external dependencies with controlled fakes: ```python from unittest.mock import patch, MagicMock @patch("my_module.requests.get") def test_api_call(mock_get): mock_get.return_value.json.return_value = {"result": 42} result = my_module.fetch_data() assert result == 42 mock_get.assert_called_once_with("https://api.example.com") ``` `patch` replaces an attribute for the test's duration. ### Pytest-mock plugin Cleaner API: ```python def test_api_call(mocker): mock_get = mocker.patch("my_module.requests.get") mock_get.return_value.json.return_value = {"result": 42} ... ``` `mocker` is a pytest fixture providing scoped mocks. ### What to mock - External services (HTTP, DB, queues). - Time (`mocker.patch("time.time")` to test time-dependent logic). - Random (set seed or mock). - File I/O (in some cases; often a temp dir is cleaner). What NOT to mock: - Your own code unless absolutely necessary. - The class under test (defeats the purpose). - Standard library (usually). ## Coverage ```bash pip install pytest-cov pytest --cov=src --cov-report=html ``` Generates an HTML report in `htmlcov/` showing line-by-line coverage. Aim for: 70-90% on critical paths; 100% is rarely worth the effort. Coverage shows WHAT was executed, not WHAT was tested. A line can be covered by a test that doesn't verify anything meaningful. ## Async tests ```python import pytest @pytest.mark.asyncio async def test_async_fetch(): result = await fetch_data() assert result == "expected" ``` Requires `pytest-asyncio`. Add to pyproject.toml: ```toml [tool.pytest.ini_options] as