Jak testujete aplikace FastAPI?

Question

Accepted Answer

FastAPI je vysoce testovatelné díky **`TestClient`** (postaveném na Starlette/httpx) a jeho **systému dependency injection**, který triviálně umožňuje mockování závislostí. Testy obvykle používají `pytest` a `TestClient` k odesílání požadavků na aplikaci bez běžícího serveru.

## Základní testování endpointů s 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
```

`TestClient` odesílá skutečné požadavky do vaší aplikace v procesu (není potřeba server), takže testujete celý tok — routing, validaci, serializaci — a kontrolujete stavové kódy a JSON odpovědi.

## Přepsání závislostí (klíč k čistým testům)

```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
```

`dependency_overrides` FastAPI vám umožňuje **nahradit jakoukoli závislost** (databázová sezení, autentizace, externí služby) testem double — základem rychlých, izolovaných testů, které jsou triviální díky designu DI.

## Testování chráněných endpointů

```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
```

## Strategie testování

```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
```

## Proč je to důležité

Testování je zásadní pro spolehlivé aplikace a FastAPI je pozoruhodně testovatelné — pochopení jeho testování je důležité jak pro kvalitu kódu, tak proto, že je framework *navržen* pro testovatelnost.

**`TestClient`** usnadňuje testování celého toku požadavek/odpověď v procesu (není potřeba server), ověřování routingu, validace, serializace a odpovědí přesně tak, jak by je zažívali klienti.

Vynikající vlastností jsou **přepsání závislostí**: protože FastAPI používá dependency injection, můžete triviálně nahradit jakoukoli závislost — databázová sezení, autentizaci, externí služby — test doubles pomocí `app.dependency_overrides`, umožňující rychlé, izolované testy bez skutečné infrastruktury (tato testovatelnost je hlavní výhodou designu DI).

Vědět, jak používat TestClient, přepisovat závislosti pro izolaci (testovací databáze, mockovaná autentizace/služby), testovat chráněné endpointy a strukturovat rozumnou strategii testování (stavové kódy, tvary odpovědí, validace, autentizace, hranichní případy) je důležité znalosti na senior úrovni pro budování robustních aplikací FastAPI.

Dobře otestovaná API chytají regrese a umožňují sebevědomý refactoring, a nástroje FastAPI pro testování činí důkladné testování přímočaré, což z tohoto tématu činí často relevantní, profesionálně důležité téma.