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

Question

IT Interview Practice · 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 च्या चाचणी साधने संपूर्ण चाचणी सरळ करतात, हा वारंवार प्रासंगिक, व्यावसायिकदृष्ट्या महत्त्वाचा विषय बनवते.

TestClient सह मूळ endpoint चाचणी

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

संरक्षित endpoints ची चाचणी

चाचणी रणनीति

हे का महत्त्वाचे आहे

संबंधित प्रश्न