L’ordre des tests dans JUnit

L'ordre des tests dans JUnit

1. Vue d'ensemble

Par défaut,JUnit runs tests using a deterministic, but unpredictable order (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,we can use @TestMethodOrder to control the execution order of tests.

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

Annotation@Order
OrdreAlphanumeric
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(), puissecondTest() 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'ordreAlphanumeric

Nous pouvons également exécuter des tests basés sur 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. Les caractères majuscules apparaissent ensuite en minuscules.

Les tests s'exécuteront dans cet ordre:myATest(),myBTest() et enfinmyaTest().

2.3. Utilisation d'une commande personnalisée

Enfin,we can use our own custom order by implementing theMethodOrdererinterface.

Dans nosCustomOrder, 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 utiliseronsCustomOrder 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 en revue les options pour y parvenir dans les versions précédentes également.

3.1. Utilisation deMethodSorters.DEFAULT

Cette stratégie par défaut compare les méthodes de test à l'aide de leurs codes de hachage. 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écuterons les tests dans la classe ci-dessus, nous verrons qu'ils réussissent tous, y comprisassertOutput().

3.2. Utilisation deMethodSorters.JVM

Une autre stratégie de classement estMethodSorters.JVM -this strategy utilizes the natural JVM ordering – which can be different for each run:

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

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

3.3. Utilisation deMethodSorters.NAME_ASCENDING

Enfin, cette stratégie peut être utilisée pour exécuter des 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 comprisassertOutput(), ce qui confirme l'ordre d'exécution que nous avons défini avec l'annotation.

4. Conclusion

Dans ce rapide tutoriel, nous avons expliqué comment définir l'ordre d'exécution disponible dans JUnit.

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

TOC

L’ordre des tests dans JUnit