How do you test FastAPI applications?

Question

Accepted Answer

FastAPI is highly testable thanks to its **`TestClient`** (built on Starlette/httpx) and its **dependency injection** system, which makes mocking dependencies trivial. Tests typically use `pytest` and the `TestClient` to send requests to the app without a running server.

## Basic endpoint testing with 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
```

The `TestClient` sends real requests to your app in-process (no server needed), so you test the full flow — routing, validation, serialization — and assert on status codes and JSON responses.

## Overriding dependencies (the key to clean 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
```

FastAPI's `dependency_overrides` lets you **replace any dependency** (database session, auth, external services) with a test double — the foundation of fast, isolated tests, made trivial by the DI design.

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

## Testing strategy

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

## Why it matters

Testing is essential for reliable applications, and FastAPI is notably testable — understanding how to test it is important both for code quality and because the framework is *designed* for testability.

The **`TestClient`** makes it easy to test the full request/response flow in-process (no server needed), verifying routing, validation, serialization, and responses just as clients would experience them.

The standout feature is **dependency overrides**: because FastAPI uses dependency injection, you can trivially replace any dependency — database sessions, authentication, external services — with test doubles via `app.dependency_overrides`, enabling fast, isolated tests without real infrastructure (this testability is a major benefit of the DI design).

Knowing how to use the TestClient, override dependencies for isolation (test databases, mocked auth/services), test protected endpoints, and structure a sensible testing strategy (status codes, response shapes, validation, auth, edge cases) is important senior-level knowledge for building robust FastAPI applications.

Well-tested APIs catch regressions and enable confident refactoring, and FastAPI's testing tools make thorough testing straightforward, making this a frequently-relevant, professionally-important topic.