Integrasjonstesting av FastAPI-endepunkter
Utfør integrasjonstester av API-endepunktene dine ved hjelp av FastAPI sin `TestClient` for å simulere forespørsler.
Integrasjonstesting av FastAPI-endepunkter er en gratis leksjon i Bootcamp i backendutvikling med FastAPI på CoddyKit. Dette er leksjon 2 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Bootcamp i backendutvikling med FastAPI, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Bootcamp i backendutvikling med FastAPI inneholder totalt 4 leksjoner.
Hva er integrasjonstesting?
Velkommen til integrasjonstesting! Etter at De har lært om enhetstester, er det på tide å se hvordan ulike deler av FastAPI-applikasjonen Deres fungerer sammen.
- Enhetstester kontrollerer individuelle funksjoner eller komponenter isolert.
- Integrasjonstester kontrollerer at flere komponenter i systemet samhandler riktig. For en FastAPI-app betyr dette å teste API-endepunktene, kontrollere at de håndterer forespørsler, samhandler med avhengigheter og returnerer forventede svar.
Disse testene sikrer at API-et oppfører seg som forventet når alle delene er koblet sammen.
Introduksjon til FastAPIs TestClient
FastAPI tilbyr et kraftig verktøy kalt TestClient fra fastapi.testclient. Denne klienten lar Dem sende HTTP-forespørsler til FastAPI-applikasjonen uten å måtte kjøre en aktiv server.
- Den simulerer forespørsler direkte i minnet.
- Den er bygget oppå det populære biblioteket
httpx. - Den passer perfekt til rask testing av API-endepunktene under utvikling.
La oss se hvordan den settes opp!
Sette opp TestClient
For å bruke TestClient må De først importere FastAPI-applikasjonsinstansen og deretter sende den til TestClient-konstruktøren. Dette oppretter en klientinstans som er klar til å sende simulerte forespørsler.
Prøv å kjøre dette eksempelet for å se et grunnleggende oppsett:
from fastapi import FastAPI
from fastapi.testclient import TestClient
# 1. Define your FastAPI app
app = FastAPI()
# 2. Define a simple endpoint
@app.get("/hello")
async def read_hello():
return {"message": "Hello Test!"}
# 3. Create a TestClient instance
client = TestClient(app)
# 4. Define a test function
def test_read_hello():
# Use the client to make a GET request
response = client.get("/hello")
# Assertions to check the response
assert response.status_code == 200
assert response.json() == {"message": "Hello Test!"}
print("Test Passed: /hello endpoint works!")
# This block makes the script runnable directly
if __name__ == "__main__":
print("Running a simple test with TestClient...")
test_read_hello()
Teste GET-forespørsler
Det er enkelt å sende GET-forespørsler. De kaller ganske enkelt .get()-metoden på TestClient-instansen og sender inn banen til endepunktet De vil teste.
Etter at forespørselen er sendt, kan De hente egenskaper fra response-objektet, for eksempel .status_code og .json(), for å kontrollere resultatet.
from fastapi import FastAPI
from fastapi.testclient import TestClient
app = FastAPI()
@app.get("/items/")
async def read_items():
return [{"name": "Laptop"}, {"name": "Mouse"}]
client = TestClient(app)
def test_read_items():
response = client.get("/items/")
print(f"Status Code: {response.status_code}")
print(f"Response JSON: {response.json()}")
assert response.status_code == 200
assert len(response.json()) == 2
assert response.json()[0]["name"] == "Laptop"
print("Test Passed: /items/ returns correct data!")
if __name__ == "__main__":
print("Testing /items/ endpoint...")
test_read_items()
Teste bane- og spørringsparametere
TestClient håndterer bane- og spørringsparametere på samme måte som en vanlig nettleser. Baneparametere inkluderes direkte i URL-strengen, mens spørringsparametere kan legges til i URL-en eller sendes via params-argumentet.
Det er ofte ryddigere å bruke params-argumentet for spørringsparametere, og det håndterer URL-koding automatisk.
from fastapi import FastAPI
from fastapi.testclient import TestClient
app = FastAPI()
@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str = None):
if q:
return {"item_id": item_id, "q": q}
return {"item_id": item_id}
client = TestClient(app)
def test_read_item_with_query():
# Path param 5, Query param q=hello
response = client.get("/items/5", params={"q": "hello"})
assert response.status_code == 200
assert response.json() == {"item_id": 5, "q": "hello"}
print("Test Passed: Path & Query params handled!")
def test_read_item_no_query():
# Only path param 10
response = client.get("/items/10")
assert response.status_code == 200
assert response.json() == {"item_id": 10}
print("Test Passed: Path param only handled!")
if __name__ == "__main__":
print("Testing path and query parameters...")
test_read_item_with_query()
test_read_item_no_query()
Teste POST-forespørsler med JSON
For endepunkter som forventer en forespørselskropp (for eksempel POST eller PUT) kan De sende en Python-ordbok direkte til json-argumentet i klientmetoden. TestClient konverterer automatisk denne ordboken til en JSON-streng og setter riktig Content-Type-hode.
from fastapi import FastAPI
from pydantic import BaseModel
from fastapi.testclient import TestClient
app = FastAPI()
class Product(BaseModel):
name: str
price: float
description: str | None = None
@app.post("/products/")
async def create_product(product: Product):
return product
client = TestClient(app)
def test_create_product():
product_data = {"name": "Widget", "price": 29.99}
response = client.post(
"/products/",
json=product_data
)
assert response.status_code == 200
assert response.json() == {"name": "Widget", "price": 29.99, "description": None}
print("Test Passed: POST request with JSON body!")
if __name__ == "__main__":
print("Testing POST request...")
test_create_product()
Overstyre avhengigheter for testing
En av FastAPIs kraftigste testfunksjoner er muligheten til enkelt å overstyre avhengigheter. Dette er avgjørende for integrasjonstester der De kanskje vil:
- Mocke eksterne tjenester (for eksempel en betalingsløsning).
- Bruke en testdatabase i stedet for produksjonsdatabasen.
- Sette inn bestemte testdata eller konfigurasjoner.
De kan midlertidig erstatte en avhengighetsfunksjon med en annen ved å bruke app.dependency_overrides.
Bruke overstyringer av avhengigheter
For å overstyre en avhengighet tilordner De mock-funksjonen til den opprinnelige avhengighetsfunksjonen i app.dependency_overrides-ordboken. Etter testen er det svært viktig å fjerne disse overstyringene, slik at de ikke påvirker andre tester.
La oss se hvordan en «ekte» innstilling kan erstattes med en «test»-innstilling:
from fastapi import FastAPI, Depends
from fastapi.testclient import TestClient
app = FastAPI()
# Our 'real' dependency function
def get_current_env():
return "production"
@app.get("/environment/")
async def get_environment(env: str = Depends(get_current_env)):
return {"current_environment": env}
client = TestClient(app)
def test_get_environment_default():
response = client.get("/environment/")
assert response.status_code == 200
assert response.json() == {"current_environment": "production"}
print("Default environment test passed!")
def test_get_environment_override():
# Our mock dependency function for testing
def override_get_current_env():
return "test"
# Apply the override
app.dependency_overrides[get_current_env] = override_get_current_env
response = client.get("/environment/")
assert response.status_code == 200
assert response.json() == {"current_environment": "test"}
print("Overridden environment test passed!")
# IMPORTANT: Clear overrides after the test
app.dependency_overrides.clear()
if __name__ == "__main__":
print("Testing dependency overrides...")
test_get_environment_default()
test_get_environment_override()
Sikre opprydding av overstyringer
Hvis app.dependency_overrides ikke tømmes, kan det føre til «lekkende» tester, der en overstyring fra én test utilsiktet påvirker påfølgende tester. Sørg alltid for å tilbakestille app.dependency_overrides, vanligvis ved å sette den tilbake til en tom ordbok eller bruke .clear().
Dette sikrer at hver test kjører i en ren og forutsigbar tilstand.
Test kunnskapene Deres!
Hvilket av følgende utsagn om FastAPIs TestClient er SANT?
Oppsummering og neste steg
Godt jobbet! De har lært å utføre integrasjonstester av FastAPI-applikasjonen Deres:
- Vi har sett på hva integrasjonstesting er, og hvorfor det er viktig.
- De har lært å sette opp og bruke FastAPIs
TestClienttil å simulere ulike HTTP-forespørsler. - Vi har dekket testing av GET- og POST-forespørsler, inkludert håndtering av bane-, spørrings- og JSON-kroppsparametere.
- De forstår nå hvordan De effektivt kan bruke overstyringer av avhengigheter til å isolere og kontrollere testmiljøet.
Disse ferdighetene er avgjørende for å bygge robuste og pålitelige FastAPI-applikasjoner. Fortsett å øve, så skriver De snart omfattende tester!
Lær deg Bootcamp i backendutvikling med FastAPI med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 21
- Leksjoner
- 84
Ofte stilte spørsmål
Er leksjonen «Integrasjonstesting av FastAPI-endepunkter» gratis?
Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Bootcamp i backendutvikling med FastAPI, inkludert «Integrasjonstesting av FastAPI-endepunkter», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Bootcamp i backendutvikling med FastAPI inneholder totalt 4 leksjoner.
Hva lærer jeg i «Integrasjonstesting av FastAPI-endepunkter»?
Utfør integrasjonstester av API-endepunktene dine ved hjelp av FastAPI sin `TestClient` for å simulere forespørsler. Du øver på Bootcamp i backendutvikling med FastAPI med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med Bootcamp i backendutvikling med FastAPI?
Ingen tidligere erfaring er nødvendig. Bootcamp i backendutvikling med FastAPI på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.
Hvor lang tid tar leksjonen «Integrasjonstesting av FastAPI-endepunkter»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne Bootcamp i backendutvikling med FastAPI-leksjonen?
Ja. Alle Bootcamp i backendutvikling med FastAPI-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Enhetstesting med Pytest
- Integrasjonstesting av FastAPI-endepunkter
- Feilsøking av FastAPI-applikasjoner
- Mocking av avhengigheter i FastAPI-tester