Tout ce qu'il faut savoir sur la pyramide des tests
Quand on parle de tests logiciels, il y a quelques règles à garder en tête. Trois catégories de tests sont bien connues. Leurs noms sont les mêmes d'une équipe à l'autre, mais chacune met sa propre définition derrière chaque catégorie. Et cet écart crée plus de confusion que n'importe quel détail technique.
Personnellement, je crois aux définitions ci-dessous. Les règles passent en premier, parce qu'elles s'appliquent à tous les étages.
Pourquoi chaque test doit-il être indépendant ?
✅ Les tests sont indépendants. Un test ne doit JAMAIS en influencer un autre.
Un test qui dépend d'un autre test cache une dépendance. Si le test B passe seulement parce que le test A a d'abord écrit une ligne en base, alors B ne vérifie pas ce que dit son nom. Lancez B tout seul, il échoue. Lancez la suite dans un autre ordre, il échoue encore, pour une raison que personne ne peut voir en lisant B.
Dans cette situation, le temps part dans la chasse à l'ordre caché, pas dans le bug. Le debugging est un tel gaspillage. Chaque test doit créer les données dont il a besoin, s'exécuter, puis nettoyer derrière lui. La suite tourne alors dans n'importe quel ordre et sur n'importe quelle machine, et un échec pointe vers un seul comportement.
Un test doit-il vérifier un comportement ou des détails techniques ?
✅ Ne testez JAMAIS les détails techniques ni les membres privés. Concentrez-vous sur la fonctionnalité.
Un test qui appelle une méthode privée est lié à la façon dont le code est construit aujourd'hui. Renommez la méthode, découpez la classe ou changez l'algorithme, et le test échoue alors que le comportement n'a pas changé. Un tel test bloque le refactoring qu'il devrait protéger.
Un test qui vérifie le résultat reçu par l'appelant survit à ces changements. Les tests qui capturent des comportements deviennent la documentation vivante de ce que fait le système. Vladimir Khorikov développe la même idée dans son livre sur les tests unitaires : testez le comportement observable, pas les détails d'implémentation.
Quand utiliser un stub, et quand utiliser un mock ?
✅ Le « stubbing » est notre ami, le « mocking » pas toujours. Connaissez vos test doubles et les raisons de chaque choix !
Un stub remplace une dépendance par une réponse fixe. Le test contrôle l'entrée et vérifie la sortie de l'unité testée. Un mock vérifie en plus comment il a été appelé. Chaque mock ajoute une attente sur la conversation entre deux classes.
Les attentes sur les appels lient le test à la façon dont le code parle à ses collaborateurs. Changez cette conversation sans changer le résultat, et le test casse. L'article Mocks Aren't Stubs de Martin Fowler décrit la différence entre vérifier un état et vérifier un comportement.
Connaissez la raison de chaque choix. Utilisez un stub quand vous avez besoin d'une réponse fixe de la part d'une dépendance. Utilisez un mock quand l'interaction elle-même est le comportement à protéger, par exemple une notification qui doit partir. Ce second cas doit rester rare.
Que vérifie chaque étage de la pyramide ?
Les tests unitaires vérifient une unité, avec ses dépendances remplacées :
- Ils valident les spécifications fonctionnelles. Ils capturent des comportements, PAS des détails techniques.
- Ils permettent de découvrir l'algorithme. Ils donnent un feedback immédiat, sur les anciennes features comme sur les nouvelles.
- Super rapides ! (~1 seconde).
- Ils utilisent des stubs pour les dépendances et restent indépendants du framework.
- Ils garantissent la non-régression fonctionnelle.
Les tests d'intégration vérifient les dépendances que les tests unitaires ont stubbées :
- Ils vérifient que les dépendances marchent comme prévu.
- En gros, ils testent ce qu'on a stubbé pendant les tests unitaires.
Les tests d'intégration ont besoin d'une vraie dépendance. Ils sont donc plus lents à écrire et à exécuter que les tests unitaires. Gardez chacun concentré sur sa dépendance. Un test qui vérifie comment un repository mappe une ligne fait bien un seul travail. Un test qui parcourt tout le flux métier appartient à l'étage du dessus.
Les tests E2E vérifient le système du côté de l'utilisateur :
- Un test qui traverse les couches et garantit le comportement vu par l'utilisateur.
- Pas de mocks, de stubs ni de fakes. Uniquement des tests système.
- Allez-y doucement ! Ils sont fragiles et cassent facilement.
- Comme les détails de l'UI peuvent bouger, le snapshot testing aide à repérer les régressions accidentelles. C'est sans doute pour l'UI qu'il est le mieux adapté.
La forme vient du coût. Un test unitaire tourne en une seconde environ et échoue pour une seule raison. Un test end-to-end démarre une plus grande partie du système et échoue pour beaucoup de raisons, la plupart sans rapport avec le comportement que vous vouliez vérifier. La base de la pyramide est donc large, et le sommet étroit. La note TestPyramid de Martin Fowler décrit la même forme et le même raisonnement.
Comment construire la pyramide dans une équipe ?
Suivez ces étapes :
- Écrivez un test unitaire pour chaque règle métier, avec ses dépendances stubbées.
- Écrivez un test d'intégration pour chaque dépendance, exécuté contre la vraie.
- Gardez un petit nombre de tests E2E, un par parcours utilisateur clé.
- Donnez à chaque test ses propres données, et nettoyez-les ensuite.
- Nommez chaque test d'après le comportement qu'il vérifie, avec les mots du domaine.
Un test est le premier client du cas d'usage qu'il teste. Il doit donc se lire comme tel. Celui qui ouvre le test doit comprendre la règle sans ouvrir le code.
Quand la pyramide ne convient-elle pas ?
La pyramide est un guide pour la forme, pas une loi. Un système très orienté données peut avoir besoin de beaucoup de tests d'intégration : ses bugs vivent dans le mapping et les requêtes, et un stub ne peut pas reproduire le comportement d'une vraie base de données. Un produit avec une interface complexe peut s'appuyer davantage sur les tests de snapshot et les tests E2E. Le principe en dessous reste le même : testez l'étage où se trouve le risque, et gardez large l'étage rapide.
Le vrai problème, ce sont les noms. « Test d'intégration » veut dire un test de base de données pour une équipe, et un test entre deux services pour une autre. Avant de vous mettre d'accord sur une stratégie, écrivez un exemple concret pour chaque mot que vous utilisez.
💡mêmes noms, mais rarement mêmes définitions.
Ressources et bibliographie
- Martin Fowler, TestPyramid (martinfowler.com, 2012). https://martinfowler.com/bliki/TestPyramid.html
- Martin Fowler, Mocks Aren't Stubs (martinfowler.com, 2007). https://martinfowler.com/articles/mocksArentStubs.html
- Vladimir Khorikov, Unit Testing Principles, Practices, and Patterns (Manning, 2020). https://www.manning.com/books/unit-testing
- Kent Beck, Test-Driven Development: By Example (Addison-Wesley, 2002). https://www.oreilly.com/library/view/test-driven-development/0321146530/
Publié d'abord sur LinkedIn : le post d'origine
