Hur testar du FastAPI-applikationer?

Question

Accepted Answer

FastAPI är mycket testbar tack vare sin **`TestClient`** (byggd på Starlette/httpx) och sitt **dependency injection**-system, som gör att mocka beroenden är trivialt. Tester använder vanligtvis `pytest` och `TestClient` för att skicka förfrågningar till appen utan en köra server.

## Grundläggande endpoint-testning 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` skickar riktiga förfrågningar till din app in-process (ingen server behövs), så du testar hela flödet — routning, validering, serialisering — och gör assertion på statuskoder och JSON-svar.

## Åsidosätta beroenden (nyckeln till rena 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` låter dig **ersätta vilket beroende som helst** (databassession, autentisering, externa tjänster) med en testdublett — grunden för snabba, isolerade tester, vilket görs trivialt av DI-designen.

## Testning av skyddade 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
```

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

## Varför det spelar roll

Testning är essentiell för pålitliga applikationer, och FastAPI är särskilt testbar — det är viktigt att förstå hur man testar den både för kodkvalitet och eftersom ramverket är *utformat* för testbarhet.

**`TestClient`** gör det enkelt att testa det fullständiga request/response-flödet in-process (ingen server behövs), och verifierar routning, validering, serialisering och svar precis som klienter skulle uppleva dem.

Den särskilda funktionen är **beroendeoversättningar**: eftersom FastAPI använder dependency injection kan du trivilt ersätta vilket beroende som helst — databassessioner, autentisering, externa tjänster — med testdubbletter via `app.dependency_overrides`, vilket möjliggör snabba, isolerade tester utan verklig infrastruktur (denna testbarhet är en stor fördel med DI-designen).

Att kunna använda TestClient, åsidosätta beroenden för isolering (testdatabaser, mocad autentisering/tjänster), testa skyddade endpoints och strukturera en vettig teststrategi (statuskoder, svarsformer, validering, autentisering, edge cases) är viktig seniorkunskap för att bygga robusta FastAPI-applikationer.

Vältestad API:er fångar regressioner och möjliggör självsäker refaktorering, och FastAPIs testverktyg gör grundlig testning enkel, vilket gör detta till ett frekvent relevant och professionellt viktigt ämne.