junit test execution order
Ce didacticiel explique comment définir l'ordre d'exécution des cas de test JUnit. Vous en apprendrez plus sur les annotations et les classes pour définir l'ordre d'exécution des tests JUnit dans JUnit 4 vs JUnit 5:
Nous avons appris comment créer une suite de tests, comment ajouter une catégorie ou une balise aux cas de test et comment filtrer les tests (exclure ou inclure les cas de test) en fonction de la catégorie ou de la balise de notre didacticiel précédent.
De plus, nous avons appris que dans JUnit 4, nous avons @Category, @IncludeCategory, et @ExcludeCategory pour filtrer les cas de test alors que JUnit 5 a @IncludeTags et @ExcludeTags Faire la même chose.
JUnit 5 a des options de filtrage supplémentaires utilisant des annotations @IncludePackages, @ExcludePackages, et aussi des annotations pour inclure ou exclure des classes à l'aide de modèles de nom de classe.
=> Vérifiez ici pour voir de A à Z des didacticiels de formation JUnit .
Ce que vous apprendrez:
Ordre d'exécution du test JUnit
Dans ce didacticiel, nous allons apprendre à définir un ordre pour chaque cas de test afin qu'ils s'exécutent dans l'ordre défini. Nous apprendrons à commander des tests dans JUnit 4 ainsi que dans JUnit 5.
Les méthodes de test ne suivent pas un ordre spécifique par défaut.Les cas de test ne doivent pas nécessairement s'exécuter dans l'ordre dans lequel ils ont été écrits.
Il existe différentes manières ou modes de définir l'ordre d'exécution des cas de test. Nous allons également approfondir la façon dont JUnit 4 varie dans l'ordre des cas de test par rapport à JUnit 5.
JUnit 4: @FixedMethodOrder, Class MethodSorters
À partir de JUnit 4.11, nous avons l'annotation @FixMethodOrder et MethodSorters.class prendre en charge la possibilité de définir un ordre pour l'exécution d'un test.
Le paquet org.junit.runners. * doit être importé pour inclure la classe MéthodeSorters . Cette classe décide de la manière dont les cas de test doivent être classés. MéthodeSorters ont Trois énumération valeurs.
Vous trouverez ci-dessous les valeurs d'énumération de la classe ainsi que le but de chacune de ces valeurs:
| MethodSorters.DEFAULT | Cette valeur d'énumération trie l'exécution du test dans un ordre spécifique. Cependant, il n'est jamais prévisible dans quel ordre il pourrait exécuter les cas de test. |
| C'est pourquoi, vous avez le contrôle de votre décision sur le cas de test à exécuter en premier et ceux qui doivent suivre ensuite. | |
| J'ai observé qu'une classe avec plusieurs méthodes triées avec une énumération DEFAULT lors de l'exécution, l'ordre reste le même à chaque fois pendant l'exécution du test. | |
| Cependant, je n'ai aucun moyen de prédire ou de comprendre la façon dont l'ordre a été défini. | |
| MethodSorters.JVM | L'ordre d'exécution des tests avec l'énumération JVM est, comme son nom l'indique, déterminé par la JVM. |
| Dans ce cas, chaque fois que vous exécutez la classe, les tests ne seront pas exécutés dans le même ordre mais dans un ordre aléatoire. | |
| En d'autres termes, l'ordre des tests change à chaque exécution. | |
| MethodSorters.NAME_ASCENDING | Cette énumération trie les méthodes de test dans l'ordre lexicographique du nom de la méthode. Par conséquent, vous pouvez être rassuré car il s'agit de la manière la plus prévisible d'ordonner l'exécution de vos tests. |
| Vous pouvez donc décider à l'avance de la séquence de tests en fonction de l'ordre lexicographique de son nom que vous définissez. |
L'annotation @FixedMethodOrder prend le paramètre d'entrée de MéthodeSorters avec sa valeur enum. Le package nécessaire pour l'annotation est org.junit.FixedMethodOrder.
Voyons comment cela est implémenté via le code.
Implémentation de code pour MethodSorters.DEFAULT
Créons un fichier de classe JUnit ' Junit4TestOrder.java ' où nous allons utiliser MethodSorters.DEFAULT
Le code pour Junit4TestOrder.java
@FixMethodOrder(MethodSorters.DEFAULT) public class JUnit4TestOrder { @Test public void Testcase_3() { System.out.println('Testcase_3 executes'); } @Test public void Testcase_1() { System.out.println('Testcase_1 executes'); } @Test public void Testcase_2() { System.out.println('Testcase_2 executes '); } } Nous exécutons la classe trois fois et voyons le même ordre de tests en cours d'exécution que ci-dessous, cependant, les cas de test peuvent ou non être exécutés dans l'ordre trié.
La fenêtre de la console a montré les résultats comme ci-dessous - l'ordre d'exécution du test est TestCase_3, TestCase_1 et TestCase_2 et l'ordre ne change pas avec le nombre d'exécutions.
Implémentation de code pour MethodSorters. JVM
Nous allons maintenant mettre à jour 'Junit4TestOrder.java' pour avoir MethodSorters.JVM
L'extrait de code pour Junit4TestOrder.java
@FixMethodOrder(MethodSorters . JVM ) public class JUnit4TestOrder {Nous exécutons la classe deux fois et l'ordre d'exécution des tests change à chaque exécution.
La fenêtre de la console pour le première run est comme indiqué ci-dessous:
La fenêtre de la console pour le deuxième run est comme indiqué ci-dessous:
Observez attentivement le changement dans l'ordre dans lequel les tests sont exécutés dans les deux exécutions. L'ordre des tests dans les deux séries diffère.
Implémentation du code pour MethodSorters.NAME_ASCENDING
Nous allons maintenant mettre à jour 'Junit4TestOrder.java' pour avoir MethodSorters.NAME_ASCENDING
L'extrait de code pour Junit4TestOrder.java
@FixMethodOrder(MethodSorters.NAME_ASCENDING) public class JUnit4TestOrder { Nous exécutons la classe deux fois, l'ordre des tests exécutés reste le même et est exécuté selon l'ordre croissant du nom de la méthode.
La fenêtre de la console affiche le résultat des tests exécutés dans l'ordre TestCase_1, TestCase_2 et TestCase_3.
JUnit 5: @TestMethodOrder, @Order, Interface MethodOrderer
Pour contrôler l'ordre d'exécution des tests, les entités ci-dessous aident à faire de même:
- L'annotation @TestMethodOrder
- L'annotation @Order
- Les classes qui appartiennent aux interfaces MethodOrderer
Les classes MethodOrderer intégrées et leurs détails sont les suivants:
| Classe intégrée de MethodOrderer | Depuis le paquet | Des détails |
|---|---|---|
| Alphanumérique | org.junit.jupiter.api.MethodOrderer.Alphanumeric | Trie les méthodes de test de manière alphanumérique en fonction de leurs noms |
| CommandeAnnotation | org.junit.jupiter.api.MethodOrderer.OrderAnnotation | Trie les méthodes de test numériquement en fonction des valeurs transmises à l'annotation @Order |
| Aléatoire | org.junit.jupiter.api.MethodOrderer.Random | Trie les méthodes de test de manière aléatoire, comme dans le cas MethodSorters.JVM dans JUnit 4 |
Examinons maintenant la démonstration de chacune de ces stratégies de commande:
Implémentation de code pour Alphanumeric.class
Créons un fichier de classe JUnit 5 nommé JUnit5TestOrder.java identique à JUnit4TestOrder.java et utilisons l'annotation avec Alphanumeric.class pour classer les tests de manière alphanumérique.
Le code de Junit5TestOrder.java
@TestMethodOrder(Alphanumeric.class) public class JUnit5TestOrder { @Test public void Testcase_3() { System.out.println('Testcase_3 executes'); } @Test public void Testcase_1() { System.out.println('Testcase_1 executes'); } @Test public void Testcase_2() { System.out.println('Testcase_2 executes '); } } Nous avons exécuté la classe trois fois et voyons toujours le même ordre de tests en cours d'exécution dans l'ordre alphanumérique trié du nom de la méthode de test.
Après exécution du fichier de classe, l'ordre d'exécution du test:
- Testcase_1,
- Testcase_2 et
- Testcase_3
Noter: La stratégie de tri alphanumérique est sensible à la casse donc au cas où nous aurions un autre cas de test avec le nom testcase_1.
L'ordre d'exécution serait:
- Testcase_1,
- Testcase_2,
- Testcase_3,
- testcase_1.
Par conséquent, les majuscules ont priorité sur les noms de méthodes minuscules.
Implémentation de code pour Random.class
Nous allons maintenant mettre à jour la classe JUnit 5 JUnit5TestOrder.java pour utiliser l'annotation avec Random.class
L'extrait de code pour Junit5TestOrder.java
@TestMethodOrder (Random.class) public class JUnit5TestOrder {Nous avons exécuté la classe deux fois et nous avons vu qu'à chaque fois, nous avons exécuté la classe, l'ordre d'exécution du test était ordonné au hasard.
Post exécution du fichier de classe pour le première fois , l'ordre d'exécution du test était:
- Testcase_2,
- Testcase_1
- Testcase_3
L'ordre d'exécution lors de l'exécution du deuxième le temps a montré:
- Testcase_2,
- Testcase_3
- Testcase_1 .
Implémentation de code pour OrderAnnotation.class
Nous allons maintenant mettre à jour la classe JUnit 5 JUnit5TestOrder.java pour utiliser l'annotation avec OrderAnnotation.class. L'annotation @Commander jouera également un rôle important dans l'établissement des priorités des méthodes d'essai ici.
L'extrait de code pour Junit5TestOrder.java
@TestMethodOrder(OrderAnnotation.class) public class JUnit5TestOrder { @Test @Order(1) public void Testcase_3() { System.out.println('Testcase_3 executes'); } @Test @Order(2) public void Testcase_1() { System.out.println('Testcase_1 executes'); } @Test @Order(3) public void Testcase_2() { System.out.println('Testcase_2 executes '); } }Ainsi, dans cette stratégie de configuration de l'ordre d'exécution des tests, l'annotation @Order impose aux méthodes de test de s'exécuter selon le valeur de la commande étant prêt pour cela.
Plus la valeur de @Order pour une méthode de test est faible, plus sa priorité lors de l'exécution est élevée.
Après l'exécution, l'ordre des tests s'est déroulé comme suit:
- Testcase_3,
- Testcase_1
- Testcase_2 car l'ordre défini pour les cas de test est respectivement 1, 2 et 3.
C’est pourquoi peu importe que les cas de test soient écrits dans l’ordre. En outre, peu importe si les noms des méthodes sont ou non dans l’ordre alphanumérique.
JUnit 5: Création d'une commande personnalisée
En outre, les classes Order intégrées, JUnit 5 prend également en charge les commandes personnalisées en implémentant l'interface MethodOrderer . À partir de JUnit 5 version 5.4, le tri personnalisé est pris en charge.
Voyons rapidement comment créer et mettre en œuvre un ordre personnalisé par longueur de méthode.
Étape 1: Création d'une classe de commande personnalisée implémentant l'interface MethodOrderer et nommée la classe TestCaseLengthOrder
Le code de TestCaseLengthOrder.java
public class TestCaseLengthOrder implements MethodOrderer { @Override public void orderMethods(MethodOrdererContext context) { MethodDescriptor md1; MethodDescriptor md2; context.getMethodDescriptors().sort((md1, md2)-> md1.getMethod().getName().length().compareTo(md2.getMethod().getName().length())); } }Explication du code TestCaseLengthOrder:
- Une classe de commande personnalisée est créée en implémentant l'interface MethodOrderer.
- void orderMethods (MethodOrderContext context) {} méthode qui est la méthode intégrée implémentée à partir de l'interface MethodOrderer. C'est ici que vous définissez l'implémentation de la logique de commande des tests.
- MethodDescriptor est une interface qui contient des détails sur une méthode:
- La méthode MethodDescriptor.getMethod () obtient le nom de méthode pour ce descripteur.
- Le nom de la méthode est converti en String avec la méthode getName () c'est-à-dire MethodDescriptor.getMethod (). GetName () et
- La méthode length () récupère la longueur de la méthode (tout comme string.length () récupère la longueur d'une valeur de chaîne).
- Tous les noms de méthodes sont comparés les uns aux autres à l'aide de la méthode compareTo ().
- La méthode getMethodDescriptors () obtient la liste de tous les descripteurs de méthode d'une classe.
- La méthode sort () trie les objets MethodDescriptor.
Maintenant que nous avons bien compris chaque API de MethodOrderer, nous espérons qu'il est facile d'interpréter le code ci-dessus.
Étape 2 : Utilisez la classe de commande personnalisée comme vous utilisez n'importe quel ordre intégré dans la classe de test.
En tant qu'entrée de l'annotation @TestMethodOrder.
Le code de JUnit_CustomOrder.java
@TestMethodOrder(TestCaseLengthOrder.class) class JUnit_CustomOrder{ @Test public void subt(){ } @Test public void add(){ } @Test public void multiply(){ } @Test public void divide(){ } Étape 3:
Après l'exécution de JUnit_CustomOrder.class , l’ordre d’exécution des tests est le suivant en fonction de l’ordre croissant de la longueur du nom des cas de test:
- ajouter(),
- subt (),
- diviser ()
- multiplier()
Conclusion
Pour conclure ce tutoriel sur l'ordre d'exécution des tests JUnit.
- Nous avons appris à définir l'ordre des cas de test en utilisant des annotations spécifiques ainsi que des classes spécifiques.
- Nous avons également appris différentes manières de commander des tests pour JUnit 4 et JUnit 5, en fonction desquelles les stratégies de classement ont changé.
- De plus, nous avons appris comment dans JUnit 5, nous pouvions également créer une classe de tri personnalisée et l'utiliser pour ordonner les cas de test lors de leur exécution.
=> Jetez un œil au guide du débutant JUnit ici.
lecture recommandée
- Tests JUnit: Comment écrire des cas de test JUnit avec des exemples
- Liste des annotations JUnit: JUnit 4 vs JUnit 5
- JUnit Ignore Test Case: JUnit 4 @Ignore Vs JUnit 5 @Disabled
- Suite de tests JUnit et cas de tests de filtrage: JUnit 4 vs JUnit 5
- Qu'est-ce qu'un montage de test JUnit: Tutoriel avec des exemples JUnit 4
- Tutoriel JUnit pour les débutants - Qu'est-ce que le test JUnit
- Plusieurs façons d'exécuter des tests JUnit
- Comment exécuter une exécution à grande échelle de tests Appium en parallèle