Wie testest du FastAPI-Anwendungen?

Question

Accepted Answer

FastAPI ist durch seine **`TestClient`** (basierend auf Starlette/httpx) und sein **Dependency-Injection**-System stark testbar, was das Mocken von Abhängigkeiten trivial macht. Tests verwenden typischerweise `pytest` und den `TestClient`, um Anfragen an die App ohne einen laufenden Server zu senden.

## Basis-Endpoint-Testing mit TestClient

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

client = TestClient(app)

def test_read_item():
    response = client.get("/items/5")            # send a request to the app in-process
    assert response.status_code == 200
    assert response.json() == {"item_id": 5}

def test_create_item():
    response = client.post("/items", json={"name": "Phone", "price": 999})
    assert response.status_code == 201
    assert response.json()["name"] == "Phone"

def test_validation_error():
    response = client.post("/items", json={"name": "Phone"})   # missing price
    assert response.status_code == 422                          # FastAPI validates automatically
```

Der `TestClient` sendet echte Anfragen an deine App im In-Process-Modus (kein Server notwendig), sodass du den vollständigen Flow testest — Routing, Validierung, Serialisierung — und Assertions auf Status-Codes und JSON-Responses machst.

## Abhängigkeiten überschreiben (der Schlüssel zu sauberen Tests)

```python
# override a dependency with a mock/test version — no real database needed
def override_get_db():
    return test_db_session

app.dependency_overrides[get_db] = override_get_db   # swap the real dependency

def test_with_test_db():
    response = client.get("/users")
    # uses the test database via the override
    app.dependency_overrides.clear()                 # reset after
```

FastAPIs `dependency_overrides` erlaubt dir, **jede Abhängigkeit** (Datenbanksession, Auth, externe Services) durch ein Test-Double zu **ersetzen** — die Grundlage für schnelle, isolierte Tests, gemacht trivial durch das DI-Design.

## Testen geschützter Endpoints

```python
def test_protected():
    # override the auth dependency to simulate a logged-in user
    app.dependency_overrides[get_current_user] = lambda: fake_user
    response = client.get("/me")
    assert response.status_code == 200
```

## Test-Strategie

```text
✓ Use a TEST database (separate, or transactions rolled back per test)
✓ Override dependencies (DB, auth, external APIs) for isolation
✓ Test: status codes, response shapes, validation (422s), auth/permissions, edge cases
✓ For async-specific code, use httpx.AsyncClient / pytest-asyncio
✓ Tools: pytest, factory libraries for test data, coverage.py
```

## Warum es wichtig ist

Testing ist essentiell für zuverlässige Anwendungen, und FastAPI ist besonders testbar — zu verstehen, wie man es testet, ist wichtig sowohl für Code-Qualität als auch, weil das Framework *für Testbarkeit designt* ist.

Der **`TestClient`** macht es einfach, den vollständigen Request/Response-Flow im In-Process-Modus zu testen (kein Server notwendig), um Routing, Validierung, Serialisierung und Responses genau so zu verifizieren, wie Clients sie erleben würden.

Das herausragende Feature sind **Dependency Overrides**: Da FastAPI Dependency Injection nutzt, kannst du trivial jede Abhängigkeit — Datenbanksessions, Authentifizierung, externe Services — durch Test-Doubles via `app.dependency_overrides` ersetzen, was schnelle, isolierte Tests ohne echte Infrastruktur ermöglicht (diese Testbarkeit ist ein großer Vorteil des DI-Designs).

Zu wissen, wie man den TestClient nutzt, Abhängigkeiten für Isolation überschreibt (Test-Datenbanken, gemockte Auth/Services), geschützte Endpoints testet und eine sinnvolle Test-Strategie strukturiert (Status-Codes, Response-Formen, Validierung, Auth, Edge-Cases) ist wichtiges Senior-Level-Wissen zum Aufbau robuster FastAPI-Anwendungen.

Gut getestete APIs fangen Regressionen ein und ermöglichen selbstbewusstes Refactoring, und FastAPIs Test-Tools machen umfassendes Testing unkompliziert, was dies zu einem häufig relevanten, beruflich wichtigen Thema macht.