FastAPI-endpoints integratietesten
Voer integratietests uit op uw API-endpoints met FastAPI's `TestClient` om requests te simuleren.
FastAPI-endpoints integratietesten is een gratis Bootcamp backendontwikkeling met FastAPI-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Bootcamp backendontwikkeling met FastAPI. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Bootcamp backendontwikkeling met FastAPI bevat in totaal 4 lessen.
Wat zijn integratietests?
Welkom bij integratietesten! Nadat je unittests hebt geleerd, is het tijd om te bekijken hoe verschillende onderdelen van je FastAPI-toepassing samenwerken.
- Unittests controleren afzonderlijke functies of onderdelen in isolatie.
- Integratietests controleren of meerdere onderdelen van je systeem correct samenwerken. Voor een FastAPI-app betekent dit dat je API-eindpunten test en controleert of ze verzoeken afhandelen, met afhankelijkheden communiceren en de verwachte antwoorden retourneren.
Deze tests zorgen ervoor dat je API zich gedraagt zoals verwacht wanneer alle onderdelen met elkaar verbonden zijn.
Kennismaken met FastAPI's TestClient
FastAPI biedt een krachtig hulpmiddel met de naam TestClient uit fastapi.testclient. Met deze client kun je HTTP-verzoeken naar je FastAPI-toepassing sturen zonder een actieve server te hoeven starten.
- De client simuleert verzoeken rechtstreeks in het geheugen.
- De client is gebouwd boven op de populaire bibliotheek
httpx. - De client is ideaal om tijdens de ontwikkeling snel je API-eindpunten te testen.
Laten we bekijken hoe je dit instelt!
Je TestClient instellen
Om TestClient te gebruiken, moet je eerst de instantie van je FastAPI-toepassing importeren en deze vervolgens doorgeven aan de constructor van TestClient. Hiermee maak je een clientinstantie die klaar is om gesimuleerde verzoeken te versturen.
Voer dit voorbeeld uit om een eenvoudige configuratie te bekijken:
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()
GET-verzoeken testen
GET-verzoeken uitvoeren is eenvoudig. Je roept de .get()-methode aan op je TestClient-instantie en geeft het pad op van het eindpunt dat je wilt testen.
Na het versturen van het verzoek kun je eigenschappen van het response-object, zoals .status_code en .json(), gebruiken om het resultaat te controleren.
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()
Pad- en queryparameters testen
TestClient verwerkt pad- en queryparameters net als een echte browser. Padparameters neem je rechtstreeks op in de URL-tekenreeks en queryparameters kun je aan de URL toevoegen of via het argument params meegeven.
Het gebruik van het argument params voor queryparameters is vaak overzichtelijker en verwerkt URL-codering automatisch.
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()
POST-verzoeken met JSON testen
Voor eindpunten die een verzoektekst verwachten (zoals POST of PUT) kun je rechtstreeks een Python-woordenboek doorgeven aan het argument json van de clientmethode. TestClient zet dit woordenboek automatisch om in een JSON-tekenreeks en stelt de juiste Content-Type-header in.
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()
Afhankelijkheden overschrijven voor tests
Een van de krachtigste testfuncties van FastAPI is de mogelijkheid om afhankelijkheden eenvoudig te overschrijven. Dit is cruciaal voor integratietests waarbij je het volgende wilt kunnen doen:
- Externe diensten simuleren (bijvoorbeeld een betalingsgateway).
- Een testdatabase gebruiken in plaats van de productiedatabase.
- Specifieke testgegevens of configuraties injecteren.
Je kunt een afhankelijkheidsfunctie tijdelijk vervangen door een andere functie met app.dependency_overrides.
Overschrijvingen van afhankelijkheden toepassen
Om een afhankelijkheid te overschrijven, wijs je je simulatiefunctie toe aan de oorspronkelijke afhankelijkheidsfunctie in het woordenboek app.dependency_overrides. Na je test is het belangrijk om deze overschrijvingen te wissen, zodat ze geen invloed hebben op andere tests.
Laten we bekijken hoe je een 'echte' instelling vervangt door een 'test'-instelling:
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()
Overschrijvingen opruimen
Als je app.dependency_overrides niet wist, kunnen er 'lekkende' tests ontstaan waarbij een overschrijving uit de ene test onbedoeld invloed heeft op volgende tests. Zorg er altijd voor dat je app.dependency_overrides terugzet, meestal door deze opnieuw in te stellen als een leeg woordenboek of door .clear() te gebruiken.
Zo draait elke test in een schone, voorspelbare toestand.
Test je kennis!
Welke van de volgende uitspraken over FastAPI's TestClient is WAAR?
Samenvatting en volgende stappen
Goed gedaan! Je hebt geleerd hoe je integratietests uitvoert voor je FastAPI-toepassing:
- We hebben bekeken wat integratietesten zijn en waarom ze cruciaal zijn.
- Je hebt geleerd hoe je FastAPI's
TestClientinstelt en gebruikt om verschillende HTTP-verzoeken te simuleren. - We hebben het testen van GET- en POST-verzoeken behandeld, inclusief het verwerken van pad-, query- en JSON-tekstparameters.
- Je begrijpt nu hoe je overschrijvingen van afhankelijkheden effectief gebruikt om je testomgeving te isoleren en te beheren.
Deze vaardigheden zijn essentieel voor het bouwen van robuuste en betrouwbare FastAPI-toepassingen. Blijf oefenen, dan schrijf je in korte tijd uitgebreide tests!
Leer Bootcamp backendontwikkeling met FastAPI met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 21
- Lessen
- 84
Veelgestelde vragen
Is de les “FastAPI-endpoints integratietesten” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Bootcamp backendontwikkeling met FastAPI, waaronder “FastAPI-endpoints integratietesten”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Bootcamp backendontwikkeling met FastAPI bevat in totaal 4 lessen.
Wat leer ik in “FastAPI-endpoints integratietesten”?
Voer integratietests uit op uw API-endpoints met FastAPI's `TestClient` om requests te simuleren. Je oefent met Bootcamp backendontwikkeling met FastAPI door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Bootcamp backendontwikkeling met FastAPI te beginnen?
Ervaring vooraf is niet nodig. Bootcamp backendontwikkeling met FastAPI op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.
Hoe lang duurt de les “FastAPI-endpoints integratietesten”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Bootcamp backendontwikkeling met FastAPI?
Ja. Elke les over Bootcamp backendontwikkeling met FastAPI bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Unit testen met Pytest
- FastAPI-endpoints integratietesten
- FastAPI-applicaties debuggen
- Dependencies mocken in FastAPI-tests