Hvordan tester du FastAPI-applikasjoner?

Question

Accepted Answer

FastAPI er svært testbar takket være sitt **`TestClient`** (bygget på Starlette/httpx) og sitt **dependency injection**-system, som gjør mocking av avhengigheter trivielt. Tester bruker typisk `pytest` og `TestClient` for å sende forespørsler til appen uten en kjørende server.

## Grunnleggende endepunkt-testing med 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` sender ekte forespørsler til appen in-process (ingen server nødvendig), så du tester den fulle flyten — ruting, validering, serialisering — og asserterer på statuskoder og JSON-respons.

## Overstyring av avhengigheter (nøkkelen til rene tester)

```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` lar deg **erstatte hvilken som helst avhengighet** (databaseøkt, autentisering, eksterne tjenester) med en test double — grunnlaget for raske, isolerte tester, gjort trivielt av DI-designet.

## Testing av beskyttede endepunkter

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

## Teststrategi

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

## Hvorfor det er viktig

Testing er essensielt for pålitelige applikasjoner, og FastAPI er særlig testbar — å forstå hvordan man tester det, er viktig både for kodekvalitet og fordi rammeverket er *designet* for testbarhet.

**`TestClient`** gjør det enkelt å teste den fulle request/response-flyten in-process (ingen server nødvendig), og verifiserer ruting, validering, serialisering og respons akkurat som klienter ville oppleve dem.

Detaljmerkevaren er **dependency overrides**: fordi FastAPI bruker dependency injection, kan du trivielt erstatte hvilken som helst avhengighet — databaseøkter, autentisering, eksterne tjenester — med test doubles via `app.dependency_overrides`, noe som muliggjør raske, isolerte tester uten ekte infrastruktur (denne testbarheten er en stor fordel med DI-designet).

Å vite hvordan man bruker TestClient, overstyrer avhengigheter for isolasjon (testdatabaser, mocket auth/tjenester), tester beskyttede endepunkter, og strukturerer en fornuftig teststrategi (statuskoder, responsformer, validering, autentisering, edge cases) er viktig kunnskap på seniornivå for å bygge robuste FastAPI-applikasjoner.

Vel-testede APIer oppdager regresjoner og muliggjør selvsikker refaktorering, og FastAPIs testverktøy gjør grundig testing rett fram, noe som gjør dette til et hyppig relevant og profesjonelt viktig tema.