A ordem dos testes no JUnit

1. Visão geral

Por padrão,JUnit runs tests using a deterministic, but unpredictable order (MethodSorters.DEFAULT).

Na maioria dos casos, esse comportamento é perfeitamente normal e aceitável; mas há casos em que precisamos impor um pedido específico.

2. Pedido de teste no JUnit 5

Na JUnit 5,we can use @TestMethodOrder to control the execution order of tests.

Podemos usar nosso próprioMethodOrderer, como veremos mais tarde, ou podemos selecionar um dos três ordenadores integrados:

@Order Anotação
PedidoAlphanumeric
Ordem aleatória

2.1. Usando a anotação@Order

Podemos usar a anotação@Order para fazer com que os testes sejam executados em uma ordem específica.

No exemplo a seguir, os métodos serão executados nesta ordem -firstTest(), depoissecondTest() e, finalmente,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. Usando o pedidoAlphanumeric

Também podemos executar testes com base em seus nomes em ordem alfanumérica:

@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");
    }
}

Observe que a ordem alfanumérica faz distinção entre maiúsculas e minúsculas; portanto, os caracteres maiúsculos vêm primeiro e os minúsculos.

Os testes serão executados nesta ordem:myATest(),myBTest()e finalmentemyaTest().

2.3. Usando um pedido personalizado

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

Em nossoCustomOrder, vamos ordenar os testes com base em seus nomes em uma ordem alfanumérica que não diferencia maiúsculas de minúsculas:

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()));
    }
}

Então, usaremosCustomOrder para executar os mesmos testes do nosso exemplo anterior nesta ordem -myATest(),myaTest() e, finalmente,myBTest():

@TestMethodOrder(CustomOrder.class)
public class CustomOrderUnitTest {

    // ...

    @AfterAll
    public static void assertOutput() {
        assertEquals(output.toString(), "AaB");
    }
}

3. Ordem de teste na JUnit 4

Se você ainda usa o JUnit 4, as APIs para solicitar testes são um pouco diferentes.

Vamos examinar as opções para conseguir isso nas versões anteriores também.

3.1. UsandoMethodSorters.DEFAULT

Essa estratégia padrão compara métodos de teste usando seus códigos de hash. No caso de uma colisão de hash, a ordem lexicográfica é usada:

@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");
    }
}

Quando executarmos os testes da classe acima, veremos que todos eles foram aprovados, incluindoassertOutput().

3.2. UsandoMethodSorters.JVM

Outra estratégia de pedido éMethodSorters.JVM -this strategy utilizes the natural JVM ordering – which can be different for each run:

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

Cada vez que executamos os testes nesta classe, obtemos um resultado diferente.

3.3. UsandoMethodSorters.NAME_ASCENDING

Por fim, essa estratégia pode ser usada para executar o teste em sua ordem lexicográfica:

@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class NameAscendingOrderOfExecutionTest {
    // same as above

    @AfterClass
    public static void assertOutput() {
        assertEquals(output.toString(), "abc");
    }
}

Da mesma forma, quando executamos os testes nesta classe, vemos que todos eles passam, incluindoassertOutput(), o que confirma a ordem de execução que definimos com a anotação.

4. Conclusão

Neste tutorial rápido, examinamos as maneiras de definir a ordem de execução disponível no JUnit.

E, como sempre, os exemplos usados neste artigo podem ser encontradosover on GitHub.

TOC

A ordem dos testes no JUnit