Tests (Flask)

Les tests permettent de vérifier que les différentes parties de l’application fonctionnent comme prévu, de détecter les régressions et d’assurer la fiabilité du code.

Dans Flask, on peut tester :

Les routes et endpoints (réponses HTTP, statuts, contenus)
La logique métier (fonctions et classes)
L’intégration avec la base de données ou d’autres services

Comment ça fonctionne dans Flask

1. Configuration pour les tests

Flask fournit un mode testing via app.config['TESTING'] = True.
Ce mode active des comportements adaptés aux tests : gestion spéciale des erreurs, suppression des commits automatiques dans certaines extensions, etc.

2. Client de test

Flask propose un test client pour simuler des requêtes HTTP sans lancer le serveur :

Permet de tester GET, POST, PUT, DELETE avec envoi de données ou JSON.

3. Tests unitaires et intégration

Tests unitaires : tester chaque fonction ou méthode indépendamment.
Tests d’intégration : tester plusieurs composants ensemble (ex. route + base de données).
On utilise souvent unittest ou pytest pour structurer les tests.

4. Gestion de la base de données pour les tests

Créer une base temporaire ou utiliser une base en mémoire (sqlite:///:memory:).
Isoler les tests pour qu’ils ne polluent pas la base de production.

Bonnes pratiques

Tester toutes les routes importantes avec différents scénarios (succès, échec, entrées invalides).
Séparer les tests unitaires et les tests d’intégration pour faciliter le diagnostic.
Automatiser les tests avec pytest ou un pipeline CI/CD.
Utiliser des fixtures ou des mocks pour simuler les dépendances externes.

Pourquoi c’est important

Détecte rapidement les bugs avant la mise en production.
Facilite les évolutions et la maintenance du code.
Garantit que les fonctionnalités critiques restent opérationnelles après des modifications.

En résumé

Flask fournit un environnement simple pour tester routes et logique métier.
Les tests unitaires et d’intégration assurent la fiabilité de l’application.
Une bonne stratégie de tests permet de déployer avec confiance et d’éviter les régressions.

Fonctions :

Tests avec Flask

Exemple de code :

from flask import Flask
import unittest

# 1️⃣ Création de l'application Flask
app = Flask(__name__)

@app.route("/")
def home():
    return "Bienvenue sur la page d'accueil !"

@app.route("/user/<username>")
def show_user(username):
    return f"Bonjour, {username} !"

# 2️⃣ Classe de tests avec unittest
class FlaskTestCase(unittest.TestCase):

    # Configuration avant chaque test
    def setUp(self):
        self.app = app.test_client()  # Client de test Flask
        self.app.testing = True       # Mode test activé

    # Test de la route d'accueil
    def test_home(self):
        response = self.app.get("/")  # Simule un GET sur la route "/"
        self.assertEqual(response.status_code, 200)  # Vérifie le code HTTP
        self.assertIn(b"Bienvenue", response.data)   # Vérifie le contenu de la réponse

    # Test de la route utilisateur
    def test_show_user(self):
        response = self.app.get("/user/Alice")
        self.assertEqual(response.status_code, 200)
        self.assertIn(b"Bonjour, Alice", response.data)

# 3️⃣ Lancer les tests
if __name__ == "__main__":
    unittest.main()

Explication du code :

from flask import Flask importe la classe Flask pour créer l’application web.
 import unittest importe le module standard de Python pour créer et exécuter des tests unitaires.
 app = Flask(__name__) crée une instance de l’application Flask.
Définition des routes
 @app.route("/") définit la route principale accessible à http://127.0.0.1:5000/.
 return "Bienvenue sur la page d'accueil !" renvoie le texte au navigateur.
 @app.route("/user/<username>") définit une route dynamique qui capture le nom d’utilisateur dans l’URL.
 return f"Bonjour, {username} !" renvoie un message personnalisé au navigateur.
Classe de tests avec unittest
 class FlaskTestCase(unittest.TestCase): crée une classe de tests qui hérite de unittest.TestCase, permettant de définir des tests unitaires.
 Configuration avant chaque test
 def setUp(self): est exécuté avant chaque test pour préparer l’environnement.
 self.app = app.test_client() crée un client de test Flask capable de simuler des requêtes HTTP.
 self.app.testing = True active le mode test pour gérer les exceptions et les erreurs proprement.
 Test de la route d'accueil
 response = self.app.get("/") simule un GET sur la route "/".
 self.assertEqual(response.status_code, 200) vérifie que le serveur renvoie le code HTTP 200.
 self.assertIn(b"Bienvenue", response.data) vérifie que la réponse contient le texte attendu. Le préfixe b indique que c’est une chaîne en bytes.
 Test de la route utilisateur
 response = self.app.get("/user/Alice") simule un GET sur la route "/user/Alice".
 self.assertEqual(response.status_code, 200) vérifie le code HTTP.
 self.assertIn(b"Bonjour, Alice", response.data) vérifie que le message renvoyé contient le texte attendu.
 Lancer les tests
 if __name__ == "__main__": vérifie que le fichier est exécuté directement.
 unittest.main() lance tous les tests définis dans la classe FlaskTestCase et affiche les résultats dans la console.