Un guide du débutant pour JUnit 5

Tutoriels

JUnit

JUnit 5 est un cadre de test logiciel utilisé par les développeurs pour tester unitairement leur code. C’est un cadre basé sur Java qui permet d’écrire et d’exécuter des tests sur la plateforme Java, y compris un rapporteur intégré qui affiche les résultats des tests.

JUnit peut être utilisé pour des tests d’automatisation à deux fins principales :

Tester que le logiciel fonctionne comme prévu
Trouver et signaler les erreurs dans le code et les corriger aussi rapidement que possible

Dans ce blog, nous allons nous concentrer sur et apprendre à propos de la configuration, des réglages et des méthodes de base utilisées dans JUnit 5.

Qu’est-ce que JUnit 5 ?

JUnit 5 est la dernière version du cadre de test JUnit. Il prend en charge Java 8 et les versions plus récentes, s’adapte à différents styles de test et offre une base moderne pour les tests côté développeur sur la JVM.

Le principal avantage de l’utilisation de JUnit est sa modularité, car il contient plusieurs modules qui permettent aux développeurs de tester facilement différents composants du logiciel. Il peut également être utilisé pour tester des classes individuelles de l’application au lieu de l’ensemble de l’application.

Fonctionnalités de JUnit 5

Les éléments suivants sont quelques-unes des fonctionnalités populaires et importantes de JUnit 5 qui le distinguent des autres cadres de test unitaire.

Feature	Description	Annotations/Method
Suites de tests	Les suites de tests sont essentiellement un groupe de tests, tels que Smoke, Sanity, ou un groupe de tests liés à une fonctionnalité particulière. JUnit 5 permet la création de suites de tests qui peuvent être exécutées ensemble.	Pour utiliser les Suites de tests, nous devons ajouter une dépendance Suite de la plateforme JUnit et utiliser les annotations suivantes. `@SelectPackages`, `@SelectClasses`, `@Suite`
Assertions	Les assertions sont utilisées pour vérifier le comportement attendu du logiciel. JUnit 5 fournit des méthodes d’assertion intégrées qui peuvent aider à effectuer facilement les assertions.	Il existe plusieurs méthodes d’assertion disponibles dans la classe `import org.junit.jupiter.api.Assertions;`. Certaines des méthodes sont listées ci-dessous : `assertTrue()`, `assertFalse()`, `assertEquals()`, `assertAll()`, `assertNotEquals()`
Ordre d’exécution des tests	Personnalise l’ordre d’exécution des tests. Cela permet au développeur de prendre le contrôle de l’exécution des tests et d’exécuter les tests dans un ordre spécifique selon les besoins.	`@TestMethodOrder`, `@Order`, `@TestClassOrder`
Test des exceptions	Effectue un test des exceptions qui vérifie que l’exception requise est levée dans le test.	La méthode suivante de la `import org.junit.jupiter.api.Assertions;` classe est utilisée : `assertThrows()`
Dépendances de test	Les dépendances de test permettent de tester de manière séquentielle en fournissant la possibilité aux méthodes de test de dépendre les unes des autres. Cela signifie que la méthode de test suivante, qui dépend de la méthode de test précédente, ne sera pas exécutée à moins que la précédente ne réussisse. C’est une fonctionnalité utile lors de l’écriture de tests d’intégration.	@TestInstance
Désactiver les tests	Désactive les tests ou les classes de test.	@Disabled
Délais d’attente	Échoue un test si son temps d’exécution dépasse une durée spécifiée.	@Timeout
Rapports	Fournit un rapporteur intégré pour analyser les résultats des tests et affiche des informations détaillées. Génère un fichier `.html` avec les résultats d’exécution des tests.	N/A

JUnit 4 vs. JUnit 5

Avec la sortie de la dernière version de JUnit, c’est-à-dire JUnit 5, plusieurs changements et nouvelles fonctionnalités ont été ajoutés au framework. Les différences entre les deux versions sont listées dans le tableau ci-dessous :

criteria	JUNIT4	JUNIT5
Architecture	Tout était regroupé dans un seul fichier JAR.	Divisé en 3 sous-projets : – Plateforme JUnit – JUnit Jupiter – JUnit Vintage
Exigence de version JDK	Requiert Java 5 ou ultérieur	Requiert Java 8 ou ultérieur
Intégration de tiers	Aucun support d’intégration de tiers pour les plugins et les IDE	Sous-projet dédié (Plateforme JUnit) pour les intégrations de tiers
Prise en charge des tests imbriqués	Aucune annotation fournie pour écrire des tests imbriqués	Fournit l’annotation `@Nested` pour écrire des tests imbriqués
Prise en charge de l’enregistrement des extensions personnalisées	Aucune prise en charge des extensions personnalisées	Fournit l’annotation `@ExtendWith` pour enregistrer des extensions personnalisées
Modifications apportées aux annotations couramment utilisées	– `@BeforeClass` – `@AfterClass` – `@Before` – `@After` – `@Ignore`	– `@BeforeAll` – `@AfterAll` – `@BeforeEach` – `@AfterEach` – `@Disabled`
Modifications d’annotations pour le balisage et le filtrage	L’annotation `@Category` est utilisée	L’annotation `@Tag` est utilisée
Suites de tests	Les annotations `@RunWith` et `@Suite` étaient utilisées	Les annotations `@Suite`, `@SelectPackages` et `@SelectClasses` sont utilisées

Démarrer avec JUnit 5

Dans cette section, nous allons apprendre comment écrire des cas de test JUnit 5 en utilisant l’IDE IntelliJ. Comme il est déjà livré avec JUnit 5, nous n’avons pas besoin d’effectuer une installation supplémentaire pour l’utiliser.

Nous devons créer un nouveau projet Maven, ajouter les dépendances JUnit 5 et commencer à écrire les tests immédiatement.

Ajout des dépendances JUnit dans le projet Maven

Les dépendances JUnit 5 suivantes doivent être ajoutées dans le fichier pom.xml:

Moteur JUnit Jupiter
API JUnit Jupiter
Suite de la Plateforme JUnit (Agrégateur)
Paramètres JUnit Jupiter

XML

<dependency>

    <groupId>org.junit.jupiter</groupId>

    <artifactId>junit-jupiter-engine</artifactId>

    <version>5.11.4</version>

    <scope>test</scope>

</dependency>

<dependency>

    <groupId>org.junit.jupiter</groupId>

    <artifactId>junit-jupiter-api</artifactId>

    <version>5.11.4</version>

    <scope>test</scope>

</dependency>

<dependency>

    <groupId>org.junit.platform</groupId>

    <artifactId>junit-platform-suite</artifactId>

    <version>1.11.4</version>

    <scope>test</scope>

</dependency>

<dependency>

    <groupId>org.junit.jupiter</groupId>

    <artifactId>junit-jupiter-params</artifactId>

    <version>5.11.4</version>

    <scope>test</scope>

</dependency>

Voici le fichier pom.xml complet

XML

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

​

    <groupId>io.github.mfaisalkhatri</groupId>

    <artifactId>junit-basic</artifactId>

    <version>1.0-SNAPSHOT</version>

    <packaging>jar</packaging>

​

    <name>junit-basic</name>

    <url>http://maven.apache.org</url>

​

    <properties>

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

    </properties>

​

    <dependencies>

        <dependency>

            <groupId>org.junit.jupiter</groupId>

            <artifactId>junit-jupiter-engine</artifactId>

            <version>5.11.4</version>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.junit.jupiter</groupId>

            <artifactId>junit-jupiter-api</artifactId>

            <version>5.11.4</version>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.junit.platform</groupId>

            <artifactId>junit-platform-suite</artifactId>

            <version>1.11.4</version>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.junit.jupiter</groupId>

            <artifactId>junit-jupiter-params</artifactId>

            <version>5.11.4</version>

            <scope>test</scope>

        </dependency>

    </dependencies>

</project>

Après avoir ajouté les dépendances, nous sommes prêts à écrire le test. Mais avant de passer à l’écriture des tests en utilisant JUnit 5, comprenons d’abord les annotations de base qui pourraient nous aider à configurer efficacement la suite de tests et exécuter les tests selon nos besoins.

Annotations de base utilisées dans JUnit 5

Voici les annotations de base les plus populaires utilisées par les développeurs lors de l’écriture des tests en utilisant JUnit 5.

@BeforeAll Annotation

L’annotation @BeforeAll indique que la méthode annotée doit être exécutée avant toute méthode @Test, @RepeatedTest, @ParameterizedTest ou @TestFactory dans la classe actuelle. Elle doit être une méthode statique dans la classe de test.

@BeforeAll sert de remplacement à l’annotation @BeforeClass utilisée dans JUnit 4.x

Syntaxe:

Java

public class BasicTest {

​

   @BeforeAll

   public static void beforeAllTest() {

​

       System.out.println("Before All method called!!");

   }

​

//..

}

Annotation `@BeforeEach`

L’annotation @BeforeEach indique que la méthode annotée doit être exécutée avant chaque invocation des méthodes @Test, @RepeatedTest, @ParameterizedTest ou @TestFactory dans la classe actuelle.

Elle fait partie des méthodes du cycle de vie du test et remplace l’annotation @Before utilisée dans JUnit 4.

Syntaxe:

Java

public class BasicTest {

​

   @BeforeEach

   public void beforeEachTest() {

       System.out.println("Before Each method called!!");

   }

//...

}

Annotation `@AfterAll`

L’annotation @AfterAll indique que la méthode annotée doit être appelée après que tous les tests de la classe actuelle ont été exécutés. Elle doit être une méthode statique et est utilisée comme méthode de nettoyage dans la classe de test.

L’annotation @AfterAll est le remplacement de l’annotation @AfterClass dans JUnit 4.

Syntaxe:

Java

public class BasicTest {

​

//...

​

@AfterAll

public static void afterAllMethod() {

   System.out.println("After All method called!!");

   }

}

Annotation `@AfterEach`

L’annotation @AfterEach indique que la méthode annotée doit être exécutée après chaque méthode @Test, @RepeatedTest, @ParameterizedTest ou @TestFactory dans la classe actuelle.

Il sert de remplacement à JUnit 5 pour l’annotation @After utilisée dans JUnit 4.

Syntaxe :

Java

public class BasicTest {

​

//...

​

@AfterEach

public void afterEachMethod() {

   System.out.println("After Each method called!!");

   }

}

Annotation @Test

L’annotation @Test indique que la méthode annotée est une méthode de test. La méthode de test ne doit pas être une méthode privée ou statique et ne doit pas retourner de valeur.

Syntaxe :

Java

public class BasicTest {

​

//.. 

@Test

public void testMethod() {
   System.out.println("Test Method Called!!");
  }
}

Annotation @DisplayName

L’annotation @DisplayName est utilisée pour spécifier un nom personnalisé pour la classe de test ou la méthode annotée. Ces noms personnalisés peuvent inclure des espaces, des caractères spéciaux, et même des emojis et sont généralement utilisés dans les rapports de test générés par les IDE et les outils de construction.

Syntaxe :

Java

@DisplayName("Demo Test class")
public class BasicTest {
​
//...
​
@DisplayName("This is a demo test")
@Test
public void testMethod() {
   System.out.println("Test Method Called!!");
   }
}

Annotation @Disabled

L’annotation @Disabled dans JUnit 5 est utilisée pour exclure la méthode de test ou la classe de test de la suite de tests pour exécution.

Lorsqu’elle est appliquée à une classe de test, toutes les méthodes à l’intérieur de la classe de test sont automatiquement considérées comme désactivées. Cette annotation a un paramètre optionnel qui permet de spécifier la raison pour laquelle le test est désactivé.

Syntaxe :

Java

public class BasicTest {
​
@Disabled("Test method disabled")
public void testMethod() {
   System.out.println("Test Method Called!!");
 }
//...
}

Comment écrire des cas de test automatisés en utilisant JUnit 5

Il est temps de passer au code et de se salir les mains avec JUnit 5. Nous allons créer une nouvelle classe Java, BasicTest.

Java

public class BasicTest {
//..
}

Toutes les annotations de base que nous avons discutées seront couvertes dans le cadre de la démonstration.

Ajoutons des méthodes dans la classe BasicTest pour démontrer l’utilisation des annotations @BeforeAll, @BeforeEach, @AfterAll, @AfterEach, @Test, @DisplayName et @Disabled disponibles dans JUnit 5.

Java

@DisplayName("Demo Test class")
public class BasicTest {
​
   @BeforeAll
   public static void beforeAllTest() {
​
       System.out.println("Before All method called!!");
   }
​
   @BeforeEach
   public void beforeEachTest() {
       System.out.println("Before Each method called!!");
   }
​
   @DisplayName("This is a demo test")
   @Test
   public void testMethodOne() {
       System.out.println("Test Method One Called!!");
   }
​
   @Test
   @Disabled("This test is disabled to demo disable annotation")
   public void disabledTest() {
       System.out.println("This is a disabled test!!");
   }
​
   @Test
   public void testMethodTwo() {
       System.out.println("Test Method Two Called!!");
​
   }
​
   @AfterEach
   public void afterEachMethod() {
       System.out.println("After Each method called!!");
   }
​
   @AfterAll
   public static void afterAllMethod() {
       System.out.println("After All method called!!");
   }
}

Parcours du code

L’annotation @DisplayName sur la classe de test affichera le nom du test comme « Classe de test de démonstration » dans les résultats lorsque le test est exécuté.

La méthode beforeAllTest() sera exécutée avant l’exécution de tous les tests et affichera le texte "Méthode Avant Tout Appelée !!". Ensuite, la méthode beforeEachTest() sera exécutée avant chaque test et affichera le texte "Méthode Avant Chaque Appelée !!".

Il y a trois méthodes de test dans cette classe, à savoir, testMethodOne(), testMethodTwo() et disabledTest(). Trois méthodes de test ont l’annotation @Test au-dessus, ce qui indique qu’il s’agit de méthodes de test.

La méthode disabledTest() ne sera pas exécutée car elle a l’annotation @Disabled placée au-dessus.

Après chaque exécution de test est terminée, la méthode afterEachTestMethod() sera exécutée car elle a l’annotation @AfterEach placée au-dessus.

Enfin, après l’exécution de tous les tests, la méthode afterAllMethod() sera exécutée car elle a l’annotation @AfterAll placée au-dessus.

Exécution du test

Les tests peuvent être exécutés en cliquant avec le bouton droit sur la classe de test et en sélectionnant Exécuter ‘‘(« BasicTest » dans notre cas).

Une autre façon est de cliquer sur l’icône Play verte à côté de la déclaration de la classe de test, comme indiqué dans la capture d’écran ci-dessous :

La capture d’écran suivante de l’IDE IntelliJ montre que les tests ont été exécutés avec succès.

Il est visible dans la capture d’écran ci-dessus que le nom d’affichage de la classe de test a été imprimé, ainsi que le test désactivé qui peut également être vu, et la raison du test désactivé est imprimée dans la console.

Tous les méthodes de test, y compris celles de beforetest et aftertest, ont été exécutées avec succès, et les résultats respectifs ont été imprimés dans la console.

Résumé

JUnit 5 est un framework de test puissant utilisé par les développeurs pour effectuer des tests unitaires du code. Il est également utilisé par les ingénieurs en automatisation des tests pour écrire et exécuter des scripts d’automatisation des tests. Il dispose de fonctionnalités riches qui permettent aux développeurs et aux testeurs d’écrire les scripts de test et d’effectuer des tests unitaires du code.

Il fournit également plusieurs méthodes pour effectuer des assertions et des vérifications qui sont utiles lors de l’écriture de tests automatisés. En plus d’écrire et d’exécuter les scripts de test, il fournit également un rapport de test qui peut être utilisé pour présenter les résultats de l’exécution des tests aux parties prenantes afin de présenter la couverture des tests.

Bon test !

Source:
https://dzone.com/articles/beginners-guide-to-junit-5

Qu’est-ce que JUnit 5 ?

Fonctionnalités de JUnit 5

JUnit 4 vs. JUnit 5

Démarrer avec JUnit 5

Ajout des dépendances JUnit dans le projet Maven

Annotations de base utilisées dans JUnit 5

@BeforeAll Annotation

Annotation @BeforeEach

Annotation @AfterAll

Annotation @AfterEach

Annotation @Test

Annotation @DisplayName

Annotation @Disabled

Comment écrire des cas de test automatisés en utilisant JUnit 5

Parcours du code

Exécution du test

Résumé

Annotation `@BeforeEach`

Annotation `@AfterAll`

Annotation `@AfterEach`