Kako testirate FastAPI aplikacije?

Question

Accepted Answer

FastAPI je zelo testabilen zahvaljujoč **`TestClient`** (zgrajen na Starlette/httpx) in njegovemu sistemu **vbrizgavanja odvisnosti**, kar naredi mocking odvisnosti trivialen. Testi običajno uporabljajo `pytest` in `TestClient` za pošiljanje zahtevkov aplikaciji brez zagnanega strežnika.

## Osnovni test končne točke 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` pošlje prave zahtevke vaši aplikaciji in-process (server ni potreben), zato testirate celoten tok — usmerjanje, validacijo, serializacijo — in potrjujete kode stanja ter JSON odgovore.

## Preglasitev odvisnosti (ključ do čistih testov)

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

FastAPI-jev `dependency_overrides` vam omogoči **zamenjavo katere koli odvisnosti** (seansa podatkovne baze, avtentifikacija, zunanji servisi) s testnim dvojnikom — temeljom hitrih, izoliranih testov, ki so trivialni zaradi oblikovanja DI.

## Testiranje zaščitenih končnih točk

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

## Strategija testiranja

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

## Zakaj je to pomembno

Testiranje je bistveno za zanesljive aplikacije, FastAPI pa je posebej testabilen — razumevanje, kako ga testirati, je pomembno tako za kakovost kode kot zato, ker je ogrodje *zasnovano* za testabilnost.

**`TestClient`** olajša testiranje celotnega toka zahtevek/odgovor in-process (server ni potreben), s preverjanjem usmerjanja, validacije, serializacije in odgovorov, tako kot bi jih doživeli odjemalci.

Izstopajočo lastnost predstavljajo **preglasitve odvisnosti**: ker FastAPI uporablja vbrizgavanje odvisnosti, lahko trivialno zamenjate katero koli odvisnost — seans podatkovne baze, avtentifikacijo, zunanje storitve — s testnimi dvojniki prek `app.dependency_overrides`, kar omogoči hitre, izolirane teste brez prave infrastrukture (ta testabilnost je velika prednost oblikovanja DI).

Znanje, kako uporabljati TestClient, preglasiti odvisnosti za izolacijo (testne podatkovne baze, mocked avtentifikacija/storitve), testirati zaščitene končne točke in strukturirati smiselno strategijo testiranja (kodi stanja, oblike odgovorov, validacija, avtentifikacija, mejni primeri), je pomembno znanje višje ravni za gradnjo robustnih FastAPI aplikacij.

Dobro testirane API-je lovijo regresije in omogočajo zaupano refaktoriranje, orodja FastAPI za testiranje pa naredi temeljito testiranje pregledno, kar to temo naredi pogosto relevantno, strokovno pomembno temo.