Bagaimana anda menguji aplikasi FastAPI?

Question

Accepted Answer

FastAPI sangat boleh diuji berkat **`TestClient`**-nya (dibina di atas Starlette/httpx) dan sistem **suntikan kebergantungan (dependency injection)**-nya, yang menjadikan mengolok-olok (mocking) kebergantungan amat mudah. Ujian biasanya menggunakan `pytest` dan `TestClient` untuk menghantar permintaan ke aplikasi tanpa pelayan yang sedang berjalan.

## Ujian endpoint asas dengan 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` menghantar permintaan sebenar ke aplikasi anda dalam-proses (tiada pelayan diperlukan), jadi anda menguji keseluruhan aliran — penghalaan, validasi, serialisasi — dan menegaskan kod status serta respons JSON.

## Menggantikan kebergantungan (kunci kepada ujian yang bersih)

```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 membenarkan anda **menggantikan mana-mana kebergantungan** (sesi pangkalan data, auth, perkhidmatan luaran) dengan pengganti ujian (test double) — asas kepada ujian yang pantas dan terasing, dibuat mudah oleh reka bentuk DI.

## Menguji endpoint yang dilindungi

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

## Strategi ujian

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

## Mengapa ia penting

Ujian adalah penting untuk aplikasi yang boleh dipercayai, dan FastAPI ketara boleh diuji — memahami cara mengujinya adalah penting kedua-duanya untuk kualiti kod dan kerana rangka kerja itu *direka* untuk kebolehujian.

**`TestClient`** menjadikannya mudah untuk menguji keseluruhan aliran permintaan/respons dalam-proses (tiada pelayan diperlukan), mengesahkan penghalaan, validasi, serialisasi, dan respons sama seperti yang akan dialami oleh klien.

Ciri yang menonjol ialah **penggantian kebergantungan (dependency overrides)**: kerana FastAPI menggunakan suntikan kebergantungan, anda boleh dengan mudah menggantikan mana-mana kebergantungan — sesi pangkalan data, pengesahan, perkhidmatan luaran — dengan pengganti ujian melalui `app.dependency_overrides`, membolehkan ujian yang pantas dan terasing tanpa infrastruktur sebenar (kebolehujian ini ialah faedah utama reka bentuk DI).

Mengetahui cara menggunakan TestClient, menggantikan kebergantungan untuk pengasingan (pangkalan data ujian, auth/perkhidmatan yang diolok-olok), menguji endpoint yang dilindungi, dan menstrukturkan strategi ujian yang munasabah (kod status, bentuk respons, validasi, auth, kes pinggiran) ialah pengetahuan peringkat senior yang penting untuk membina aplikasi FastAPI yang teguh.

API yang diuji dengan baik menangkap regresi dan membolehkan pemfaktoran semula dengan yakin, dan alat ujian FastAPI menjadikan ujian menyeluruh mudah, menjadikan ini topik yang kerap relevan dan penting dari segi profesional.