Recap — TestClient, Fixtures, Dependency Overrides

# TestClient, Fixtures, Dependency Overrides Testing FastAPI is straightforward — TestClient + pytest + fixture overrides give you fast, isolated tests. ## TestClient basics ```python # tests/test_main.py from fastapi.testclient import TestClient from my_app.main import app client = TestClient(app) def test_root(): response = client.get("/") assert response.status_code == 200 assert response.json() == {"message": "Hello, world"} def test_create_user(): response = client.post("/users", json={"email": "a@b.com", "name": "A", "password": "secret123"}) assert response.status_code == 201 data = response.json() assert data["email"] == "a@b.com" assert "id" in data assert "password" not in data # security check ``` TestClient simulates HTTP requests; no server needs to run. ## Test DB (real DB, transaction-rolled-back) For integration tests with real schema: ```python # tests/conftest.py import pytest from sqlalchemy import create_engine from sqlalchemy.orm import sessionmaker from my_app.main import app from my_app.db import Base, get_db TEST_DB_URL = "sqlite:///./test.db" engine = create_engine(TEST_DB_URL, connect_args={"check_same_thread": False}) TestingSessionLocal = sessionmaker(bind=engine) @pytest.fixture(scope="session", autouse=True) def setup_db(): Base.metadata.create_all(engine) yield Base.metadata.drop_all(engine) @pytest.fixture def db(): """Per-test DB session with rollback.""" connection = engine.connect() transaction = connection.begin() session = TestingSessionLocal(bind=connection) yield session session.close() transaction.rollback() connection.close() @pytest.fixture def client(db): """TestClient with test DB injected.""" def override_get_db(): yield db app.dependency_overrides[get_db] = override_get_db with TestClient(app) as c: yield c app.dependency_overrides.clear() ``` What this does: - `setup_db`: create schema once per test session. - `db`: a fresh transaction per test; rolled back after. - `client`: TestClient that uses the test DB. Each test starts with a clean DB state. Fast (no schema rebuild) and isolated. ## Testing protected endpoints Override `get_current_user`: ```python # tests/conftest.py from my_app.deps import get_current_user from my_app.models import User @pytest.fixture def test_user(db): user = User(email="test@example.com", name="Test", password_hash="hashed") db.add(user) db.commit() return user @pytest.fixture def authenticated_client(client, test_user): def override_get_current_user(): return test_user app.dependency_overrides[get_current_user] = override_get_current_user yield client app.dependency_overrides.pop(get_current_user, None) ``` Use: ```python def test_me(authenticated_client, test_user): response = authenticated_client.get("/me") assert response.status_code == 200 assert response.json()["email"] == test_user.email ``` No actual JWT involved; the dependency returns the test user directly. ## Testing different roles ```python @pytest.fixture def admin_user(db): user = User(email="admin@example.com", role="admin", ...) db.add(user) db.commit() return user @pytest.fixture def admin_client(client, admin_user): def override(): return admin_user app.dependency_overrides[get_current_user] = override yield client app.dependency_overrides.pop(get_current_user, None) def test_admin_can_delete(admin_client): response = admin_client.delete("/users/123") assert response.status_code in (204, 404) def test_regular_user_cannot_delete(authenticated_client): response = authenticated_client.delete("/users/123") assert response.status_code == 403 ``` Different fixtures for different user roles. ## Mocking external services For HTTP calls to third parties: ```python from unittest.mock import patch @patch("my_app.email.send_email") def test_signup_sends_email(mock_send, client): response = client.post("/signup", json={"email": "a@b.com", "password": "secret", "name": "A"}) assert response.status_code == 201 mock_send.assert_called_once() ``` Or use `pytest-mock` for cleaner syntax: ```python def test_signup_sends_email(client, mocker): mock_send = mocker.patch("my_app.email.send_email") response = client.post("/signup", json={...}) mock_send.assert_called_once() ``` For HTTP clients: `pytest-httpx` mocks httpx; `responses` library mocks requests. ## Testing async endpoints ```python import pytest from httpx import AsyncClient from my_app.main import app @pytest.mark.asyncio async def test_async_endpoint(): async with AsyncClient(app=app, base_url="http://test") as ac: response = await ac.get("/async-endpoint") assert response.status_code == 200 ``` Requires `pytest-asyncio`. In pyproject.toml: ```toml [tool.pytest.ini_options] asyncio_mode = "auto" ``` ## Parametr