ਤੁਸੀਂ FastAPI ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਜਾਂਚ ਕਿਵੇਂ ਕਰਦੇ ਹੋ?

Question

Accepted Answer

FastAPI ਆਪਣੇ **`TestClient`** (Starlette/httpx ਉੱਤੇ ਬਣਿਆ ਹੋਇਆ) ਅਤੇ ਆਪਣੇ **dependency injection** ਸਿਸਟਮ ਦੀ ਬਦੌਲਤ ਬਹੁਤ ਸੀ ਪਰੀਖਿਆ ਯੋਗ ਹੈ, ਜੋ mock dependencies ਨੂੰ ਅਸਾਨ ਬਣਾਉਂਦਾ ਹੈ। ਟੈਸਟ ਆਮ ਤੌਰ 'ਤੇ `pytest` ਅਤੇ `TestClient` ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਐਪ ਨੂੰ ਬਿਨਾਂ ਚਲ ਰਹੀ ਸਰਵਰ ਦੇ ਬੇਨਤੀਆਂ ਭੇਜਦੇ ਹਨ।

## TestClient ਦੇ ਨਾਲ ਬੁਨਿਆਦੀ endpoint ਟੈਸਟਿੰਗ

```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` ਤੁਹਾਡੀ ਐਪ ਨੂੰ in-process ਵਿੱਚ ਅਸਲ ਬੇਨਤੀਆਂ ਭੇਜਦਾ ਹੈ (ਕੋਈ ਸਰਵਰ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ), ਇਸ ਲਈ ਤੁਸੀਂ ਪੂਰੇ ਪ੍ਰਵਾਹ — routing, validation, serialization — ਦੀ ਪਰੀਖਿਆ ਕਰਦੇ ਹੋ ਅਤੇ status codes ਅਤੇ JSON responses 'ਤੇ assert ਕਰਦੇ ਹੋ।

## Dependencies ਨੂੰ override ਕਰਨਾ (ਸਾਫ਼ ਟੈਸਟਾਂ ਦੀ ਕੁੰਜੀ)

```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 ਦਾ `dependency_overrides` ਤੁਹਾਨੂੰ **ਕਿਸੇ ਵੀ dependency** (database session, auth, external services) ਨੂੰ test double ਨਾਲ **replace** ਕਰਨ ਦਿੰਦਾ ਹੈ — ਤੇਜ਼, isolated tests ਦੀ ਨਿੰਮ, DI design ਦੁਆਰਾ ਅਸਾਨ ਬਣਾਇਆ ਗਿਆ।

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

## ਟੈਸਟਿੰਗ ਰਣਨੀਤੀ

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

## ਇਹ ਕਿਉਂ ਮਹੱਤਵਪੂਰਨ ਹੈ

ਟੈਸਟਿੰਗ ਕਾਬਲ-ਭਰੋਸਾ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਜ਼ਰੂਰੀ ਹੈ, ਅਤੇ FastAPI ਖਾਸ ਤੌਰ 'ਤੇ ਪਰੀਖਿਆ ਯੋਗ ਹੈ — ਇਸ ਨੂੰ ਕਿਵੇਂ ਟੈਸਟ ਕਰਨਾ ਹੈ ਇਹ ਸਮਝਣਾ code ਗੁਣਵੱਤਾ ਅਤੇ ਇਸ ਲਈ ਜ਼ਰੂਰੀ ਹੈ ਕਿ ਫ੍ਰੇਮਵਰਕ *testability* ਲਈ design ਕੀਤਾ ਗਿਆ ਹੈ।

**`TestClient`** ਪੂਰੇ request/response flow ਦੀ in-process ਵਿੱਚ ਟੈਸਟਿੰਗ ਨੂੰ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ (ਕੋਈ ਸਰਵਰ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ), routing, validation, serialization, ਅਤੇ responses ਨੂੰ verify ਕਰਦਾ ਹੈ ਜਿਸ ਤਰੀਕੇ ਨਾਲ ਕਲਾਇਟ ਉਨ੍ਹਾਂ ਦਾ ਅਨੁਭਵ ਕਰਦੇ ਹਨ।

ਸਭ ਤੋਂ ਵਧੀਆ ਵਿਸ਼ੇਸ਼ਤਾ **dependency overrides** ਹੈ: ਕਿਉਂਕਿ FastAPI dependency injection ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ، ਤੁਸੀਂ ਕਿਸੇ ਵੀ dependency — database sessions, authentication, external services — ਨੂੰ test doubles ਨਾਲ `app.dependency_overrides` ਦੁਆਰਾ trivially replace ਕਰ ਸਕਦੇ ਹੋ, ਬਿਨਾਂ ਅਸਲ infrastructure (ਇਹ testability DI design ਦਾ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਲਾਭ ਹੈ) ਦੇ ਤੇਜ਼, isolated tests ਨੂੰ ਸਮਰਥ ਬਣਾਉਂਦਾ ਹੈ।

TestClient ਦੀ ਵਰਤੋਂ ਕਰਨਾ, dependencies ਨੂੰ isolation ਲਈ override ਕਰਨਾ (test databases, mocked auth/services), protected endpoints ਦੀ ਟੈਸਟਿੰਗ ਕਰਨਾ, ਅਤੇ ਇੱਕ sensible ਟੈਸਟਿੰਗ ਰਣਨੀਤੀ ਬਣਾਉਣਾ (status codes, response shapes, validation, auth, edge cases) ਜਾਣਨਾ robust FastAPI ਐਪਲੀਕੇਸ਼ਨਾਂ ਬਣਾਉਣ ਲਈ ਮਹੱਤਵਪੂਰਨ senior-level ਗਿਆਨ ਹੈ।

ਚੰਗੀ ਤਰੀਕੇ ਨਾਲ ਟੈਸਟ ਕੀਤੀਆਂ APIs regressions ਨੂੰ ਫੜਦੀਆਂ ਹਨ ਅਤੇ confident refactoring ਨੂੰ ਸਮਰਥ ਬਣਾਉਂਦੀਆਂ ਹਨ, ਅਤੇ FastAPI ਦੀਆਂ ਟੈਸਟਿੰਗ tools thorough ਟੈਸਟਿੰਗ ਨੂੰ straightforward ਬਣਾਉਂਦੀਆਂ ਹਨ, ਇਸ ਨੂੰ ਇੱਕ frequently-relevant, professionally-important ਵਿਸ਼ਾ ਬਣਾਉਂਦਾ ਹੈ।