तुम FastAPI अ‍ॅप्लिकेशन्सची चाचणी कसे करता?

Question

Accepted Answer

FastAPI हे **`TestClient`** (Starlette/httpx वर बनलेले) आणि त्याच्या **dependency injection** सिस्टमच्या कारणे अत्यंत चाचणीयोग्य आहे, जो मॉकिंग 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 — चाचणी कराल आणि स्थिती कोड आणि JSON प्रतिक्रियांवर assert कराल.

## Dependencies ओव्हरराइड करणे (स्वच्छ चाचण्यांची गुरुकिल्ली)

```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** (डेटाबेस सेशन, auth, बाहेरील सेवा) test double सह **बदलू** देते — हा वेगवान, विलग चाचण्यांचा पाया आहे, DI डिজाईनद्वारे साधा केलेला.

## संरक्षित 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 विशेषतः चाचणीयोग्य आहे — हे कसे चाचणी करायचे हे समजणे कोड गुणवत्ता आणि फ्रेमवर्क *चाचण्यांसाठी डिजाईन केलेल्या* या दोन्हीसाठी महत्त्वाचे आहे.

**`TestClient`** संपूर्ण request/response प्रवाहची in-process चाचणी सोपे करते (सर्व्हरची आवश्यकता नाही), routing, validation, serialization, आणि प्रतिक्रिया तसे सत्यापित करते जसे क्लायंट्सना अनुभव येतात.

उत्कृष्ट वैशिष्ट्य म्हणजे **dependency overrides**: कारण FastAPI dependency injection वापरते, तुम्ही त्रिविक्रमेण कोणताही dependency — डेटाबेस सेशन्स, प्रमाणीकरण, बाहेरील सेवा — test doubles सह `app.dependency_overrides` द्वारे बदलू शकता, वास्तविक infrastructure शिवाय वेगवान, विलग चाचण्या सक्षम करते (हे चाचणीयोगिता DI डिजाईनचा मुख्य फायदा आहे).

TestClient कसे वापरायचे, विलगीकरणासाठी dependencies कसे ओव्हरराइड करायचे (test databases, mocked auth/services), संरक्षित endpoints चाचणी कसे करायची, आणि विवेकी चाचणी रणनीति (स्थिती कोड, प्रतिक्रिया आकार, validation, auth, edge cases) कसे संरचित करायची हे जाणून घेणे senior-level ज्ञान आहे robust FastAPI अ‍ॅप्लिकेशन्स बनवण्यासाठी.

स्व-चाचणी APIs रिग्रेशन्स पकडतात आणि आत्मविश्वास रीफॅक्टरिंग सक्षम करते, आणि FastAPI च्या चाचणी साधने संपूर्ण चाचणी सरळ करतात, हा वारंवार प्रासंगिक, व्यावसायिकदृष्ट्या महत्त्वाचा विषय बनवते.