FastAPI ടെസ്റ്റിംഗിൽ പ്രാവീണ്യം നേടുക: TestClient-ലേക്കുള്ള ഒരു സമഗ്ര ഗൈഡ്

Python ഉപയോഗിച്ച് ഉയർന്ന പ്രകടനമുള്ള 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 പോലുള്ള ജനപ്രിയ Python ടെസ്റ്റിംഗ് ചട്ടക്കൂടുകളുമായി എളുപ്പത്തിൽ സംയോജിപ്പിക്കുന്നു.

നിങ്ങളുടെ ടെസ്റ്റിംഗ് പരിസ്ഥിതി സജ്ജമാക്കുന്നു

നിങ്ങൾ ടെസ്റ്റ് ചെയ്യുന്നതിന് മുമ്പ്, നിങ്ങളുടെ ടെസ്റ്റിംഗ് പരിസ്ഥിതി സജ്ജീകരിക്കേണ്ടതുണ്ട്. ഇതിൽ സാധാരണയായി ആവശ്യമായ ഡിപൻഡൻസികൾ ഇൻസ്റ്റാൾ ചെയ്യുകയും നിങ്ങളുടെ ടെസ്റ്റിംഗ് ചട്ടക്കൂട് ക്രമീകരിക്കുകയും ചെയ്യുന്നു.

ഇൻസ്റ്റാളേഷൻ

ആദ്യം, നിങ്ങളുടെ കമ്പ്യൂട്ടറിൽ FastAPI-യും pytest-ഉം ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക. pip ഉപയോഗിച്ച് നിങ്ങൾക്ക് അവ ഇൻസ്റ്റാൾ ചെയ്യാവുന്നതാണ്:

            pip install fastapi pytest httpx
            

              
                Copy
              
            
          

FastAPI രഹസ്യമായി ഉപയോഗിക്കുന്ന ഒരു HTTP ക്ലയിന്റാണ് httpx. TestClient FastAPI-യുടെ ഭാഗമാണെങ്കിലും, httpx ഇൻസ്റ്റാൾ ചെയ്യുന്നത് സുഗമമായ ടെസ്റ്റിംഗ് ഉറപ്പാക്കുന്നു. ചില ട്യൂട്ടോറിയലുകളിൽ requests നെക്കുറിച്ചും പരാമർശിക്കുന്നുണ്ട്. എന്നിരുന്നാലും, httpx FastAPI-യുടെ async സ്വഭാവവുമായി കൂടുതൽ യോജിക്കുന്നു.

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}: ഒരു ഐഡി അടിസ്ഥാനമാക്കി ഒരു ഇനം നൽകുന്ന 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 രീതികൾ പരിശോധിക്കുന്നു

GET, POST, PUT, DELETE, PATCH എന്നിവയുൾപ്പെടെ എല്ലാ സാധാരണ HTTP രീതികളെയും TestClient പിന്തുണയ്ക്കുന്നു. ഈ രീതികളിൽ ഓരോന്നും എങ്ങനെ പരിശോധിക്കാമെന്ന് നോക്കാം.

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
              
            
          

ഈ ടെസ്റ്റ് q=test എന്ന ചോദ്യ പാരാമീറ്ററോടുകൂടി /items/1-ലേക്ക് ഒരു 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 എന്നൊരു ഡിക്ഷണറി ഉണ്ടാക്കുന്നു.
• JSON പേലോഡായി item_data പാസ് ചെയ്തുകൊണ്ട് /items/ എൻഡ്‌പോയിന്റിലേക്ക് ഒരു POST അഭ്യർത്ഥന അയയ്‌ക്കാൻ ഞങ്ങൾ client.post("/items/", json=item_data) ഉപയോഗിക്കുന്നു.
• പ്രതികരണത്തിന്റെ സ്റ്റാറ്റസ് കോഡ് 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 പൈപ്പ്‌ലൈനിൽ നിങ്ങളുടെ ടെസ്റ്റുകൾ സ്വയമേവ പ്രവർത്തിപ്പിക്കുക. ഇത് നേടാൻ Jenkins, GitLab CI, GitHub Actions, അല്ലെങ്കിൽ CircleCI പോലുള്ള ടൂളുകൾ ഉപയോഗിക്കാം.

ഉദാഹരണം: അന്താരാഷ്ട്രവൽക്കരണം (i18n) പരിശോധന

ഒരു ആഗോള പ്രേക്ഷകർക്കായി API-കൾ വികസിപ്പിക്കുമ്പോൾ, അന്താരാഷ്ട്രവൽക്കരണം (i18n) അത്യാവശ്യമാണ്. ഒന്നിലധികം ഭാഷകളെയും പ്രദേശങ്ങളെയും നിങ്ങളുടെ API ശരിയായി പിന്തുണയ്ക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കുന്നത് i18n-ൽ ഉൾപ്പെടുന്നു. ഒരു 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 ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നതിനുള്ള ഒരു പ്രധാന ഭാഗമാണ് ടെസ്റ്റിംഗ്. നിങ്ങളുടെ API എൻഡ്‌പോയിന്റുകൾ പരിശോധിക്കുന്നതിനുള്ള ലളിതവും സൗകര്യപ്രദവുമായ മാർഗ്ഗം TestClient നൽകുന്നു. ഈ ഗൈഡിൽ വിവരിച്ചിട്ടുള്ള മികച്ച രീതികൾ പിന്തുടരുന്നതിലൂടെ, നിങ്ങളുടെ API-കളുടെ ഗുണനിലവാരവും സ്ഥിരതയും ഉറപ്പാക്കുന്ന സമഗ്രമായ ടെസ്റ്റുകൾ നിങ്ങൾക്ക് എഴുതാൻ കഴിയും. അടിസ്ഥാന അഭ്യർത്ഥനകൾ മുതൽ ഡിപെൻഡൻസി ഇൻജക്ഷനും അസിൻക്രണസ് ടെസ്റ്റിംഗും പോലുള്ള നൂതന സാങ്കേതിക വിദ്യകൾ വരെ, നന്നായി പരിശോധിച്ചതും പരിപാലിക്കാൻ കഴിയുന്നതുമായ കോഡ് ഉണ്ടാക്കാൻ TestClient നിങ്ങളെ സഹായിക്കുന്നു. നിങ്ങളുടെ വികസന വർക്ക്ഫ്ലോയുടെ പ്രധാന ഭാഗമായി ടെസ്റ്റിംഗിനെ സ്വീകരിക്കുക, കൂടാതെ ലോകമെമ്പാടുമുള്ള ഉപയോക്താക്കൾക്ക് ശക്തവും വിശ്വസനീയവുമായ API-കൾ നിങ്ങൾ നിർമ്മിക്കും. ടെസ്റ്റിംഗ് സ്വയമേവ പ്രവർത്തിപ്പിക്കാനും തുടർച്ചയായ ഗുണനിലവാര ഉറപ്പാക്കൽ ഉറപ്പാക്കാനും CI/CD സംയോജനത്തിന്റെ പ്രാധാന്യം ഓർക്കുക.