Drills: Testing Python & FastAPI

from app.text import slugify

def test_slugify_basic():
    assert slugify("Hello World") == "hello-world"

Run with pytest -k slugify -v. The function name must start with test_ or pytest won't discover it.

import pytest

@pytest.fixture
def sample_user():
    return {"id": 1, "name": "Sam"}

def test_user_name(sample_user):   # param name == fixture name
    assert sample_user["name"] == "Sam"

pytest injects the fixture by matching the parameter name. Move it to conftest.py and every test file can use it with no import.

import pytest
from app.text import slugify

@pytest.mark.parametrize("raw, expected", [
    ("A B", "a-b"),
    ("X", "x"),
    ("Two Words", "two-words"),
])
def test_slugify_cases(raw, expected):
    assert slugify(raw) == expected

Three rows = three independent tests. A failing one is reported as test_slugify_cases[X-x] so you know exactly which case broke.

from app.rag import summarize

def test_summarize_mocks_llm(monkeypatch):
    monkeypatch.setattr("app.rag.call_llm",
                        lambda prompt: "fake")
    assert summarize("long document text") == "fake"

Patch where the name is used (app.rag.call_llm), not where it's defined. monkeypatch auto-restores after the test — no cleanup needed. The same fixture sets env vars: monkeypatch.setenv("OPENAI_API_KEY", "x").

import pytest
from app.rag import embed_text

@pytest.mark.asyncio
async def test_embed_length():
    vec = await embed_text("hello")
    assert len(vec) == 1536

Without @pytest.mark.asyncio (from pytest-asyncio) the coroutine is never awaited and the test silently does nothing.

from fastapi.testclient import TestClient
from app.main import app

client = TestClient(app)

def test_health():
    resp = client.get("/health")
    assert resp.status_code == 200
    assert resp.json() == {"status": "ok"}

Always assert the status code before the body — a 422 also returns valid JSON, so a body-only check can pass against the wrong response.

from fastapi.testclient import TestClient
from app.main import app
from app.db import get_db

def test_ask_with_fake_db(fake_session):
    def override():
        yield fake_session
    app.dependency_overrides[get_db] = override
    try:
        resp = TestClient(app).post("/ask",
            json={"question": "hi"})
        assert resp.status_code == 200
    finally:
        app.dependency_overrides.clear()   # never leak

The finally (or a client fixture that clears on teardown) is essential — a stray override poisons every later test. The same mechanism swaps get_current_user for a fixed test user.

tests/conftest.py

import pytest
from fastapi.testclient import TestClient
from app.main import app
from app.db import get_db
from app.auth import get_current_user

@pytest.fixture
def client(test_session, monkeypatch):
    monkeypatch.setattr("app.rag.call_llm",
                        lambda prompt: "Grounded answer.")
    monkeypatch.setattr("app.rag.embed_text",
                        lambda text: [0.1] * 1536)
    app.dependency_overrides[get_db] = lambda: (yield test_session)
    yield TestClient(app)
    app.dependency_overrides.clear()

@pytest.fixture
def auth_client(client):
    app.dependency_overrides[get_current_user] = lambda: {"id": 1}
    return client

tests/test_auth_ask.py

def test_ask_requires_auth(client):
    resp = client.post("/ask", json={"question": "hi"})
    assert resp.status_code == 401

def test_authed_ask_returns_answer(auth_client):
    resp = auth_client.post("/ask",
        json={"question": "What is RAG?"})
    assert resp.status_code == 200
    assert resp.json()["answer"] == "Grounded answer."

The unauthenticated test uses the bare client (real auth runs → 401). The happy-path test uses auth_client, which layers an auth override on top. The LLM is mocked in both, so the suite is fast and deterministic — exactly what CI needs.