Partie 1 JUnit

Chapitre 1 : Premiers pas avec JUnit

1.1 Prouver que le programme fonctionne correctement
1.2 Partir de zéro
-1.2.1 Comprendre le cadre des tests unitaires
-1.2.2 Ajout de tests unitaires
1.3 Installation de JUnit
1.4 Tests avec JUnit
organiser

Chapitre 2 : Présentation de JUnit Core

2.1 Annotations principales
-2.1.1 @NomAffiché
-2.1.2 @Désactivé
2.2 Test de chevauchement
2.3 Tests avec des balises
2.4 Assertion
2.5 Déclaration familiale
2.6 Injection de dépendances dans JUnit 5
-2.6.1 Résolveur de paramètres d'information de test
-2.6.2 TestReporterParameterRésolveur
-2.6.3 Résolveur de paramètres d'information de répétition
2.7 Tests répétés
2.8 Tests avec paramètres
2.9 Tests dynamiques
2.10 Utilisation des correspondances Hamcrest
organiser

Chapitre 3 Architecture JUnit

3.1 Le concept et l'importance de l'architecture logicielle
-3.1.1 Première histoire : L’annuaire téléphonique
-3.1.2 Deuxième histoire : Le fabricant de baskets
3.2 Architecture JUnit 4
-3.2.1 Architecture monolithique JUnit 4
-3.2.2 JUnit 4 runner
-3.2.3 Règle JUnit 4
-3.2.4 Inconvénients de l'architecture JUnit 4
3.3 Architecture JUnit 5
-3.3.1 Modularité de JUnit 5
-3.3.2 Plateforme JUnit
-3.3.3 JUnit Jupiter
-3.3.4 JUnit Vintage
-3.3.5 Diagramme d'architecture interne de JUnit 5
organiser

Chapitre 4 : Migration de JUnit 4 vers JUnit 5

4.1 Processus de transition de JUnit 4 à JUnit 5
4.2 Dépendances requises pour migrer de JUnit 4 à JUnit 5
4.3 Annotations, classes et méthodes JUnit 5
-4.3.1 Annotations, classes et méthodes utilisées de manière similaire dans JUnit 4 et JUnit 5
-4.3.2 @Category dans JUnit 4 et @Tag dans JUnit 5
-4.3.3 Activation de la fonctionnalité Hamcrest Matcher
-4.3.4 Modèle de règle JUnit 4 et d'extension JUnit 5
-4.3.5 Conversion d'une règle personnalisée en extension
organiser

Chapitre 5 Principes des tests logiciels

5.1 Pourquoi des tests unitaires ?
-5.1.1 Peut augmenter la couverture des tests
-5.1.2 La productivité de l'équipe est améliorée.
-5.1.3 Réduire les efforts de débogage en détectant les régressions à l'avance.
-5.1.4 Vous pouvez refactoriser en toute confiance
- Contribue à la mise en œuvre des fonctionnalités 5.1.5
-5.1.6 Documentez le comportement attendu de votre code.
-5.1.7 Permet de mesurer la couverture du code et diverses métriques.
5.2 Types de tests
-5.2.1 Tests unitaires
-5.2.2 Tests d'intégration
-5.2.3 Tests système
-5.2.4 Test d'acceptation
5.3 Tests en boîte noire vs tests en boîte blanche
-5.3.1 Test de la boîte noire
-5.3.2 Tests en boîte blanche
-5.3.3 Comparaison des avantages et des inconvénients
organiser

Partie 2 : Différentes stratégies de test

Chapitre 6 : Tests de qualité

6.1 Mesure de la couverture des tests
-6.1.1 Qu'est-ce que la couverture de test ?
-6.1.2 Outils de mesure de la couverture de code
6.2 Écrire du code facile à tester
-6.2.1 Une API publique est un contrat entre les fournisseurs d'informations et les utilisateurs d'informations.
-6.2.2 Réduction des dépendances
-6.2.3 Création d'un constructeur simple
-6.2.4 Suivre la loi de Déméter
-6.2.5 Éviter les dépendances cachées et l'état global
-6.2.6 Utilisation de méthodes génériques
-6.2.7 Utilisation de la composition plutôt que de l'héritage
-6.2.8 Utilisez le polymorphisme plutôt que les instructions conditionnelles.
6.3 TDD
-6.3.1 Adaptation au cycle de développement
-6.3.2 Exécution de l'étape TDD 2
6.4 Développement axé sur le comportement
6.5 Réalisation de tests de mutation
6.6 Tests au sein du cycle de développement
organiser

Chapitre 7 : Tests préliminaires à l’aide de stubs

7.1 Examen du stencil
7.2 Test des connexions HTTP avec des stubs
-7.2.1 Que remplacer par des stubs
-7.2.2 Utilisation de Jetty comme serveur Web embarqué
7.3 Création d'une ressource de serveur Web avec un stub
-7.3.1 Configuration du premier stub
-7.3.2 Retour sur le premier test de l'ébauche
7.4 Création d'une connexion HTTP avec un stub
-7.4.1 Création d'un gestionnaire de protocole URL personnalisé
-7.4.2 Création d'un stub HttpURLConnection
-7.4.3 Exécution de tests remplaçant les connexions HTTP par des stubs
organiser

Chapitre 8 : Tests avec des objets factices

8.1 Qu'est-ce qu'un objet factice ?
8.2 Tests unitaires à l'aide d'objets simulés
8.3 Refactorisation à l'aide d'objets simulés
-8.3.1 Exemple de refactorisation
-8.3.2 Considérations relatives à la refactorisation
8.4 Simulation de connexions HTTP
-8.4.1 Définition d'un objet factice
-8.4.2 Test de la méthode d'exemple
-8.4.3 Première tentative : Techniques de refactorisation faciles
-8.4.4 Deuxième tentative : Refactorisation à l’aide de fabriques de classes
8.5 Utilisation d'objets factices comme chevaux de Troie
8.6 Utilisation du framework d'objets factices
-8.6.1 EasyMock
-8.6.2 JMock
-8.6.3 Mockito
organiser

Chapitre 9 : Tests avec des conteneurs

9.1 Limites des tests unitaires généraux
9.2 Tests avec des objets factices
9.3 Utilisation des conteneurs
-9.3.1 Stratégie de mise en œuvre des tests utilisant des conteneurs
-9.3.2 Cadre de test utilisant des conteneurs
9.4 Comparaison des tests sur stub, mock et conteneur
-9.4.1 Évaluation de l'ébauche
-9.4.2 Évaluation d'objets simulés
-9.4.3 Évaluation des tests à l'aide de conteneurs
9.5 Tests avec Arquillian
organiser

Partie 3 : Utilisation de JUnit 5 avec différents outils

Chapitre 10 : Exécution des tests JUnit avec Maven 3

10.1 Création d'un projet Maven
10.2 Utilisation des plugins Maven
-10.2.1 Plugin de compilation Maven
-10.2.2 Plugin Maven Surefire
-10.2.3 Création de rapports JUnit avec Maven
10.3 Tout à la fois
10.4 Tâches Maven
organiser

Chapitre 11 : Exécution des tests JUnit avec Gradle 6

11.1 Présentation de Gradle
11.2 Mise en place d'un projet Gradle
11.3 Utilisation du plugin Gradle
11.4 Création d'un projet Gradle et test avec JUnit 5
11.5 Comparaison de Gradle et Maven
organiser

Chapitre 12 : JUnit 5 et prise en charge de plusieurs environnements de développement intégrés (IDE)

12.1 Utilisation de JUnit 5 avec IntelliJ IDEA
12.2 Utilisation de JUnit 5 avec Eclipse
12.3 Utilisation de JUnit 5 avec NetBeans
12.4 Comparaison de l'utilisation de JUnit 5 dans trois IDE
organiser

Chapitre 13 : JUnit 5 et l’intégration continue

13.1 Tests et intégration continue
13.2 Exploration de Jenkins
13.3 Pratiquer l'intégration continue
13.4 Configuration de Jenkins
13.5 Travailler dans un environnement d'intégration continue
organiser

Partie 4 : Utilisation de JUnit dans les frameworks modernes

Chapitre 14 Modèle d'extension JUnit 5

14.1 Exploration du modèle d'extension JUnit 5
14.2 Création d'une extension JUnit 5
14.3 Implémentation des tests JUnit 5 à l'aide de points d'extension
-14.3.1 Enregistrement des informations passagers dans la base de données
-14.3.2 Vérification de l'unicité du passager
organiser

Chapitre 15 : Tests de la couche de présentation

15.1 Choix d'un cadre de test
15.2 Aperçu de HtmlUnit
-15.2.1 Exemples pratiques d'unité HTML
15.3 Écriture de tests unitaires HTML
-15.3.1 Assertions HTML
-15.3.2 Tests de navigateurs Web spécifiques
-15.3.3 Test de plusieurs navigateurs
-15.3.4 Création d'un test d'interface graphique autonome
-15.3.5 Test des formulaires HTML
-15.3.6 Tests JavaScript
15.4 Un aperçu de Selenium
15.5 Rédaction de tests avec Selenium
-15.5.1 Tests de navigateurs Web spécifiques
-15.5.2 Test de navigation à l'aide d'un navigateur Web
-15.3.3 Tests avec plusieurs navigateurs
-15.5.4 Test de la recherche et de la navigation Google dans plusieurs navigateurs
-15.5.5 Test d'authentification du site Web
15.6 HtmlUnit et Selenium
organiser

Chapitre 16 : Tests des applications Spring

16.1 Exploration du framework Spring
16.2 Analyse de l'injection de dépendances
16.3 Utilisation et test des applications Spring
-16.3.1 Création d'un contexte Spring par programmation
-16.3.2 Utilisation du framework de contexte de test dans Spring
16.4 Utilisation de SpringExtension avec JUnit 5 Jupiter
16.5 Ajout de nouvelles fonctionnalités et tests avec JUnit 5
organiser

Chapitre 17 : Tests des applications Spring Boot

17.1 Aperçu de Spring Boot
17.2 Création d'un projet avec Spring Initializer
17.3 Migration d'une application Spring vers Spring Boot
17.4 Mise en œuvre d'une configuration de test uniquement dans Spring Boot
17.5 Ajout et test de nouvelles fonctionnalités à une application Spring Boot
organiser

Chapitre 18 : Tester les API REST

18.1 Analyse des applications REST
18.2 Création d'une API RESTful pour gérer une entité unique
18.3 Création d'une API RESTful gérant plusieurs entités
18.4 Tests des API RESTful
organiser

Chapitre 19 : Tests des applications de bases de données

19.1 Inadéquation d'impédance lors des tests unitaires de base de données
-19.1.1 Les tests unitaires doivent être exécutés indépendamment du code.
-19.1.2 Les tests unitaires doivent être faciles à écrire et à exécuter.
-19.1.3 Les tests unitaires doivent s'exécuter rapidement.
19.2 Tests des applications JDBC
19.3 Tests d'applications Spring JDBC
19.4 Tests d'applications Hibernate
19.5 Tests d'applications Spring Hibernate
19.6 Comparaison des tests d'applications de bases de données
organiser

Partie 5 : Méthodologie de développement avec JUnit 5

Chapitre 20 : TDD avec JUnit 5

20.1 Concepts fondamentaux du TDD
20.2 Système de gestion de vol
20.3 Préparation préliminaire au développement d'un système de gestion de vol avec TDD
20.4 Refonte du système de gestion de vol
20.5 Ajout de nouvelles fonctionnalités avec TDD
-20.5.1 Ajout de vols premium
-20.5.2 Ajout d'une fonctionnalité pour empêcher l'ajout de passagers en double
organiser

Chapitre 21 : Conception pilotée par les comportements (BDD) avec JUnit 5

21.1 Examen du BDD
-21.1.1 Ajout de nouvelles fonctionnalités
-21.1.2 De l'analyse des exigences aux critères d'acceptation
-21.1.3 Avantages et défis du BDD
21.2 Mise en pratique du BDD avec Cucumber et JUnit 5
-21.2.1 Vue d'ensemble du concombre
-21.2.2 Migration des fonctionnalités créées avec TDD vers Cucumber
-21.2.3 Ajout de nouvelles fonctionnalités avec Cucumber
21.3 Mise en pratique du BDD avec JBehave et JUnit 5
-21.3.1 Vue d'ensemble de JBehave
-21.3.2 Migration des fonctionnalités créées avec TDD vers JBehave
-21.3.3 Ajout de nouvelles fonctionnalités via JBehave
21.4 Comparaison de Cucumber et JBehave
organiser

Chapitre 22 : Mise en œuvre d’une stratégie de pyramide de tests avec JUnit 5

22.1 Niveaux de test logiciel
22.2 Tests unitaires : Composants de base fonctionnant indépendamment
22.3 Tests d'intégration : collaboration entre les unités
22.4 Tests système : un aperçu du logiciel complet
-22.4.1 Tests avec des dépendances externes simulées
-22.4.2 Tests avec des dépendances externes partiellement implémentées
-22.4.3 Tests avec dépendances externes entièrement implémentées
22.5 Tests d'acceptation : Conformité aux exigences métier
organiser

Annexe A Maven

A.1 Réglage personnalisé
A.2 Gestion des dépendances fortes
A.3 Cycle de vie de la construction Maven
A.4 Architecture à base de modules enfichables
A.5 Modèle objet de projet Maven
A.6 Installation de Maven

Annexe B Gradle

B.1 Installation de Gradle
B.2 Création d'une tâche avec Gradle

Annexe C IDE

C.1 Installation d'IntelliJ IDEA
C.2 Installation d'Eclipse
C.3 Installation de NetBeans

Annexe D Jenkins

Ce que ce livre couvre

• Migration de JUnit 4 vers JUnit 5
Automatisation efficace des tests
ㆍ TDD et BDD
Utilisation d'objets factices pour l'isolation des tests
• Gestion de JUnit 5 avec Maven ou Gradle