FastAPI ಟೆಸ್ಟಿಂಗ್‌ನಲ್ಲಿ ಪ್ರಾವೀಣ್ಯತೆ: TestClientಗೆ ಒಂದು ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ

ಪೈಥಾನ್‌ನೊಂದಿಗೆ ಉತ್ತಮ-ಕಾರ್ಯಕ್ಷಮತೆಯ APIಗಳನ್ನು ನಿರ್ಮಿಸಲು FastAPI ಒಂದು ಪ್ರಮುಖ ಫ್ರೇಮ್‌ವರ್ಕ್ ಆಗಿ ಹೊರಹೊಮ್ಮಿದೆ. ಅದರ ವೇಗ, ಬಳಕೆಯ ಸುಲಭತೆ ಮತ್ತು ಸ್ವಯಂಚಾಲಿತ ಡೇಟಾ ಮೌಲ್ಯೀಕರಣವು ವಿಶ್ವಾದ್ಯಂತ ಡೆವಲಪರ್‌ಗಳಲ್ಲಿ ಇದನ್ನು ಮೆಚ್ಚಿನದಾಗಿಸಿದೆ. ಆದಾಗ್ಯೂ, ಉತ್ತಮವಾಗಿ ನಿರ್ಮಿಸಲಾದ API ಅದರ ಪರೀಕ್ಷೆಗಳಷ್ಟೇ ಉತ್ತಮವಾಗಿರುತ್ತದೆ. ಸಂಪೂರ್ಣ ಪರೀಕ್ಷೆಯು ನಿಮ್ಮ API ನಿರೀಕ್ಷೆಯಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಒತ್ತಡದಲ್ಲಿ ಸ್ಥಿರವಾಗಿರುತ್ತದೆ ಮತ್ತು ಉತ್ಪಾದನೆಗೆ ವಿಶ್ವಾಸದಿಂದ ನಿಯೋಜಿಸಬಹುದು ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ ನಿಮ್ಮ API ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಪರೀಕ್ಷಿಸಲು FastAPIಯ TestClient ಅನ್ನು ಬಳಸುವುದರ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತದೆ.

FastAPI ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಟೆಸ್ಟಿಂಗ್ ಏಕೆ ಮುಖ್ಯ?

ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿ ಜೀವನಚಕ್ರದಲ್ಲಿ ಪರೀಕ್ಷೆ ಒಂದು ನಿರ್ಣಾಯಕ ಹಂತವಾಗಿದೆ. ಇದು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ:

• ದೋಷಗಳನ್ನು ಬೇಗನೆ ಗುರುತಿಸಿ: ಉತ್ಪಾದನೆಯನ್ನು ತಲುಪುವ ಮೊದಲು ದೋಷಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಿ, ಸಮಯ ಮತ್ತು ಸಂಪನ್ಮೂಲಗಳನ್ನು ಉಳಿಸಿ.
• ಕೋಡ್ ಗುಣಮಟ್ಟವನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ: ಉತ್ತಮ-ರಚನಾತ್ಮಕ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಕೋಡ್ ಅನ್ನು ಉತ್ತೇಜಿಸಿ.
• ರಿಗ್ರೆಷನ್‌ಗಳನ್ನು ತಡೆಯಿರಿ: ಹೊಸ ಬದಲಾವಣೆಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕಾರ್ಯವನ್ನು ಹಾಳುಮಾಡುವುದಿಲ್ಲ ಎಂದು ಖಾತರಿಪಡಿಸಿ.
• API ವಿಶ್ವಾಸಾರ್ಹತೆಯನ್ನು ಸುಧಾರಿಸಿ: APIಯ ಸ್ಥಿರತೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ವಿಶ್ವಾಸವನ್ನು ನಿರ್ಮಿಸಿ.
• ಸಹಯೋಗವನ್ನು ಸುಲಭಗೊಳಿಸಿ: ಇತರ ಡೆವಲಪರ್‌ಗಳಿಗೆ ನಿರೀಕ್ಷಿತ ನಡವಳಿಕೆಯ ಸ್ಪಷ್ಟ ದಾಖಲಾತಿಯನ್ನು ಒದಗಿಸಿ.

FastAPIಯ TestClient ಅನ್ನು ಪರಿಚಯಿಸಲಾಗುತ್ತಿದೆ

FastAPI ಅಂತರ್ನಿರ್ಮಿತ TestClient ಅನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದು ನಿಮ್ಮ API ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ. TestClient ಪೂರ್ಣ ಪ್ರಮಾಣದ ಸರ್ವರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸದೆ ನಿಮ್ಮ APIಗೆ ವಿನಂತಿಗಳನ್ನು ಕಳುಹಿಸಬಲ್ಲ ಹಗುರವಾದ ಕ್ಲೈಂಟ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಇದು ಪರೀಕ್ಷೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ವೇಗವಾಗಿ ಮತ್ತು ಹೆಚ್ಚು ಅನುಕೂಲಕರವಾಗಿಸುತ್ತದೆ.

TestClientನ ಪ್ರಮುಖ ವೈಶಿಷ್ಟ್ಯಗಳು:

• HTTP ವಿನಂತಿಗಳನ್ನು ಅನುಕರಿಸುತ್ತದೆ: ನಿಮ್ಮ APIಗೆ GET, POST, PUT, DELETE ಮತ್ತು ಇತರ HTTP ವಿನಂತಿಗಳನ್ನು ಕಳುಹಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
• ಡೇಟಾ ಸೀರಿಯಲೈಸೇಶನ್ ಅನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ: ವಿನಂತಿಯ ಡೇಟಾವನ್ನು (ಉದಾ., JSON ಪೇಲೋಡ್‌ಗಳು) ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸೀರಿಯಲೈಸ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆ ಡೇಟಾವನ್ನು ಡಿಸೀರಿಯಲೈಸ್ ಮಾಡುತ್ತದೆ.
• ಅಸರ್ಷನ್ ವಿಧಾನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ: ಪ್ರತಿಕ್ರಿಯೆಗಳ ಸ್ಟೇಟಸ್ ಕೋಡ್, ಹೆಡರ್‌ಗಳು ಮತ್ತು ವಿಷಯವನ್ನು ಪರಿಶೀಲಿಸಲು ಅನುಕೂಲಕರ ವಿಧಾನಗಳನ್ನು ನೀಡುತ್ತದೆ.
• ಅಸಿಂಕ್ರೋನಸ್ ಟೆಸ್ಟಿಂಗ್ ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ: FastAPIಯ ಅಸಿಂಕ್ರೋನಸ್ ಸ್ವಭಾವದೊಂದಿಗೆ ಮನಬಂದಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.
• ಟೆಸ್ಟಿಂಗ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳೊಂದಿಗೆ ಸಂಯೋಜನೆಗೊಳ್ಳುತ್ತದೆ: pytest ಮತ್ತು unittest ನಂತಹ ಜನಪ್ರಿಯ ಪೈಥಾನ್ ಟೆಸ್ಟಿಂಗ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳೊಂದಿಗೆ ಸುಲಭವಾಗಿ ಸಂಯೋಜನೆಗೊಳ್ಳುತ್ತದೆ.

ನಿಮ್ಮ ಟೆಸ್ಟಿಂಗ್ ಪರಿಸರವನ್ನು ಸ್ಥಾಪಿಸುವುದು

ನೀವು ಪರೀಕ್ಷೆಯನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು, ನಿಮ್ಮ ಟೆಸ್ಟಿಂಗ್ ಪರಿಸರವನ್ನು ಸ್ಥಾಪಿಸಬೇಕಾಗುತ್ತದೆ. ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಅಗತ್ಯವಾದ ಡಿಪೆಂಡೆನ್ಸಿಗಳನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡುವುದು ಮತ್ತು ನಿಮ್ಮ ಟೆಸ್ಟಿಂಗ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.

ಅನುಸ್ಥಾಪನೆ

ಮೊದಲಿಗೆ, ನೀವು FastAPI ಮತ್ತು pytest ಅನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿದ್ದೀರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ನೀವು ಅವುಗಳನ್ನು pip ಬಳಸಿ ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಬಹುದು:

            pip install fastapi pytest httpx
            

              
                Copy
              
            
          

httpx ಎಂಬುದು FastAPI ತೆರೆಮರೆಯಲ್ಲಿ ಬಳಸುವ HTTP ಕ್ಲೈಂಟ್ ಆಗಿದೆ. TestClient FastAPIಯ ಭಾಗವಾಗಿದ್ದರೂ, httpx ಅನ್ನು ಸಹ ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿರುವುದು ಸುಗಮ ಪರೀಕ್ಷೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಕೆಲವು ಟ್ಯುಟೋರಿಯಲ್‌ಗಳು requests ಅನ್ನು ಸಹ ಉಲ್ಲೇಖಿಸುತ್ತವೆ, ಆದಾಗ್ಯೂ, httpx FastAPIಯ ಅಸಿಂಕ್ ಸ್ವಭಾವಕ್ಕೆ ಹೆಚ್ಚು ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ.

ಉದಾಹರಣೆ FastAPI ಅಪ್ಲಿಕೇಶನ್

ಪರೀಕ್ಷೆಗಾಗಿ ನಾವು ಬಳಸಬಹುದಾದ ಸರಳ FastAPI ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರಚಿಸೋಣ:

            from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
 name: str
 description: str | None = None
 price: float
 tax: float | None = None

@app.get("/")
async def read_root():
 return {"message": "Hello World"}

@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str | None = None):
 return {"item_id": item_id, "q": q}

@app.post("/items/")
async def create_item(item: Item):
 return item

            

              
                Copy
              
            
          

ಈ ಕೋಡ್ ಅನ್ನು main.py ಎಂದು ಉಳಿಸಿ. ಈ ಅಪ್ಲಿಕೇಶನ್ ಮೂರು ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ:

• /: "Hello World" ಸಂದೇಶವನ್ನು ಹಿಂತಿರುಗಿಸುವ ಸರಳ GET ಎಂಡ್‌ಪಾಯಿಂಟ್.
• /items/{item_id}: ಅದರ IDಯ ಆಧಾರದ ಮೇಲೆ ಐಟಂ ಅನ್ನು ಹಿಂತಿರುಗಿಸುವ GET ಎಂಡ್‌ಪಾಯಿಂಟ್.
• /items/: ಹೊಸ ಐಟಂ ಅನ್ನು ರಚಿಸುವ POST ಎಂಡ್‌ಪಾಯಿಂಟ್.

ನಿಮ್ಮ ಮೊದಲ ಪರೀಕ್ಷೆಯನ್ನು ಬರೆಯುವುದು

ಈಗ ನೀವು FastAPI ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಹೊಂದಿದ್ದೀರಿ, ನೀವು TestClient ಬಳಸಿ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯಲು ಪ್ರಾರಂಭಿಸಬಹುದು. main.py ಇರುವ ಅದೇ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ test_main.py ಎಂಬ ಹೊಸ ಫೈಲ್ ಅನ್ನು ರಚಿಸಿ.

            from fastapi.testclient import TestClient
from .main import app

client = TestClient(app)

def test_read_root():
 response = client.get("/")
 assert response.status_code == 200
 assert response.json() == {"message": "Hello World"}

            

              
                Copy
              
            
          

ಈ ಪರೀಕ್ಷೆಯಲ್ಲಿ:

• ನಾವು TestClient ಮತ್ತು FastAPI app ಇನ್‌ಸ್ಟೆನ್ಸ್ ಅನ್ನು ಇಂಪೋರ್ಟ್ ಮಾಡುತ್ತೇವೆ.
• ನಾವು app ಅನ್ನು ಪಾಸ್ ಮಾಡಿ TestClientನ ಇನ್‌ಸ್ಟೆನ್ಸ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ.
• ನಾವು test_read_root ಎಂಬ ಟೆಸ್ಟ್ ಫಂಕ್ಷನ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ.
• ಟೆಸ್ಟ್ ಫಂಕ್ಷನ್ ಒಳಗೆ, ರೂಟ್ ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗೆ GET ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸಲು ನಾವು client.get("/") ಅನ್ನು ಬಳಸುತ್ತೇವೆ.
• ನಾವು ಪ್ರತಿಕ್ರಿಯೆ ಸ್ಟೇಟಸ್ ಕೋಡ್ 200 (OK) ಎಂದು ಖಚಿತಪಡಿಸುತ್ತೇವೆ.
• ನಾವು ಪ್ರತಿಕ್ರಿಯೆಯ JSON {"message": "Hello World"} ಗೆ ಸಮನಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತೇವೆ.

pytest ನೊಂದಿಗೆ ನಿಮ್ಮ ಪರೀಕ್ಷೆಗಳನ್ನು ನಡೆಸುವುದು

ನಿಮ್ಮ ಪರೀಕ್ಷೆಗಳನ್ನು ನಡೆಸಲು, ನಿಮ್ಮ test_main.py ಫೈಲ್ ಇರುವ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಟರ್ಮಿನಲ್ ತೆರೆದು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿ:

            pytest
            

              
                Copy
              
            
          

pytest ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಪರೀಕ್ಷೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪತ್ತೆಹಚ್ಚಿ ನಡೆಸುತ್ತದೆ. ನೀವು ಈ ರೀತಿಯ ಔಟ್‌ಪುಟ್ ಅನ್ನು ನೋಡಬೇಕು:

            ============================= test session starts ==============================
platform darwin -- Python 3.9.6, pytest-6.2.5, py-1.11.0, pluggy-1.0.0
rootdir: /path/to/your/project
collected 1 item

test_main.py .

============================== 1 passed in 0.01s ===============================
            

              
                Copy
              
            
          

ವಿವಿಧ HTTP ವಿಧಾನಗಳನ್ನು ಪರೀಕ್ಷಿಸುವುದು

TestClient GET, POST, PUT, DELETE, ಮತ್ತು PATCH ಸೇರಿದಂತೆ ಎಲ್ಲಾ ಪ್ರಮಾಣಿತ HTTP ವಿಧಾನಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ. ಈ ಪ್ರತಿಯೊಂದು ವಿಧಾನವನ್ನು ಹೇಗೆ ಪರೀಕ್ಷಿಸುವುದು ಎಂದು ನೋಡೋಣ.

GET ವಿನಂತಿಗಳನ್ನು ಪರೀಕ್ಷಿಸುವುದು

ಹಿಂದಿನ ವಿಭಾಗದಲ್ಲಿ ನಾವು ಈಗಾಗಲೇ GET ವಿನಂತಿಯನ್ನು ಪರೀಕ್ಷಿಸುವ ಉದಾಹರಣೆಯನ್ನು ನೋಡಿದ್ದೇವೆ. ಇಲ್ಲಿ ಇನ್ನೊಂದು ಉದಾಹರಣೆಯಿದೆ, /items/{item_id} ಎಂಡ್‌ಪಾಯಿಂಟ್ ಅನ್ನು ಪರೀಕ್ಷಿಸುವುದು:

            def test_read_item():
 response = client.get("/items/1?q=test")
 assert response.status_code == 200
 assert response.json() == {"item_id": 1, "q": "test"}

            

              
                Copy
              
            
          

ಈ ಪರೀಕ್ಷೆಯು /items/1 ಗೆ q=test ಎಂಬ ಕ್ವೆರಿ ಪ್ಯಾರಾಮೀಟರ್‌ನೊಂದಿಗೆ GET ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸುತ್ತದೆ. ನಂತರ ಇದು ಪ್ರತಿಕ್ರಿಯೆ ಸ್ಟೇಟಸ್ ಕೋಡ್ 200 ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆ JSON ನಿರೀಕ್ಷಿತ ಡೇಟಾವನ್ನು ಹೊಂದಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

POST ವಿನಂತಿಗಳನ್ನು ಪರೀಕ್ಷಿಸುವುದು

POST ವಿನಂತಿಯನ್ನು ಪರೀಕ್ಷಿಸಲು, ನೀವು ವಿನಂತಿಯ ಬಾಡಿಯಲ್ಲಿ ಡೇಟಾವನ್ನು ಕಳುಹಿಸಬೇಕಾಗುತ್ತದೆ. TestClient ಡೇಟಾವನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ JSON ಗೆ ಸೀರಿಯಲೈಸ್ ಮಾಡುತ್ತದೆ.

            def test_create_item():
 item_data = {"name": "Example Item", "description": "A test item", "price": 9.99, "tax": 1.00}
 response = client.post("/items/", json=item_data)
 assert response.status_code == 200
 assert response.json() == item_data

            

              
                Copy
              
            
          

ಈ ಪರೀಕ್ಷೆಯಲ್ಲಿ:

• ನಾವು ಹೊಸ ಐಟಂಗಾಗಿ ಡೇಟಾವನ್ನು ಹೊಂದಿರುವ item_data ಎಂಬ ಡಿಕ್ಷನರಿಯನ್ನು ರಚಿಸುತ್ತೇವೆ.
• /items/ ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗೆ POST ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸಲು ನಾವು client.post("/items/", json=item_data) ಅನ್ನು ಬಳಸುತ್ತೇವೆ, item_data ಅನ್ನು JSON ಪೇಲೋಡ್ ಆಗಿ ರವಾನಿಸುತ್ತೇವೆ.
• ನಾವು ಪ್ರತಿಕ್ರಿಯೆ ಸ್ಟೇಟಸ್ ಕೋಡ್ 200 ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆ JSON item_data ಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತೇವೆ.

PUT, DELETE, ಮತ್ತು PATCH ವಿನಂತಿಗಳನ್ನು ಪರೀಕ್ಷಿಸುವುದು

PUT, DELETE, ಮತ್ತು PATCH ವಿನಂತಿಗಳನ್ನು ಪರೀಕ್ಷಿಸುವುದು POST ವಿನಂತಿಗಳನ್ನು ಪರೀಕ್ಷಿಸಿದಂತೆಯೇ ಇರುತ್ತದೆ. ನೀವು TestClient ನಲ್ಲಿ ಅನುಗುಣವಾದ ವಿಧಾನಗಳನ್ನು ಬಳಸುತ್ತೀರಿ:

            def test_update_item():
 item_data = {"name": "Updated Item", "description": "An updated test item", "price": 19.99, "tax": 2.00}
 response = client.put("/items/1", json=item_data)
 assert response.status_code == 200
 # Add assertions for the expected response

def test_delete_item():
 response = client.delete("/items/1")
 assert response.status_code == 200
 # Add assertions for the expected response

def test_patch_item():
 item_data = {"price": 29.99}
 response = client.patch("/items/1", json=item_data)
 assert response.status_code == 200
 # Add assertions for the expected response
            

              
                Copy
              
            
          

ಪ್ರತಿಕ್ರಿಯೆಗಳು ನಿರೀಕ್ಷೆಯಂತೆ ಇರುವುದನ್ನು ಪರಿಶೀಲಿಸಲು ಅಸರ್ಷನ್‌ಗಳನ್ನು ಸೇರಿಸಲು ಮರೆಯದಿರಿ.

ಸುಧಾರಿತ ಪರೀಕ್ಷಾ ತಂತ್ರಗಳು

TestClient ಹಲವಾರು ಸುಧಾರಿತ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ನೀಡುತ್ತದೆ, ಇದು ಹೆಚ್ಚು ಸಮಗ್ರ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಡಿಪೆಂಡೆನ್ಸಿಗಳೊಂದಿಗೆ ಪರೀಕ್ಷೆ

FastAPIಯ ಡಿಪೆಂಡೆನ್ಸಿ ಇಂಜೆಕ್ಷನ್ ಸಿಸ್ಟಮ್ ನಿಮ್ಮ API ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗಳಿಗೆ ಸುಲಭವಾಗಿ ಡಿಪೆಂಡೆನ್ಸಿಗಳನ್ನು ಇಂಜೆಕ್ಟ್ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ. ಪರೀಕ್ಷಿಸುವಾಗ, ಅಣಕು ಅಥವಾ ಪರೀಕ್ಷಾ-ನಿರ್ದಿಷ್ಟ ಅನುಷ್ಠಾನಗಳನ್ನು ಒದಗಿಸಲು ನೀವು ಈ ಡಿಪೆಂಡೆನ್ಸಿಗಳನ್ನು ಅತಿಕ್ರಮಿಸಲು ಬಯಸಬಹುದು.

ಉದಾಹರಣೆಗೆ, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕವನ್ನು ಅವಲಂಬಿಸಿದೆ ಎಂದು ಭಾವಿಸೋಣ. ನಿಮ್ಮ ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ಇನ್-ಮೆಮೊರಿ ಡೇಟಾಬೇಸ್ ಬಳಸಲು ನೀವು ಡೇಟಾಬೇಸ್ ಡಿಪೆಂಡೆನ್ಸಿಯನ್ನು ಅತಿಕ್ರಮಿಸಬಹುದು:

            from typing import Annotated

from fastapi import Depends, FastAPI, HTTPException, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker, declarative_base, Session

# Database Configuration
DATABASE_URL = "sqlite:///./test.db"  # In-memory database for testing
engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()

# Define User Model
class User(Base):
 __tablename__ = "users"

 id = Column(Integer, primary_key=True, index=True)
 username = Column(String, unique=True, index=True)
 password = Column(String)

Base.metadata.create_all(bind=engine)

# FastAPI App
app = FastAPI()

# Dependency to get the database session
def get_db():
 db = TestingSessionLocal()
 try:
 yield db
 finally:
 db.close()

# Endpoint to create a user
@app.post("/users/")
async def create_user(username: str, password: str, db: Session = Depends(get_db)):
 db_user = User(username=username, password=password)
 db.add(db_user)
 db.commit()
 db.refresh(db_user)
 return db_user

            

              
                Copy
              
            
          

            from fastapi.testclient import TestClient
from .main import app, get_db, Base, engine, TestingSessionLocal

client = TestClient(app)

# Override the database dependency for testing

def override_get_db():
 try:
 db = TestingSessionLocal()
 yield db
 finally:
 db.close()

app.dependency_overrides[get_db] = override_get_db

def test_create_user():
 # First, ensure the tables are created, which may not happen by default
 Base.metadata.create_all(bind=engine) # important: create the tables in the test db
 response = client.post("/users/", params={"username": "testuser", "password": "password123"})
 assert response.status_code == 200
 assert response.json()["username"] == "testuser"

 # Clean up the override after the test if needed
app.dependency_overrides = {}

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯು get_db ಡಿಪೆಂಡೆನ್ಸಿಯನ್ನು ಇನ್-ಮೆಮೊರಿ SQLite ಡೇಟಾಬೇಸ್‌ಗೆ ಸೆಶನ್ ಹಿಂತಿರುಗಿಸುವ ಪರೀಕ್ಷಾ-ನಿರ್ದಿಷ್ಟ ಫಂಕ್ಷನ್‌ನೊಂದಿಗೆ ಅತಿಕ್ರಮಿಸುತ್ತದೆ. ಪ್ರಮುಖ: ಟೆಸ್ಟ್ db ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಮೆಟಾಡೇಟಾ ರಚನೆಯನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಆಹ್ವಾನಿಸಬೇಕು. ಟೇಬಲ್ ರಚಿಸಲು ವಿಫಲವಾದರೆ ಕಾಣೆಯಾದ ಟೇಬಲ್‌ಗಳಿಗೆ ಸಂಬಂಧಿಸಿದ ದೋಷಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.

ಅಸಿಂಕ್ರೋನಸ್ ಕೋಡ್ ಅನ್ನು ಪರೀಕ್ಷಿಸುವುದು

FastAPI ಅನ್ನು ಅಸಿಂಕ್ರೋನಸ್ ಆಗಿ ನಿರ್ಮಿಸಲಾಗಿದೆ, ಆದ್ದರಿಂದ ನೀವು ಆಗಾಗ್ಗೆ ಅಸಿಂಕ್ರೋನಸ್ ಕೋಡ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಬೇಕಾಗುತ್ತದೆ. TestClient ಅಸಿಂಕ್ರೋನಸ್ ಪರೀಕ್ಷೆಯನ್ನು ಮನಬಂದಂತೆ ಬೆಂಬಲಿಸುತ್ತದೆ.

ಅಸಿಂಕ್ರೋನಸ್ ಎಂಡ್‌ಪಾಯಿಂಟ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲು, ನಿಮ್ಮ ಟೆಸ್ಟ್ ಫಂಕ್ಷನ್ ಅನ್ನು async ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಿ:

            import asyncio

from fastapi import FastAPI

app = FastAPI()

@app.get("/async")
async def async_endpoint():
 await asyncio.sleep(0.1) # Simulate some async operation
 return {"message": "Async Hello"}

            

              
                Copy
              
            
          

            import pytest
from fastapi.testclient import TestClient
from .main import app

client = TestClient(app)

@pytest.mark.asyncio # Needed to be compatible with pytest-asyncio
async def test_async_endpoint():
 response = client.get("/async")
 assert response.status_code == 200
 assert response.json() == {"message": "Async Hello"}

            

              
                Copy
              
            
          

ಗಮನಿಸಿ: @pytest.mark.asyncio ಬಳಸಲು ನೀವು pytest-asyncio ಅನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ: pip install pytest-asyncio. ಹಳೆಯ pytest ಆವೃತ್ತಿಗಳನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ asyncio.get_event_loop() ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗಿದೆಯೆ ಎಂದು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕು. pytest ಆವೃತ್ತಿ 8 ಅಥವಾ ಹೊಸದನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ, ಇದು ಅಗತ್ಯವಿಲ್ಲದಿರಬಹುದು.

ಫೈಲ್ ಅಪ್‌ಲೋಡ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸುವುದು

FastAPI ಫೈಲ್ ಅಪ್‌ಲೋಡ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುವುದನ್ನು ಸುಲಭಗೊಳಿಸುತ್ತದೆ. ಫೈಲ್ ಅಪ್‌ಲೋಡ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು, ನೀವು TestClientನ ವಿನಂತಿ ವಿಧಾನಗಳ files ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಬಳಸಬಹುದು.

            from fastapi import FastAPI, File, UploadFile
from typing import List

app = FastAPI()

@app.post("/files/")
async def create_files(files: List[bytes] = File()):
 return {"file_sizes": [len(file) for file in files]}

@app.post("/uploadfiles/")
async def create_upload_files(files: List[UploadFile]):
 return {"filenames": [file.filename for file in files]}

            

              
                Copy
              
            
          

            from fastapi.testclient import TestClient
from .main import app
import io

client = TestClient(app)

def test_create_files():
 file_content = b"Test file content"
 files = [('files', ('test.txt', io.BytesIO(file_content), 'text/plain'))]
 response = client.post("/files/", files=files)
 assert response.status_code == 200
 assert response.json() == {"file_sizes": [len(file_content)]}

def test_create_upload_files():
 file_content = b"Test upload file content"
 files = [('files', ('test_upload.txt', io.BytesIO(file_content), 'text/plain'))]
 response = client.post("/uploadfiles/", files=files)
 assert response.status_code == 200
 assert response.json() == {"filenames": ["test_upload.txt"]}

            

              
                Copy
              
            
          

ಈ ಪರೀಕ್ಷೆಯಲ್ಲಿ, ನಾವು io.BytesIO ಬಳಸಿ ಡಮ್ಮಿ ಫೈಲ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ ಮತ್ತು ಅದನ್ನು files ಪ್ಯಾರಾಮೀಟರ್‌ಗೆ ರವಾನಿಸುತ್ತೇವೆ. files ಪ್ಯಾರಾಮೀಟರ್ ಟುಪಲ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ, ಅಲ್ಲಿ ಪ್ರತಿ ಟುಪಲ್ ಫೀಲ್ಡ್ ಹೆಸರು, ಫೈಲ್ ಹೆಸರು ಮತ್ತು ಫೈಲ್ ವಿಷಯವನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಸರ್ವರ್‌ನಿಂದ ನಿಖರವಾದ ನಿರ್ವಹಣೆಗಾಗಿ ವಿಷಯ ಪ್ರಕಾರವು ಮುಖ್ಯವಾಗಿದೆ.

ದೋಷ ನಿರ್ವಹಣೆಯನ್ನು ಪರೀಕ್ಷಿಸುವುದು

ನಿಮ್ಮ API ದೋಷಗಳನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಪರೀಕ್ಷಿಸುವುದು ಮುಖ್ಯವಾಗಿದೆ. ಅಮಾನ್ಯ ವಿನಂತಿಗಳನ್ನು ಕಳುಹಿಸಲು ಮತ್ತು API ಸರಿಯಾದ ದೋಷ ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಎಂದು ಪರಿಶೀಲಿಸಲು ನೀವು TestClient ಅನ್ನು ಬಳಸಬಹುದು.

            from fastapi import FastAPI, HTTPException

app = FastAPI()

@app.get("/items/{item_id}")
async def read_item(item_id: int):
 if item_id > 100:
 raise HTTPException(status_code=400, detail="Item ID too large")
 return {"item_id": item_id}

            

              
                Copy
              
            
          

            from fastapi.testclient import TestClient
from .main import app

client = TestClient(app)

def test_read_item_error():
 response = client.get("/items/101")
 assert response.status_code == 400
 assert response.json() == {"detail": "Item ID too large"}

            

              
                Copy
              
            
          

ಈ ಪರೀಕ್ಷೆಯು /items/101 ಗೆ GET ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸುತ್ತದೆ, ಇದು 400 ಸ್ಟೇಟಸ್ ಕೋಡ್‌ನೊಂದಿಗೆ HTTPException ಅನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ. ಪರೀಕ್ಷೆಯು ಪ್ರತಿಕ್ರಿಯೆ ಸ್ಟೇಟಸ್ ಕೋಡ್ 400 ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆ JSON ನಿರೀಕ್ಷಿತ ದೋಷ ಸಂದೇಶವನ್ನು ಹೊಂದಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಭದ್ರತಾ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಪರೀಕ್ಷಿಸುವುದು

ನಿಮ್ಮ API ದೃಢೀಕರಣ ಅಥವಾ ಅಧಿಕಾರವನ್ನು ಬಳಸಿದರೆ, ನೀವು ಈ ಭದ್ರತಾ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಸಹ ಪರೀಕ್ಷಿಸಬೇಕಾಗುತ್ತದೆ. TestClient ದೃಢೀಕೃತ ವಿನಂತಿಗಳನ್ನು ಅನುಕರಿಸಲು ಹೆಡರ್‌ಗಳು ಮತ್ತು ಕುಕೀಗಳನ್ನು ಹೊಂದಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

            from fastapi import FastAPI, Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm

app = FastAPI()

# Security
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

@app.post("/token")
async def login(form_data: OAuth2PasswordRequestForm = Depends()):
 # Simulate authentication
 if form_data.username != "testuser" or form_data.password != "password123":
 raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Incorrect username or password")
 return {"access_token": "fake_token", "token_type": "bearer"}

@app.get("/protected")
async def protected_route(token: str = Depends(oauth2_scheme)):
 return {"message": "Protected data"}

            

              
                Copy
              
            
          

            from fastapi.testclient import TestClient
from .main import app

client = TestClient(app)

def test_login():
 response = client.post("/token", data={"username": "testuser", "password": "password123"})
 assert response.status_code == 200
 assert "access_token" in response.json()

def test_protected_route():
 # First, get a token
 token_response = client.post("/token", data={"username": "testuser", "password": "password123"})
 token = token_response.json()["access_token"]

 # Then, use the token to access the protected route
 response = client.get("/protected", headers={"Authorization": f"Bearer {token}"}) # corrected format.
 assert response.status_code == 200
 assert response.json() == {"message": "Protected data"}

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಲಾಗಿನ್ ಎಂಡ್‌ಪಾಯಿಂಟ್ ಅನ್ನು ಪರೀಕ್ಷಿಸುತ್ತೇವೆ ಮತ್ತು ನಂತರ ಪಡೆದ ಟೋಕನ್ ಬಳಸಿ ಸಂರಕ್ಷಿತ ಮಾರ್ಗವನ್ನು ಪ್ರವೇಶಿಸುತ್ತೇವೆ. TestClient ನ ವಿನಂತಿ ವಿಧಾನಗಳ headers ಪ್ಯಾರಾಮೀಟರ್, ಬೇರರ್ ಟೋಕನ್‌ಗಳಿಗಾಗಿ Authorization ಹೆಡರ್ ಸೇರಿದಂತೆ ಕಸ್ಟಮ್ ಹೆಡರ್‌ಗಳನ್ನು ಹೊಂದಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

FastAPI ಟೆಸ್ಟಿಂಗ್‌ಗೆ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ನಿಮ್ಮ FastAPI ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸುವಾಗ ಅನುಸರಿಸಬೇಕಾದ ಕೆಲವು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು ಇಲ್ಲಿವೆ:

• ಸಮಗ್ರ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯಿರಿ: ನಿಮ್ಮ APIಯ ಎಲ್ಲಾ ಭಾಗಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಪರೀಕ್ಷಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಹೆಚ್ಚಿನ ಟೆಸ್ಟ್ ಕವರೇಜ್ ಗುರಿಯನ್ನು ಹೊಂದಿರಿ.
• ವಿವರಣಾತ್ಮಕ ಪರೀಕ್ಷಾ ಹೆಸರುಗಳನ್ನು ಬಳಸಿ: ನಿಮ್ಮ ಪರೀಕ್ಷಾ ಹೆಸರುಗಳು ಪರೀಕ್ಷೆಯು ಏನನ್ನು ಪರಿಶೀಲಿಸುತ್ತಿದೆ ಎಂಬುದನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಸೂಚಿಸುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
• ಅರೇಂಜ್-ಆಕ್ಟ್-ಅಸರ್ಟ್ ಮಾದರಿಯನ್ನು ಅನುಸರಿಸಿ: ನಿಮ್ಮ ಪರೀಕ್ಷೆಗಳನ್ನು ಮೂರು ವಿಭಿನ್ನ ಹಂತಗಳಾಗಿ ಆಯೋಜಿಸಿ: ಅರೇಂಜ್ (ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು ಸಿದ್ಧಪಡಿಸಿ), ಆಕ್ಟ್ (ಪರೀಕ್ಷಿಸಲಾಗುತ್ತಿರುವ ಕ್ರಿಯೆಯನ್ನು ಮಾಡಿ), ಮತ್ತು ಅಸರ್ಟ್ (ಫಲಿತಾಂಶಗಳನ್ನು ಪರಿಶೀಲಿಸಿ).
• ಅಣಕು ವಸ್ತುಗಳನ್ನು ಬಳಸಿ: ನಿಮ್ಮ ಪರೀಕ್ಷೆಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸಲು ಮತ್ತು ಬಾಹ್ಯ ವ್ಯವಸ್ಥೆಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗುವುದನ್ನು ತಪ್ಪಿಸಲು ಬಾಹ್ಯ ಡಿಪೆಂಡೆನ್ಸಿಗಳನ್ನು ಅಣಕು ಮಾಡಿ.
• ಎಡ್ಜ್ ಕೇಸ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸಿ: ನಿಮ್ಮ API ದೋಷಗಳನ್ನು ಸರಿಯಾಗಿ ನಿಭಾಯಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಅಮಾನ್ಯ ಅಥವಾ ಅನಿರೀಕ್ಷಿತ ಇನ್‌ಪುಟ್‌ನೊಂದಿಗೆ ಪರೀಕ್ಷಿಸಿ.
• ಪರೀಕ್ಷೆಗಳನ್ನು ಆಗಾಗ್ಗೆ ನಡೆಸಿ: ದೋಷಗಳನ್ನು ಬೇಗನೆ ಮತ್ತು ಆಗಾಗ್ಗೆ ಪತ್ತೆಹಚ್ಚಲು ನಿಮ್ಮ ಅಭಿವೃದ್ಧಿ ವರ್ಕ್‌ಫ್ಲೋಗೆ ಪರೀಕ್ಷೆಯನ್ನು ಸಂಯೋಜಿಸಿ.
• CI/CD ನೊಂದಿಗೆ ಸಂಯೋಜಿಸಿ: ಉತ್ಪಾದನೆಗೆ ನಿಯೋಜಿಸುವ ಮೊದಲು ಎಲ್ಲಾ ಕೋಡ್ ಬದಲಾವಣೆಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಪರೀಕ್ಷಿಸಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಿಮ್ಮ CI/CD ಪೈಪ್‌ಲೈನ್‌ನಲ್ಲಿ ನಿಮ್ಮ ಪರೀಕ್ಷೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಿ. ಇದನ್ನು ಸಾಧಿಸಲು ಜೆಂಕಿನ್ಸ್, GitLab CI, GitHub ಕ್ರಿಯೆಗಳು, ಅಥವಾ CircleCI ನಂತಹ ಸಾಧನಗಳನ್ನು ಬಳಸಬಹುದು.

ಉದಾಹರಣೆ: ಅಂತರರಾಷ್ಟ್ರೀಕರಣ (i18n) ಪರೀಕ್ಷೆ

ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗಾಗಿ APIಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವಾಗ, ಅಂತರರಾಷ್ಟ್ರೀಕರಣ (i18n) ಅತ್ಯಗತ್ಯ. i18n ಪರೀಕ್ಷೆಯು ನಿಮ್ಮ API ಬಹು ಭಾಷೆಗಳು ಮತ್ತು ಪ್ರದೇಶಗಳನ್ನು ಸರಿಯಾಗಿ ಬೆಂಬಲಿಸುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. FastAPI ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ನೀವು i18n ಅನ್ನು ಹೇಗೆ ಪರೀಕ್ಷಿಸಬಹುದು ಎಂಬುದಕ್ಕೆ ಇಲ್ಲಿದೆ ಒಂದು ಉದಾಹರಣೆ:

            from fastapi import FastAPI, Header
from typing import Optional

app = FastAPI()

messages = {
 "en": {"greeting": "Hello, world!"},
 "fr": {"greeting": "Bonjour le monde !"},
 "es": {"greeting": "¡Hola Mundo!"},
}

@app.get("/")
async def read_root(accept_language: Optional[str] = Header(None)):
 lang = accept_language[:2] if accept_language else "en"
 if lang not in messages:
 lang = "en"
 return {"message": messages[lang]["greeting"]}

            

              
                Copy
              
            
          

            from fastapi.testclient import TestClient
from .main import app

client = TestClient(app)

def test_read_root_en():
 response = client.get("/", headers={"Accept-Language": "en-US"})
 assert response.status_code == 200
 assert response.json() == {"message": "Hello, world!"}

def test_read_root_fr():
 response = client.get("/", headers={"Accept-Language": "fr-FR"})
 assert response.status_code == 200
 assert response.json() == {"message": "Bonjour le monde !"}

def test_read_root_es():
 response = client.get("/", headers={"Accept-Language": "es-ES"})
 assert response.status_code == 200
 assert response.json() == {"message": "¡Hola Mundo!"}

def test_read_root_default():
 response = client.get("/")
 assert response.status_code == 200
 assert response.json() == {"message": "Hello, world!"}

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯು ಬಯಸಿದ ಭಾಷೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು Accept-Language ಹೆಡರ್ ಅನ್ನು ಹೊಂದಿಸುತ್ತದೆ. API ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಭಾಷೆಯಲ್ಲಿ ಶುಭಾಶಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಪರೀಕ್ಷೆಯು API ವಿವಿಧ ಭಾಷಾ ಆದ್ಯತೆಗಳನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. Accept-Language ಹೆಡರ್ ಇಲ್ಲದಿದ್ದರೆ, ಡೀಫಾಲ್ಟ್ "en" ಭಾಷೆಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ತೀರ್ಮಾನ

ದೃಢ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ FastAPI ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವಲ್ಲಿ ಪರೀಕ್ಷೆ ಒಂದು ಅತ್ಯಗತ್ಯ ಭಾಗವಾಗಿದೆ. TestClient ನಿಮ್ಮ API ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು ಸರಳ ಮತ್ತು ಅನುಕೂಲಕರ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿ ವಿವರಿಸಲಾದ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸುವ ಮೂಲಕ, ನಿಮ್ಮ APIಗಳ ಗುಣಮಟ್ಟ ಮತ್ತು ಸ್ಥಿರತೆಯನ್ನು ಖಚಿತಪಡಿಸುವ ಸಮಗ್ರ ಪರೀಕ್ಷೆಗಳನ್ನು ನೀವು ಬರೆಯಬಹುದು. ಮೂಲಭೂತ ವಿನಂತಿಗಳಿಂದ ಹಿಡಿದು ಡಿಪೆಂಡೆನ್ಸಿ ಇಂಜೆಕ್ಷನ್ ಮತ್ತು ಅಸಿಂಕ್ರೋನಸ್ ಪರೀಕ್ಷೆಯಂತಹ ಸುಧಾರಿತ ತಂತ್ರಗಳವರೆಗೆ, TestClient ಉತ್ತಮ-ಪರೀಕ್ಷಿತ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಕೋಡ್ ರಚಿಸಲು ನಿಮಗೆ ಅಧಿಕಾರ ನೀಡುತ್ತದೆ. ನಿಮ್ಮ ಅಭಿವೃದ್ಧಿ ವರ್ಕ್‌ಫ್ಲೋನ ಮುಖ್ಯ ಭಾಗವಾಗಿ ಪರೀಕ್ಷೆಯನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಿ, ಮತ್ತು ನೀವು ವಿಶ್ವಾದ್ಯಂತ ಬಳಕೆದಾರರಿಗೆ ಶಕ್ತಿಯುತ ಮತ್ತು ಅವಲಂಬಿತವಾಗಿರುವ APIಗಳನ್ನು ನಿರ್ಮಿಸುತ್ತೀರಿ. ಪರೀಕ್ಷೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ಮತ್ತು ನಿರಂತರ ಗುಣಮಟ್ಟದ ಭರವಸೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು CI/CD ಸಂಯೋಜನೆಯ ಪ್ರಾಮುಖ್ಯತೆಯನ್ನು ನೆನಪಿಡಿ.