L'ordre des tests dans JUnit

1. Vue d'ensemble

Par défaut, JUnit exécute les tests en utilisant un ordre déterministe, mais imprévisible ( MethodSorters.DEFAULT ).

Dans la plupart des cas, ce comportement est parfaitement correct et acceptable; mais il y a des cas où nous devons appliquer une commande spécifique.

2. Ordre de test dans JUnit 5

Dans JUnit 5, nous pouvons utiliser @TestMethodOrder pour contrôler l'ordre d'exécution des tests .

Nous pouvons utiliser notre propre MethodOrderer , comme nous le verrons plus tard, ou nous pouvons sélectionner l'un des trois ordonnanceurs intégrés:

  1. Annotation @Order
  2. Ordre alphanumérique
  3. Ordre aléatoire

2.1. Utilisation de l' annotation @Order

Nous pouvons utiliser l' annotation @Order pour forcer les tests à s'exécuter dans un ordre spécifique.

Dans l'exemple suivant, les méthodes s'exécuteront dans cet ordre - firstTest () , puis secondTest () et enfin, thirdTest () :

@TestMethodOrder(OrderAnnotation.class) public class OrderAnnotationUnitTest { private static StringBuilder output = new StringBuilder(""); @Test @Order(1) public void firstTest() { output.append("a"); } @Test @Order(2) public void secondTest() { output.append("b"); } @Test @Order(3) public void thirdTest() { output.append("c"); } @AfterAll public static void assertOutput() { assertEquals(output.toString(), "abc"); } }

2.2. Utilisation de l' ordre alphanumérique

Nous pouvons également exécuter des tests en fonction de leurs noms dans l'ordre alphanumérique:

@TestMethodOrder(Alphanumeric.class) public class AlphanumericOrderUnitTest { private static StringBuilder output = new StringBuilder(""); @Test public void myATest() { output.append("A"); } @Test public void myBTest() { output.append("B"); } @Test public void myaTest() { output.append("a"); } @AfterAll public static void assertOutput() { assertEquals(output.toString(), "ABa"); } }

Notez que l'ordre alphanumérique est sensible à la casse, donc les caractères majuscules viennent en premier, puis les minuscules.

Les tests se dérouleront dans cet ordre: myATest () , myBTest () et enfin myaTest () .

2.3. Utilisation d'une commande personnalisée

Enfin, nous pouvons utiliser notre propre ordre personnalisé en implémentant l' interface MethodOrderer .

Dans notre CustomOrder , nous classerons les tests en fonction de leurs noms dans un ordre alphanumérique insensible à la casse:

public class CustomOrder implements MethodOrderer { @Override public void orderMethods(MethodOrdererContext context) { context.getMethodDescriptors().sort( (MethodDescriptor m1, MethodDescriptor m2)-> m1.getMethod().getName().compareToIgnoreCase(m2.getMethod().getName())); } }

Ensuite, nous utiliserons CustomOrder pour exécuter les mêmes tests de notre exemple précédent dans cet ordre - myATest () , myaTest () et enfin, myBTest () :

@TestMethodOrder(CustomOrder.class) public class CustomOrderUnitTest { // ... @AfterAll public static void assertOutput() { assertEquals(output.toString(), "AaB"); } }

3. Ordre de test dans JUnit 4

Si vous utilisez toujours JUnit 4, les API de commande des tests sont légèrement différentes.

Passons également en revue les options pour y parvenir dans les versions précédentes.

3.1. Utilisation de MethodSorters.DEFAULT

Cette stratégie par défaut compare les méthodes de test à l'aide de leurs hashcodes. En cas de collision de hachage, l'ordre lexicographique est utilisé:

@FixMethodOrder(MethodSorters.DEFAULT) public class DefaultOrderOfExecutionTest { private static StringBuilder output = new StringBuilder(""); @Test public void secondTest() { output.append("b"); } @Test public void thirdTest() { output.append("c"); } @Test public void firstTest() { output.append("a"); } @AfterClass public static void assertOutput() { assertEquals(output.toString(), "cab"); } }

Lorsque nous exécutons les tests dans la classe ci-dessus, nous verrons qu'ils réussissent tous, y compris assertOutput () .

3.2. Utilisation de MethodSorters.JVM

Une autre stratégie de commande est MethodSorters.JVM - cette stratégie utilise la commande JVM naturelle - qui peut être différente pour chaque exécution:

@FixMethodOrder(MethodSorters.JVM) public class JVMOrderOfExecutionTest { // same as above }

Chaque fois que nous exécutons les tests de cette classe, nous obtenons un résultat différent.

3.3. Utilisation de MethodSorters.NAME_ASCENDING

Enfin, cette stratégie peut être utilisée pour exécuter les tests dans leur ordre lexicographique:

@FixMethodOrder(MethodSorters.NAME_ASCENDING) public class NameAscendingOrderOfExecutionTest { // same as above @AfterClass public static void assertOutput() { assertEquals(output.toString(), "abc"); } }

De même, lorsque nous exécutons les tests dans cette classe, nous voyons qu'ils réussissent tous, y compris assertOutput () , qui confirme l'ordre d'exécution que nous avons défini avec l'annotation.

4. Conclusion

Dans ce rapide didacticiel, nous avons décrit les moyens de définir l'ordre d'exécution disponible dans JUnit.

Et, comme toujours, les exemples utilisés dans cet article peuvent être trouvés sur GitHub.