Si testoni aplikacionet FastAPI?

Question

Accepted Answer

FastAPI është shumë i testueshem falë **`TestClient`** (ndërtuar mbi Starlette/httpx) dhe sistemit të tij **dependency injection**, që e bën mockimin e varësive trivial. Testet zakonisht përdorin `pytest` dhe `TestClient` për të dërguar kërkesa në aplikacion pa një server në ekzekutim.

## Testimi bazik i endpoint-eve me 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` dërgon kërkesa të vërteta në aplikacionin tuaj në-proces (asnjë server i nevojshëm), kështu që testoni rrjedhën e plotë — routing, validim, serializim — dhe verifikoni kodet e statusit dhe përgjigjet JSON.

## Zëvendësimi i varësive (çelësi për teste të pastra)

```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` i FastAPI ju lejon të **zëvendësoni çdo varësi** (sesion baze të dhënash, autentifikim, shërbime të jashtme) me një test double — themeli i testeve të shpejta, të izoluara, bërë trivial nga dizajni DI.

## Testimi i endpoint-eve të mbrojtur

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

## Strategjia e testimit

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

## Pse ka rëndësi

Testimi është thelbësor për aplikacione të besueshme, dhe FastAPI është veçanërisht i testueshem — të kuptosh se si ta testosh atë është i rëndësishëm si për cilësinë e kodit ashtu edhe sepse korniza është *e dizajnuar* për testueshmëri.

**`TestClient`** e bën të lehtë të testosh rrjedhën e plotë request/response në-proces (asnjë server i nevojshëm), duke verifikuar routing, validim, serializim, dhe përgjigjet ashtu siç do t'i përjetonin klientët.

veçoria më e dallueshme është **zëvendësimi i varësive**: sepse FastAPI përdor dependency injection, mund trivialit të zëvendësosh çdo varësi — sesionet bazë të dhënash, autentifikimin, shërbimet e jashtme — me test doubles përmes `app.dependency_overrides`, duke mundësuar teste të shpejta, të izoluara pa infrastrukturë reale (kjo testueshmëri është një përfitim i madh i dizajnit DI).

Dija se si të përdorësh TestClient, të zëvendësosh varësitë për izolim (baza testimi të dhënash, autentifikim/shërbime të finguar), të testosh endpoint-e të mbrojtur, dhe të strukturosh një strategji testimi të arsyeshme (kodet e statusit, format përgjigje, validim, autentifikim, raste skaje) është njohuri e rëndësishme për nivel senior për ndërtimin e aplikacioneve FastAPI të forta.

APItë e testuar mirë zbulojnë regresionet dhe mundësojnë refactoring-un me besim, dhe mjetet e testimit të FastAPI e bëjnë testimin gjithëpërfshirës të drejtpërdrejtë, duke e bërë këtë një temë frekuentisht-relevan dhe profesionalisht-e rëndësishme.