Tests (Fast API)

Les tests permettent de vérifier que les endpoints, la logique métier et les interactions avec les dépendances fonctionnent correctement.
Dans FastAPI, on peut tester :

Les routes et endpoints (statuts HTTP, contenus JSON, en-têtes)
La logique des fonctions indépendantes du framework
L’intégration avec des bases de données ou des services externes

Comment ça fonctionne dans FastAPI

1. Configuration pour les tests

FastAPI utilise un client de test pour simuler des requêtes HTTP sans lancer le serveur.
On peut configurer les tests pour utiliser une base de données temporaire ou des dépendances mockées.

2. Types de tests

Tests unitaires : tester la logique métier (fonctions, classes, validation de données) indépendamment des routes.
Tests d’intégration : tester la route, la logique métier et les dépendances ensemble.

3. Gestion de la base de données et dépendances

Utiliser des bases temporaires ou en mémoire pour les tests afin de ne pas affecter les données de production.
Remplacer certaines dépendances par des versions testables ou mockées pour isoler les composants.

Bonnes pratiques

Tester tous les endpoints principaux avec différents cas (succès, erreurs, entrées invalides).
Séparer tests unitaires et tests d’intégration pour plus de clarté.
Automatiser les tests avec un outil comme pytest et intégrer les tests dans un pipeline CI/CD.
Mockez les services externes pour éviter les effets de bord.

Pourquoi c’est important

Garantit la fiabilité des routes et de la logique métier.
Permet de détecter rapidement les régressions après des modifications.
Facilite le déploiement et la maintenance de l’application FastAPI.

En résumé

FastAPI offre des outils pour tester les routes et la logique métier sans lancer le serveur.
Les tests unitaires et d’intégration assurent la stabilité de l’application.
Une bonne couverture de tests rend le code plus sûr, maintenable et prévisible.

Fonctions :

Tests avec Fast API

Exemple de code :

from fastapi import FastAPI
from fastapi.testclient import TestClient

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Bienvenue sur FastAPI !"}

@app.get("/items/{item_id}")
def read_item(item_id: int):
    return {"item_id": item_id}

# Création du client de test
client = TestClient(app)

# Test de la route racine
def test_read_root():
    response = client.get("/")
    assert response.status_code == 200
    assert response.json() == {"message": "Bienvenue sur FastAPI !"}

# Test de la route avec paramètre
def test_read_item():
    response = client.get("/items/5")
    assert response.status_code == 200
    assert response.json() == {"item_id": 5}

Explication du code :

from fastapi import FastAPI importe la classe FastAPI pour créer l’application web.
 from fastapi.testclient import TestClient importe TestClient, un outil permettant de simuler des requêtes HTTP pour tester l’application sans démarrer le serveur.
Créer l’application FastAPI
 app = FastAPI() crée une instance de l’application FastAPI.
Définir les routes à tester
 @app.get("/") définit la route racine accessible à /.
 return {"message": "Bienvenue sur FastAPI !"} renvoie un message JSON.
 @app.get("/items/{item_id}") définit une route dynamique avec paramètre item_id.
 return {"item_id": item_id} renvoie l’ID de l’item dans la réponse JSON.
Créer un client de test
 client = TestClient(app) crée un client capable d’envoyer des requêtes HTTP simulées à l’application FastAPI.
Test de la route racine
 def test_read_root(): définit une fonction de test pour la route /.
 response = client.get("/") envoie une requête GET simulée à la route racine.
 assert response.status_code == 200 vérifie que le code HTTP renvoyé est bien 200.
 assert response.json() == {"message": "Bienvenue sur FastAPI !"} vérifie que le contenu JSON est correct.
Test de la route avec paramètre
 def test_read_item(): définit une fonction de test pour la route /items/{item_id}.
 response = client.get("/items/5") envoie une requête GET simulée avec item_id=5.
 assert response.status_code == 200 vérifie que le code HTTP est 200.
 assert response.json() == {"item_id": 5} vérifie que le JSON renvoyé contient bien l’ID attendu.