Développement logiciel
Tests Java et TDD avec JUnit 5
Formation concrète sur les tests Java pour les équipes dont la suite est lente, fragile ou discrètement ignorée. Les participants écrivent des tests avec JUnit 5, isolent les collaborateurs avec Mockito, sollicitent de vraies dépendances via Testcontainers et pratiquent le cycle piloté par les tests sur leur propre backlog.
Aperçu
Un apprentissage pratique pour le transfert en situation de travail.
Une suite de tests trahit une équipe de deux manières : elle casse dès qu'on refactorise, ou elle reste au vert pendant que les défauts atteignent les clients. Les deux viennent d'assertions portant sur l'implémentation plutôt que sur le comportement, et finissent de même : une équipe qui contourne la suite pour tenir une échéance. Cette formation reconstruit la discipline consistant à décider quoi vérifier, quoi isoler et quoi laisser réel, en exploitant des capacités de JUnit 5 rarement adoptées : tests paramétrés et imbriqués, contrôle du cycle de vie, assertions groupées et exécution par tags. Les participants pratiquent le cycle rouge-vert-refactor sur du code écrit sans tests.
Prérequis
Expérience pratique du développement Java et familiarité avec Maven ou Gradle. Aucune expérience préalable de JUnit 5 n'est nécessaire.
Objectifs
- Écrire des tests JUnit 5 expressifs à l'aide de structures paramétrées, imbriquées et taguées.
- Distinguer stubs, mocks, fakes et spies, et utiliser Mockito sans sur-spécifier le comportement.
- Tester l'accès aux données et la messagerie face à de vraies dépendances avec Testcontainers.
- Pratiquer le cycle rouge-vert-refactor sur les nouvelles fonctionnalités comme sur les correctifs.
- Concevoir des tests qui vérifient le comportement afin que le refactoring améliore le code sans casser la suite.
- Fixer des objectifs de couverture, de temps d'exécution et de fiabilité applicables par le pipeline.
Public cible
- Développeurs Java responsables des tests livrés avec leur code
- Ingénieurs d'automatisation de tests travaillant dans des bases de code Java
- Responsables techniques relevant le niveau de qualité d'une suite de tests héritée
- Ingénieurs QA passant des vérifications manuelles aux tests au niveau du code
- Équipes mettant en place l'intégration continue pour un produit Java
- Développeurs maintenant des modules peu ou pas couverts par des tests
Programme
Une structure claire pour le parcours d'apprentissage.
Programme
Les points du programme sont regroupés dans un seul bloc au lieu de créer un module par ligne.
Module 1 : Que tester, et pourquoi les suites se dégradent
Séparer les responsabilités des tests unitaires, d'intégration et de bout en bout
Comportement ou implémentation : pourquoi cette différence détermine la durée de vie d'une suite
Nommage et organisation permettant à un test de se lire comme une spécification
L'économie d'une suite lente et le moment où les équipes commencent à la contourner
Module 2 : JUnit 5 en profondeur
Cycle de vie Jupiter, extensions et chemin de migration depuis JUnit 4
Tests paramétrés alimentés par sources de valeurs, CSV, enum et méthodes
Tests imbriqués, noms d'affichage et assumptions pour l'exécution conditionnelle
Assertions groupées, assertions d'exception, timeouts et sélection par tags
Module 3 : Doublures de test et Mockito
Stubs, mocks, fakes et spies : choisir la doublure la plus légère qui fonctionne
Stubbing Mockito, matchers d'arguments et vérification sans sur-spécification
Concevoir pour la testabilité via l'injection, les fonctions pures et de petites coutures
Simuler les frontières que vous possédez, jamais les types que vous ne contrôlez pas
Module 4 : Tests d'intégration avec Testcontainers
Exécuter bases de données, brokers et dépendances comme conteneurs jetables
Tranches de test Spring Boot comparées aux tests de contexte applicatif complet
Données de test déterministes, isolation entre tests et stratégie de nettoyage
Garder des tests d'intégration assez rapides pour tourner à chaque commit
Module 5 : Le développement piloté par les tests en pratique
Appliquer rouge-vert-refactor à une fonctionnalité aux critères d'acceptation réels
Laisser les tests guider la conception sans figer trop tôt l'implémentation
Reproduire un défaut signalé sous forme de test en échec avant de le corriger
Où le TDD est rentable, où il freine la livraison, et comment trancher
Module 6 : Code hérité, couverture et pipeline
Tests de caractérisation figeant le comportement existant avant modification
Trouver les coutures et refactoriser en sécurité pour rendre testable un code qui ne l'est pas
Lire la couverture honnêtement : ce que le chiffre prouve et ne prouve pas
Traitement des tests instables, budgets de temps d'exécution et portes d'intégration continue
Supports fournis
- Manuel de formation, exemples de code commentés et notes de référence
- Environnement de laboratoire et dépôts de démarrage
- Exercices, check-lists et modèles de code réutilisables
- Certificat de participation 4D
- Accompagnement technique après la formation
Options de formation
Les programmes peuvent être organisés en entreprise, en ligne ou dans un format hybride selon le calendrier, la localisation et les objectifs de vos équipes. Lorsqu'un certificat ou un examen externe est inclus, les règles et frais de certification restent soumis aux politiques de l'organisme certificateur, tandis que 4D assure la formation et l'accompagnement à la préparation.
Pourquoi choisir 4D
4D anime cette formation sur une base de code présentant les mêmes problèmes de test que la vôtre : classes héritées sans coutures, mocks qui vérifient beaucoup trop et tests d'intégration trop lents pour tourner à chaque commit. Les participants repartent avec une politique de suite écrite couvrant temps d'exécution, gestion des tests instables et portes de pipeline validées par l'équipe.
Formations liées
Fondamentaux de la programmation Python
Une introduction pratique à Python pour les ingénieurs et analystes qui ont besoin de code opérationnel plutôt que d'extraits de tutoriel. Les participants acquièrent de l'aisance avec les types, les collections, les fonctions, les fichiers et la gestion des erreurs, puis construisent un programme complet.
View coursePython intermédiaire et pratiques de code propre
Conçue pour les développeurs dont le code Python fonctionne mais résiste au changement. Le programme couvre dataclasses, générateurs, décorateurs, gestionnaires de contexte et annotations de types, puis applique les refactorings qui transforment un module interminable en unités testées contrôlées par black, ruff et mypy.
View courseAutomatisation et scripting Python pour les tâches métier
Destinée aux équipes qui perdent chaque semaine des heures en manipulations de fichiers, de tableurs et de rapports. Les participants automatisent ces tâches avec Python : traitement de fichiers en lot, Excel et CSV, appels d'API REST, alertes par e-mail et tâches planifiées qui signalent clairement toute défaillance.
View course