TestClient ఉపయోగించి మీ FastAPI అప్లికేషన్‌లను సమర్థవంతంగా టెస్ట్ చేయడం ఎలాగో తెలుసుకోండి. బలమైన మరియు నమ్మకమైన APIల కోసం ఉత్తమ పద్ధతులు, అధునాతన టెక్నిక్స్ మరియు వాస్తవ-ప్రపంచ ఉదాహరణలను కవర్ చేయండి.
FastAPI టెస్టింగ్‌లో నైపుణ్యం: TestClient కోసం ఒక సమగ్ర గైడ్
పైథాన్‌తో అధిక-పనితీరు గల APIలను నిర్మించడానికి FastAPI ఒక ప్రముఖ ఫ్రేమ్‌వర్క్‌గా ఉద్భవించింది. దీని వేగం, వాడుకలో సౌలభ్యం, మరియు ఆటోమేటిక్ డేటా వాలిడేషన్ ప్రపంచవ్యాప్తంగా డెవలపర్‌లలో దీనిని ఒక అభిమాన ఎంపికగా మార్చాయి. అయితే, బాగా నిర్మించిన API దాని టెస్ట్‌ల వలె మాత్రమే మంచిది. క్షుణ్ణమైన టెస్టింగ్ మీ API ఆశించిన విధంగా పనిచేస్తుందని, ఒత్తిడిలో స్థిరంగా ఉంటుందని, మరియు ప్రొడక్షన్‌కు నమ్మకంగా డిప్లాయ్ చేయవచ్చని నిర్ధారిస్తుంది. ఈ సమగ్ర గైడ్ మీ API ఎండ్‌పాయింట్‌లను సమర్థవంతంగా టెస్ట్ చేయడానికి FastAPI యొక్క TestClient ఉపయోగించడంపై దృష్టి పెడుతుంది.
FastAPI అప్లికేషన్‌ల కోసం టెస్టింగ్ ఎందుకు ముఖ్యం?
సాఫ్ట్‌వేర్ డెవలప్‌మెంట్ జీవిత చక్రంలో టెస్టింగ్ ఒక కీలకమైన దశ. ఇది మీకు సహాయపడుతుంది:
- బగ్స్‌ను ముందుగానే గుర్తించడం: ప్రొడక్షన్‌కు చేరకముందే లోపాలను పట్టుకోవడం, సమయం మరియు వనరులను ఆదా చేస్తుంది.
- కోడ్ నాణ్యతను నిర్ధారించడం: బాగా-నిర్మితమైన మరియు నిర్వహించదగిన కోడ్‌ను ప్రోత్సహించడం.
- రిగ్రెషన్‌లను నివారించడం: కొత్త మార్పులు ఇప్పటికే ఉన్న కార్యాచరణను దెబ్బతీయకుండా హామీ ఇవ్వడం.
- API విశ్వసనీయతను మెరుగుపరచడం: API యొక్క స్థిరత్వం మరియు పనితీరుపై నమ్మకాన్ని పెంచడం.
- సహకారాన్ని సులభతరం చేయడం: ఇతర డెవలపర్‌ల కోసం ఆశించిన ప్రవర్తన యొక్క స్పష్టమైన డాక్యుమెంటేషన్‌ను అందించడం.
FastAPI యొక్క TestClient పరిచయం
మీ API ఎండ్‌పాయింట్‌లను టెస్ట్ చేసే ప్రక్రియను సులభతరం చేసే అంతర్నిర్మిత TestClientను FastAPI అందిస్తుంది. TestClient పూర్తిస్థాయి సర్వర్‌ను ప్రారంభించకుండా మీ APIకి అభ్యర్థనలను పంపగల ఒక తేలికపాటి క్లయింట్‌గా పనిచేస్తుంది. ఇది టెస్టింగ్‌ను గణనీయంగా వేగంగా మరియు మరింత సౌకర్యవంతంగా చేస్తుంది.
TestClient యొక్క ముఖ్య లక్షణాలు:
- HTTP అభ్యర్థనలను అనుకరిస్తుంది: మీ APIకి GET, POST, PUT, DELETE, మరియు ఇతర HTTP అభ్యర్థనలను పంపడానికి మిమ్మల్ని అనుమతిస్తుంది.
- డేటా సీరియలైజేషన్‌ను నిర్వహిస్తుంది: అభ్యర్థన డేటాను (ఉదా., JSON పేలోడ్స్) ఆటోమేటిక్‌గా సీరియలైజ్ చేస్తుంది మరియు ప్రతిస్పందన డేటాను డీసీరియలైజ్ చేస్తుంది.
- అస్సర్షన్ పద్ధతులను అందిస్తుంది: ప్రతిస్పందనల యొక్క స్టేటస్ కోడ్, హెడర్‌లు మరియు కంటెంట్‌ను ధృవీకరించడానికి సౌకర్యవంతమైన పద్ధతులను అందిస్తుంది.
- ఎసింక్రోనస్ టెస్టింగ్‌కు మద్దతు ఇస్తుంది: FastAPI యొక్క ఎసింక్రోనస్ స్వభావంతో సజావుగా పనిచేస్తుంది.
- టెస్టింగ్ ఫ్రేమ్‌వర్క్‌లతో కలిసిపోతుంది: pytest మరియు unittest వంటి ప్రసిద్ధ పైథాన్ టెస్టింగ్ ఫ్రేమ్‌వర్క్‌లతో సులభంగా కలిసిపోతుంది.
మీ టెస్టింగ్ వాతావరణాన్ని ఏర్పాటు చేయడం
మీరు టెస్టింగ్ ప్రారంభించడానికి ముందు, మీరు మీ టెస్టింగ్ వాతావరణాన్ని ఏర్పాటు చేయాలి. ఇందులో సాధారణంగా అవసరమైన డిపెండెన్సీలను ఇన్‌స్టాల్ చేయడం మరియు మీ టెస్టింగ్ ఫ్రేమ్‌వర్క్‌ను కాన్ఫిగర్ చేయడం ఉంటాయి.
ఇన్‌స్టాలేషన్
ముందుగా, మీరు FastAPI మరియు pytest ఇన్‌స్టాల్ చేసుకున్నారని నిర్ధారించుకోండి. మీరు వాటిని pip ఉపయోగించి ఇన్‌స్టాల్ చేయవచ్చు:
pip install fastapi pytest httpx
httpx అనేది FastAPI హుడ్ కింద ఉపయోగించే ఒక HTTP క్లయింట్. TestClient FastAPIలో భాగమైనప్పటికీ, httpxను కూడా ఇన్‌స్టాల్ చేసుకోవడం సున్నితమైన టెస్టింగ్‌ను నిర్ధారిస్తుంది. కొన్ని ట్యుటోరియల్స్ requestsను కూడా ప్రస్తావిస్తాయి, అయితే, FastAPI యొక్క ఎసింక్ స్వభావానికి httpx మరింత అనుకూలంగా ఉంటుంది.
ఉదాహరణ 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
ఈ కోడ్‌ను 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"}
ఈ టెస్ట్‌లో:
- మేము
TestClientమరియు FastAPIappఇన్‌స్టాన్స్‌ను ఇంపోర్ట్ చేస్తాము. - మేము
TestClientయొక్క ఒక ఇన్‌స్టాన్స్‌ను క్రియేట్ చేస్తాము, దానికిappను పాస్ చేస్తాము. - మేము
test_read_rootఅనే ఒక టెస్ట్ ఫంక్షన్‌ను నిర్వచిస్తాము. - టెస్ట్ ఫంక్షన్ లోపల, రూట్ ఎండ్‌పాయింట్‌కు GET అభ్యర్థన పంపడానికి మేము
client.get("/")ఉపయోగిస్తాము. - మేము ప్రతిస్పందన స్టేటస్ కోడ్ 200 (OK) అని ధృవీకరిస్తాము.
- మేము ప్రతిస్పందన JSON
{"message": "Hello World"}కు సమానమని ధృవీకరిస్తాము.
pytestతో మీ టెస్ట్‌లను రన్ చేయడం
మీ టెస్ట్‌లను రన్ చేయడానికి, మీ test_main.py ఫైల్ ఉన్న డైరెక్టరీలో ఒక టెర్మినల్ తెరిచి, కింది కమాండ్‌ను రన్ చేయండి:
pytest
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 ===============================
వివిధ 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"}
ఈ టెస్ట్ /items/1కు ఒక GET అభ్యర్థనను q=test అనే క్వెరీ పారామీటర్‌తో పంపుతుంది. ఆపై ఇది ప్రతిస్పందన స్టేటస్ కోడ్ 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
ఈ టెస్ట్‌లో:
- కొత్త ఐటెమ్ కోసం డేటాను కలిగి ఉన్న
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
ప్రతిస్పందనలు ఆశించిన విధంగా ఉన్నాయని ధృవీకరించడానికి అస్సర్షన్‌లను జోడించడం గుర్తుంచుకోండి.
అధునాతన టెస్టింగ్ టెక్నిక్స్
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
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 = {}
ఈ ఉదాహరణ 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"}
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"}
గమనిక: @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]}
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"]}
ఈ టెస్ట్‌లో, మేము 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}
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"}
ఈ టెస్ట్ /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"}
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"}
ఈ ఉదాహరణలో, మేము లాగిన్ ఎండ్‌పాయింట్‌ను టెస్ట్ చేసి, ఆపై రక్షిత మార్గాన్ని యాక్సెస్ చేయడానికి పొందిన టోకెన్‌ను ఉపయోగిస్తాము. TestClient యొక్క అభ్యర్థన పద్ధతుల యొక్క headers పారామీటర్, బేరర్ టోకెన్‌ల కోసం Authorization హెడర్‌తో సహా, కస్టమ్ హెడర్‌లను సెట్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.
FastAPI టెస్టింగ్ కోసం ఉత్తమ పద్ధతులు
మీ FastAPI అప్లికేషన్‌లను టెస్ట్ చేసేటప్పుడు అనుసరించాల్సిన కొన్ని ఉత్తమ పద్ధతులు ఇక్కడ ఉన్నాయి:
- సమగ్ర టెస్ట్‌లు రాయండి: మీ API యొక్క అన్ని భాగాలు క్షుణ్ణంగా టెస్ట్ చేయబడ్డాయని నిర్ధారించుకోవడానికి అధిక టెస్ట్ కవరేజీని లక్ష్యంగా చేసుకోండి.
- వివరణాత్మక టెస్ట్ పేర్లను ఉపయోగించండి: మీ టెస్ట్ పేర్లు టెస్ట్ ఏమి ధృవీకరిస్తుందో స్పష్టంగా సూచించేలా చూసుకోండి.
- అరేంజ్-యాక్ట్-అస్సర్ట్ నమూనాను అనుసరించండి: మీ టెస్ట్‌లను మూడు విభిన్న దశలుగా నిర్వహించండి: అరేంజ్ (టెస్ట్ డేటాను సెటప్ చేయండి), యాక్ట్ (టెస్ట్ చేయబడుతున్న చర్యను నిర్వహించండి), మరియు అస్సర్ట్ (ఫలితాలను ధృవీకరించండి).
- మాక్ ఆబ్జెక్ట్‌లను ఉపయోగించండి: మీ టెస్ట్‌లను వేరు చేయడానికి మరియు బాహ్య సిస్టమ్‌లపై ఆధారపడటాన్ని నివారించడానికి బాహ్య డిపెండెన్సీలను మాక్ చేయండి.
- ఎడ్జ్ కేసులను టెస్ట్ చేయండి: చెల్లని లేదా ఊహించని ఇన్‌పుట్‌తో మీ APIని టెస్ట్ చేయండి, అది లోపాలను సున్నితంగా నిర్వహిస్తుందని నిర్ధారించుకోవడానికి.
- టెస్ట్‌లను తరచుగా రన్ చేయండి: బగ్‌లను ముందుగానే మరియు తరచుగా పట్టుకోవడానికి మీ డెవలప్‌మెంట్ వర్క్‌ఫ్లోలో టెస్టింగ్‌ను ఏకీకృతం చేయండి.
- CI/CDతో ఇంటిగ్రేట్ చేయండి: ప్రొడక్షన్‌కు డిప్లాయ్ చేయడానికి ముందు అన్ని కోడ్ మార్పులు క్షుణ్ణంగా టెస్ట్ చేయబడ్డాయని నిర్ధారించుకోవడానికి మీ CI/CD పైప్‌లైన్‌లో మీ టెస్ట్‌లను ఆటోమేట్ చేయండి. దీనిని సాధించడానికి జెంకిన్స్, గిట్‌ల్యాబ్ CI, గిట్‌హబ్ యాక్షన్స్, లేదా సర్కిల్‌సిఐ వంటి సాధనాలను ఉపయోగించవచ్చు.
ఉదాహరణ: అంతర్జాతీయీకరణ (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"]}
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!"}
ఈ ఉదాహరణ కోరుకున్న భాషను పేర్కొనడానికి Accept-Language హెడర్‌ను సెట్ చేస్తుంది. API పేర్కొన్న భాషలో శుభాకాంక్షను తిరిగి ఇస్తుంది. API వివిధ భాషా ప్రాధాన్యతలను సరిగ్గా నిర్వహిస్తుందని టెస్టింగ్ నిర్ధారిస్తుంది. Accept-Language హెడర్ లేనట్లయితే, డిఫాల్ట్ "en" భాష ఉపయోగించబడుతుంది.
ముగింపు
బలమైన మరియు నమ్మకమైన FastAPI అప్లికేషన్‌లను నిర్మించడంలో టెస్టింగ్ ఒక ముఖ్యమైన భాగం. TestClient మీ API ఎండ్‌పాయింట్‌లను టెస్ట్ చేయడానికి ఒక సులభమైన మరియు సౌకర్యవంతమైన మార్గాన్ని అందిస్తుంది. ఈ గైడ్‌లో పేర్కొన్న ఉత్తమ పద్ధతులను అనుసరించడం ద్వారా, మీరు మీ APIల నాణ్యత మరియు స్థిరత్వాన్ని నిర్ధారించే సమగ్ర టెస్ట్‌లను రాయవచ్చు. ప్రాథమిక అభ్యర్థనల నుండి డిపెండెన్సీ ఇంజెక్షన్ మరియు ఎసింక్రోనస్ టెస్టింగ్ వంటి అధునాతన టెక్నిక్స్ వరకు, TestClient బాగా-టెస్ట్ చేయబడిన మరియు నిర్వహించదగిన కోడ్‌ను సృష్టించడానికి మిమ్మల్ని శక్తివంతం చేస్తుంది. మీ డెవలప్‌మెంట్ వర్క్‌ఫ్లోలో టెస్టింగ్‌ను ఒక ప్రధాన భాగంగా స్వీకరించండి, మరియు మీరు ప్రపంచవ్యాప్తంగా వినియోగదారుల కోసం శక్తివంతమైన మరియు నమ్మకమైన APIలను నిర్మిస్తారు. టెస్టింగ్‌ను ఆటోమేట్ చేయడానికి మరియు నిరంతర నాణ్యత హామీని నిర్ధారించడానికి CI/CD ఇంటిగ్రేషన్ యొక్క ప్రాముఖ్యతను గుర్తుంచుకోండి.