FastAPI-päätepisteiden integraatiotestaus
Suorittakaa API-päätepisteiden integraatiotestejä FastAPI:n `TestClient`-luokalla pyyntöjen simulointia varten.
FastAPI-päätepisteiden integraatiotestaus on ilmainen FastAPI-backend-kehityksen intensiivikurssi-oppitunti CoddyKitissä. Tämä on oppitunti 2/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu FastAPI-backend-kehityksen intensiivikurssi-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. FastAPI-backend-kehityksen intensiivikurssi-kurssilla on yhteensä 4 oppituntia.
Mitä integraatiotestaus on?
Tervetuloa integraatiotestauksen pariin! Yksikkötesteihin tutustumisen jälkeen on aika tarkastella, miten FastAPI-sovelluksen eri osat toimivat yhdessä.
- Yksikkötesteillä tarkistetaan yksittäisiä funktioita tai komponentteja eristettyinä.
- Integraatiotesteillä varmistetaan, että järjestelmän useat komponentit toimivat oikein yhdessä. FastAPI-sovelluksessa tämä tarkoittaa API-päätepisteiden testaamista ja sen tarkistamista, miten ne käsittelevät pyyntöjä, käyttävät riippuvuuksia ja palauttavat odotettuja vastauksia.
Näillä testeillä varmistetaan, että API toimii odotetulla tavalla kaikkien osien ollessa yhdistettyinä.
FastAPI:n TestClientin esittely
FastAPI tarjoaa tehokkaan työkalun nimeltä TestClient, joka tulee moduulista fastapi.testclient. Tämän clientin avulla voit lähettää HTTP-pyyntöjä FastAPI-sovellukseen ilman käynnissä olevaa palvelinta.
- Se simuloi pyynnöt suoraan muistissa.
- Se perustuu suosittuun
httpx-kirjastoon. - Se sopii erinomaisesti API-päätepisteiden nopeaan testaamiseen kehityksen aikana.
Katsotaan, miten se määritetään!
TestClientin määrittäminen
Käyttääksesi TestClient-clientia sinun on ensin tuotava FastAPI-sovelluksen ilmentymä ja välitettävä se sitten TestClient-konstruktorille. Näin luodaan client-ilmentymä, joka on valmis lähettämään simuloituja pyyntöjä.
Kokeile suorittaa tämä esimerkki nähdäksesi perusmäärityksen:
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-pyyntöjen testaaminen
GET-pyyntöjen lähettäminen on suoraviivaista. Kutsut vain .get()-metodia TestClient-ilmentymälle ja välität sille testattavan päätepisteen polun.
Pyynnön lähettämisen jälkeen voit tarkistaa tuloksen response-olion ominaisuuksien, kuten .status_code- ja .json()-arvojen, avulla.
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()
Polku- ja kyselyparametrien testaaminen
TestClient käsittelee polku- ja kyselyparametreja samalla tavalla kuin oikea selain. Polkuparametrit lisätään suoraan URL-merkkijonoon, ja kyselyparametrit voidaan lisätä URL-osoitteeseen tai välittää params-argumentilla.
params-argumentin käyttäminen kyselyparametreille on usein selkeämpää, ja se käsittelee URL-koodauksen automaattisesti.
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()
JSON-muotoisten POST-pyyntöjen testaaminen
Pyyntöosan odottaville päätepisteille (kuten POST- tai PUT-pyynnöille) voit välittää Python-sanakirjan suoraan client-metodin json-argumenttiin. TestClient muuntaa sanakirjan automaattisesti JSON-merkkijonoksi ja asettaa asianmukaisen Content-Type-otsakkeen.
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()
Riippuvuuksien ohittaminen testausta varten
Yksi FastAPI:n tehokkaimmista testausominaisuuksista on mahdollisuus ohittaa riippuvuuksia helposti. Tämä on olennaista integraatiotesteissä, joissa saatat haluta:
- Simuloida ulkoisia palveluita (esimerkiksi maksupalvelua).
- Käyttää testitietokantaa tuotantotietokannan sijaan.
- Syöttää tiettyjä testitietoja tai määrityksiä.
Voit korvata riippuvuusfunktion tilapäisesti toisella funktiolla käyttämällä app.dependency_overrides-sanakirjaa.
Riippuvuuksien ohitusten käyttöönotto
Ohita riippuvuus sijoittamalla mock-funktiosi alkuperäisen riippuvuusfunktion arvoksi app.dependency_overrides-sanakirjaan. Testin jälkeen ohitukset on ehdottomasti tyhjennettävä, jotta ne eivät vaikuta muihin testeihin.
Katsotaan, miten 'oikea' asetus korvataan 'testi'asetuksella:
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()
Ohitusten siivouksen varmistaminen
Jos app.dependency_overrides-sanakirjaa ei tyhjennetä, testit voivat vuotaa: yhden testin ohitus vaikuttaa tahattomasti seuraaviin testeihin. Muista aina palauttaa app.dependency_overrides alkutilaan, yleensä asettamalla sen arvoksi tyhjä sanakirja tai käyttämällä .clear()-metodia.
Näin jokainen testi suoritetaan puhtaassa ja ennakoitavassa tilassa.
Testaa tietosi!
Mikä seuraavista FastAPI:n TestClient-clientia koskevista väitteistä on TOSI?
Kertaus ja seuraavat vaiheet
Hienoa työtä! Olet oppinut suorittamaan FastAPI-sovelluksen integraatiotestejä:
- Tutustuimme siihen, mitä integraatiotestaus on ja miksi se on tärkeää.
- Opit määrittämään ja käyttämään FastAPI:n
TestClient-clientia erilaisten HTTP-pyyntöjen simulointiin. - Käsittelimme GET- ja POST-pyyntöjen testaamista, mukaan lukien polku-, kysely- ja JSON-pyyntöosan parametrien käsittely.
- Ymmärrät nyt, miten riippuvuuksien ohituksia käytetään tehokkaasti testiympäristön eristämiseen ja hallintaan.
Nämä taidot ovat olennaisia vankkojen ja luotettavien FastAPI-sovellusten rakentamisessa. Jatka harjoittelua, niin kirjoitat kattavia testejä hetkessä!
Opi FastAPI-backend-kehityksen intensiivikurssi tekoälytuutorin avulla — ilmaiseksi
Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.
- Kurssit
- 21
- Oppitunnit
- 84
Usein kysytyt kysymykset
Onko oppitunti ”FastAPI-päätepisteiden integraatiotestaus” ilmainen?
Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa FastAPI-backend-kehityksen intensiivikurssi-oppimispolun 3 oppituntia, myös oppitunnin “FastAPI-päätepisteiden integraatiotestaus”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. FastAPI-backend-kehityksen intensiivikurssi-kurssilla on yhteensä 4 oppituntia.
Mitä opin oppitunnilla ”FastAPI-päätepisteiden integraatiotestaus”?
Suorittakaa API-päätepisteiden integraatiotestejä FastAPI:n `TestClient`-luokalla pyyntöjen simulointia varten. Harjoittelet FastAPI-backend-kehityksen intensiivikurssi-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.
Tarvitsenko kokemusta aloittaakseni FastAPI-backend-kehityksen intensiivikurssi-opiskelun?
Aiempi kokemus ei ole tarpeen. CoddyKitin FastAPI-backend-kehityksen intensiivikurssi-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 2/4.
Kuinka kauan ”FastAPI-päätepisteiden integraatiotestaus”-oppitunnin suorittaminen kestää?
Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.
Voinko kirjoittaa ja suorittaa koodia tällä FastAPI-backend-kehityksen intensiivikurssi-oppitunnilla?
Kyllä. Jokainen FastAPI-backend-kehityksen intensiivikurssi-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.
Kaikki tämän kurssin oppitunnit
- Yksikkötestaus Pytestillä
- FastAPI-päätepisteiden integraatiotestaus
- FastAPI-sovellusten virheenkorjaus
- Riippuvuuksien mockaus FastAPI-testeissä