Bootcamp i FastAPI-backendudvikling · Lektion

Integrationstest af FastAPI-endpoints

Udfør integrationstests af Deres API-endpoints ved hjælp af FastAPI's `TestClient` til at simulere requests.

Lektion 2 af 411 trin

Integrationstest af FastAPI-endpoints er en gratis Bootcamp i FastAPI-backendudvikling-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Bootcamp i FastAPI-backendudvikling, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Bootcamp i FastAPI-backendudvikling-kurset indeholder 4 lektioner i alt.

Hvad er integrationstest?

Velkommen til integrationstest! Efter at have lært om enhedstest er det tid til at se, hvordan forskellige dele af din FastAPI-applikation fungerer sammen.

Enhedstest kontrollerer individuelle funktioner eller komponenter isoleret.
Integrationstest kontrollerer, at flere komponenter i dit system interagerer korrekt. I en FastAPI-app betyder det, at du tester dine API-endepunkter, kontrollerer, om de håndterer forespørgsler, interagerer med afhængigheder og returnerer de forventede svar.

Disse test sikrer, at dit API fungerer som forventet, når alle delene er forbundet.

Introduktion til FastAPIs TestClient

FastAPI indeholder et effektivt værktøj kaldet TestClient fra fastapi.testclient. Denne klient giver dig mulighed for at sende HTTP-forespørgsler til din FastAPI-applikation uden at skulle køre en aktiv server.

Den simulerer forespørgsler direkte i hukommelsen.
Den er bygget oven på det populære bibliotek httpx.
Den er ideel til hurtigt at teste dine API-endepunkter under udviklingen.

Lad os se, hvordan du konfigurerer den!

Konfiguration af din TestClient

For at bruge TestClient skal du først importere din FastAPI-applikationsinstans og derefter sende den til TestClient-konstruktøren. Det opretter en klientinstans, der er klar til at sende simulerede forespørgsler.

Prøv at køre dette eksempel for at se en grundlæggende opsætning:

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()

Test af GET-forespørgsler

Det er enkelt at sende GET-forespørgsler. Du kalder blot .get()-metoden på din TestClient-instans og angiver stien til det endepunkt, du vil teste.

Efter at have sendt forespørgslen kan du tilgå egenskaber for response-objektet, såsom .status_code og .json(), for at 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()

Test af sti- og forespørgselsparametre

TestClient håndterer sti- og forespørgselsparametre ligesom en rigtig browser. Stiparametre inkluderes direkte i URL-strengen, og forespørgselsparametre kan føjes til URL'en eller sendes via params-argumentet.

Det er ofte mere overskueligt at bruge params-argumentet til forespørgselsparametre, og det håndterer automatisk URL-kodningen.

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()

Test af POST-forespørgsler med JSON

For endepunkter, der forventer en forespørgselskrop (som POST eller PUT), kan du sende en Python-ordbog direkte til json-argumentet i klientmetoden. TestClient konverterer automatisk denne ordbog til en JSON-streng og angiver den korrekte Content-Type-header.

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()

Tilsidesættelse af afhængigheder til test

En af FastAPIs mest effektive testfunktioner er muligheden for nemt at tilsidesætte afhængigheder. Det er afgørende ved integrationstest, hvor du måske vil:

Simulere eksterne tjenester (for eksempel en betalingsgateway).
Bruge en testdatabase i stedet for produktionsdatabasen.
Indsætte bestemte testdata eller konfigurationer.

Du kan midlertidigt erstatte en afhængighedsfunktion med en anden ved hjælp af app.dependency_overrides.

Anvendelse af tilsidesættelser af afhængigheder

Hvis du vil tilsidesætte en afhængighed, tildeler du din simuleringsfunktion til den oprindelige afhængighedsfunktion i ordbogen app.dependency_overrides. Efter testen er det vigtigt at rydde disse tilsidesættelser for at forhindre, at de påvirker andre test.

Lad os se, hvordan du erstatter en "rigtig" indstilling med en "test"-indstilling:

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()

Sikring af oprydning efter tilsidesættelser

Hvis du ikke rydder app.dependency_overrides, kan det føre til "utætte" test, hvor en tilsidesættelse fra én test utilsigtet påvirker efterfølgende test. Sørg altid for at nulstille app.dependency_overrides, typisk ved at sætte den tilbage til en tom ordbog eller bruge .clear().

Det sikrer, at hver test kører i en ren og forudsigelig tilstand.

Test din viden!

Hvilken af følgende påstande om FastAPIs TestClient er SAND?

Besvar den i den interaktive lektion

Opsummering og næste trin

Godt gået! Du har lært at udføre integrationstest af din FastAPI-applikation:

Vi undersøgte, hvad integrationstest er, og hvorfor det er vigtigt.
Du har lært at konfigurere og bruge FastAPIs TestClient til at simulere forskellige HTTP-forespørgsler.
Vi gennemgik test af GET- og POST-forespørgsler, herunder håndtering af sti-, forespørgsels- og JSON-kropsparametre.
Du forstår nu, hvordan du effektivt bruger tilsidesættelser af afhængigheder til at isolere og styre dit testmiljø.

Disse færdigheder er afgørende, når du skal bygge robuste og pålidelige FastAPI-applikationer. Bliv ved med at øve dig, så skriver du snart omfattende test!

Gratis at komme i gang

Lær Bootcamp i FastAPI-backendudvikling med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 21
Lektioner: 84

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Integrationstest af FastAPI-endpoints” gratis?

Ja — alle 3 lektioner i læringssporet Bootcamp i FastAPI-backendudvikling, inklusive “Integrationstest af FastAPI-endpoints”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Bootcamp i FastAPI-backendudvikling-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Integrationstest af FastAPI-endpoints”?

Udfør integrationstests af Deres API-endpoints ved hjælp af FastAPI's `TestClient` til at simulere requests. Du øver dig i Bootcamp i FastAPI-backendudvikling med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Bootcamp i FastAPI-backendudvikling?

Der kræves ingen tidligere erfaring. Bootcamp i FastAPI-backendudvikling på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “Integrationstest af FastAPI-endpoints”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Bootcamp i FastAPI-backendudvikling-lektion?

Ja. Alle Bootcamp i FastAPI-backendudvikling-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Bootcamp i FastAPI-backendudvikling