Comment configurer l'environnement de test pour une application FastAPI

Pour tester correctement une application FastAPI, il est essentiel de configurer un environnement de test adéquat. Cela permet de valider le bon fonctionnement des endpoints, des bases de données et d'autres parties de l'application avant de déployer le code en production. Le processus de configuration des tests pour une application FastAPI suit plusieurs étapes fondamentales, qui incluent la création de fichiers de configuration, la définition de tests unitaires et l'exécution de tests d'intégration.

La première étape consiste à définir la structure du projet. Un projet FastAPI minimaliste doit commencer par la création d'un dossier de tests, qui contiendra tous les modules nécessaires pour tester l'application. Il est également nécessaire d'ajouter un fichier de configuration pytest.ini à la racine du projet. Ce fichier doit contenir des instructions pour pytest, un framework populaire pour les tests en Python, et il inclura la définition du chemin PYTHONPATH pour que pytest sache où trouver les modules de l'application. La structure du projet pourrait ressembler à ceci :

css
Copy code
protoapp/

│─ protoapp/
│  │─ main.py
│─ tests/
│  │─ test_main.py
│─ pytest.ini

Le fichier pytest.ini devrait inclure la ligne suivante pour que pytest sache où chercher les modules de l'application :

csharp
Copy code
[pytest]
pythonpath = .
protoapp

python
Copy code
import pytest
from httpx import ASGITransport, AsyncClient
from protoapp.main import app
@pytest.mark.asyncio
async def test_read_main():
    client = AsyncClient(
        transport=ASGITransport(app=app),
        base_url="http://test",
    )
    response = await client.get("/home")
    assert response.status_code == 200
    assert response.json() == {"message": "Hello World"}

Une fois le test écrit, il est possible de vérifier sa bonne configuration en collectant tous les tests dans le projet avec la commande suivante :

lua
Copy code
$ pytest --collect-only

Cette commande permet de vérifier que pytest trouve bien tous les tests définis dans le projet et est capable de les exécuter correctement. Si tout est configuré correctement, on peut ensuite exécuter les tests avec la commande :

ruby
Copy code
$ pytest

Une fois les tests exécutés, pytest affichera les résultats, vous indiquant si les tests ont réussi ou échoué.

Écriture et exécution de tests unitaires

Dans le cadre de FastAPI, les tests unitaires se concentrent principalement sur les endpoints de l'application. Par exemple, nous pouvons tester un endpoint GET /home avec la classe TestClient fournie par FastAPI. Cette classe permet d'effectuer des requêtes HTTP synchrones pour tester les endpoints de manière plus simple et plus rapide que d'autres solutions comme httpx.

python
Copy code
import pytest
from fastapi.testclient import TestClient
from protoapp.main import app
@pytest.fixture(scope="function")
def test_client():
    client = TestClient(app)
    yield client

Une fois cette fixture définie, il devient facile de l'utiliser dans le test pour effectuer une requête GET sur le endpoint /home :

python
Copy code
def test_read_main_client(test_client):

    response = test_client.get("/home")
    assert response.status_code == 200
    assert response.json() == {"message": "Hello World"}

Cette approche permet d'écrire des tests plus compacts et plus rapides que ceux utilisant httpx. Une fois le test écrit, il suffit de lancer pytest à nouveau :

ruby
Copy code
$ pytest

Si tout fonctionne comme prévu, vous obtiendrez un retour indiquant que les tests ont été exécutés avec succès.

Tests d'intégration

Prenons l'exemple d'une application qui utilise une base de données SQL. Pour tester l'ajout et la lecture d'éléments dans la base de données, il est nécessaire de configurer une connexion à la base de données dans l'application. Voici un exemple de configuration d'une base de données avec SQLAlchemy dans un module database.py :

python
Copy code
from sqlalchemy.orm import DeclarativeBase, sessionmaker, Session

from sqlalchemy import create_engine
DATABASE_URL = "sqlite:///./production.db"
engine = create_engine(DATABASE_URL)
class Base(DeclarativeBase):
    pass
class Item(Base):
    __tablename__ = "items"
    id = mapped_column(primary_key=True, index=True)
    name = mapped_column(index=True)
    color = mapped_column()

Ensuite, il faut configurer la session de base de données dans le fichier main.py :

python
Copy code
from protoapp.database import SessionLocal
def get_db_session():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

Les endpoints qui interagiront avec la base de données pourront maintenant être créés. Par exemple, un endpoint permettant d'ajouter un élément à la base de données pourrait ressembler à ceci :

python
Copy code
from fastapi import FastAPI, Depends

from sqlalchemy.orm import Session
from protoapp.database import get_db_session, Item
app = FastAPI()
@app.post("/items/")
async def create_item(name: str, color: str, db: Session = Depends(get_db_session)):
    item = Item(name=name, color=color)
    db.add(item)
    db.commit()
    db.refresh(item)
    return item

Une fois l'endpoint créé, un test d'intégration pourra être écrit pour vérifier l'ajout d'un élément à la base de données, en utilisant la fixture définie précédemment. Il sera aussi nécessaire de vérifier que la base de données retourne les données ajoutées via un autre endpoint qui lit les éléments de la base de données.

Les tests d'intégration garantissent que l'application fonctionne correctement en combinant plusieurs composants du système. Ils permettent de s'assurer que les données sont correctement ajoutées à la base de données et peuvent être lues sans erreurs.

Comment déployer une application FastAPI avec HTTPS pour le développement local

Lorsque vous travaillez sur une application web, la sécurité est une considération primordiale. Le protocole HTTPS (HyperText Transfer Protocol Secure) est la méthode de base permettant de sécuriser les communications entre le client et le serveur en cryptant les données échangées. Dans cet article, nous allons explorer comment activer HTTPS sur une application FastAPI pour des tests locaux, en utilisant l'outil mkcert pour générer des certificats SSL/TLS et en fournissant des conseils pour un déploiement en production.

Avant de commencer, il est essentiel d’avoir une version de FastAPI supérieure à 0.111.0 installée dans votre environnement. Assurez-vous d’avoir cette version ou une version plus récente en exécutant la commande suivante :

ruby
Copy code
$ pip install "fastapi~=0.111.0"

Si vous avez déjà installé FastAPI, vous pouvez également vérifier si vous disposez de la dernière version en utilisant la commande suivante :

lua
Copy code
$ pip install fastapi --upgrade

Une fois l'installation terminée, nous pouvons commencer à configurer l'application. Créez un dossier de projet, par exemple live_application, et ajoutez un sous-dossier app contenant un fichier main.py avec le code suivant :

python
Copy code
from fastapi import FastAPI
app = FastAPI(title="FastAPI Live Application")
@app.get("/")
def read_root():
    return {"Hello": "World"}

Avec cette configuration de base, l’application dispose d’un point de terminaison simple accessible via la route /, qui renvoie un message JSON. Pour démarrer le serveur en mode développement, utilisez la commande suivante :

ruby
Copy code
$ fastapi dev

Le serveur démarre alors et affiche des informations utiles, y compris les adresses auxquelles l'application est accessible localement. Le mode développement active le rechargement automatique de l'application à chaque modification du code, ce qui est pratique pendant le développement.

Activer HTTPS sur FastAPI pour des tests locaux

1. Installation de mkcert

   Avant tout, installez mkcert sur votre machine. L'installation dépend de votre système d'exploitation, mais les instructions sont disponibles sur la page GitHub du projet ici. Une fois installé, exécutez la commande suivante pour vérifier que mkcert fonctionne correctement :

   ruby
   Copy code
   $ mkcert
   
   

2. Configurer les certificats SSL/TLS

   Pour créer des certificats pour le domaine localhost et l'adresse 127.0.0.1, utilisez la commande suivante :

   ruby
   Copy code
   $ mkcert localhost 127.0.0.1
   

   Cela générera deux fichiers : un fichier clé privée (example.com+5-key.pem) et un certificat (example.com+5.pem). Ces fichiers seront utilisés pour activer HTTPS sur votre serveur FastAPI.

3. Installer le certificat dans le magasin de confiance de votre système

   Avant de commencer à utiliser les certificats générés, vous devez permettre à votre navigateur de leur faire confiance. Cela se fait en exécutant la commande suivante :

   ruby
   Copy code
   $ mkcert -install
   
   

   Cela ajoute un certificat local à votre magasin de confiance, ce qui permettra à vos navigateurs de l’accepter automatiquement comme source fiable.

4. Démarrer le serveur avec HTTPS

   Pour démarrer le serveur avec les certificats SSL/TLS, utilisez la commande uvicorn comme suit :

   lua
   Copy code
   $ uvicorn app.main:app --port 443 --ssl-keyfile example.com+5-key.pem --ssl-certfile example.com+5.pem
   

   Cela démarre le serveur FastAPI sur le port 443, en utilisant le certificat SSL et la clé privée. Une fois le serveur lancé, ouvrez votre navigateur et accédez à l'adresse https://localhost:443. Vous devriez voir un petit cadenas dans la barre d'adresse, ce qui signifie que la connexion est sécurisée.

5. Redirection automatique vers HTTPS

   Par défaut, si vous tentez d’accéder à votre application via HTTP (par exemple, http://localhost:443), vous obtiendrez une erreur. Pour éviter cela, vous pouvez configurer une redirection automatique de HTTP vers HTTPS en utilisant un middleware spécifique à FastAPI. Voici comment l'ajouter dans votre fichier main.py :

   python
   Copy code
   from fastapi import FastAPI
   
   from fastapi.middleware.httpsredirect import HTTPSRedirectMiddleware
   app = FastAPI(title="FastAPI Live Application")
   app.add_middleware(HTTPSRedirectMiddleware)
   

   Ce middleware redirigera automatiquement les requêtes HTTP vers HTTPS, garantissant ainsi une communication sécurisée sur toute la durée de l'utilisation de l'application.

Conseils pour la production

Si vous envisagez de déployer votre application FastAPI en production, il est crucial de mettre en place des pratiques de sécurité adaptées. Bien que mkcert soit utile pour les tests locaux, il ne doit pas être utilisé en production. Pour les déploiements en production, vous devez obtenir un certificat SSL/TLS valide, émis par une autorité de certification reconnue. De plus, il est recommandé d’utiliser un serveur comme nginx ou traefik en tant que reverse proxy pour gérer les connexions HTTPS de manière sécurisée.

L'utilisation de HTTPS garantit que toutes les informations sensibles transmises entre le client et le serveur sont cryptées, ce qui protège contre l'écoute clandestine et l'altération des données. Cela renforce la confiance des utilisateurs et est désormais indispensable dans le développement d'applications web modernes.