Menu

Ordem de execução de teste JUnit: Ordem dos testes JUnit 4 Vs JUnit 5

  • Principal
  • De Outros
  • Ordem de execução de teste JUnit: Ordem dos testes JUnit 4 Vs JUnit 5

junit test execution order

Experimente Nosso Instrumento Para Eliminar Problemas

como classificar uma matriz de inteiros em java

Este tutorial explica como definir a ordem de execução para casos de teste JUnit. Você aprenderá sobre Anotações e classes para definir a ordem de execução de teste JUnit no JUnit 4 vs JUnit 5:

Aprendemos como criar um conjunto de testes, como adicionar uma categoria ou tag aos casos de teste e como filtrar os testes (excluir ou incluir os casos de teste) com base na categoria ou tag em nosso tutorial anterior.

Além disso, aprendemos que na JUnit 4, temos @Category, @IncludeCategory, e @ExcludeCategory para filtrar os casos de teste enquanto JUnit 5 tem @IncludeTags e @ExcludeTags para fazer o mesmo.

JUnit 5 tem opções de filtragem adicionais usando anotações @IncludePackages, @ExcludePackages, e também anotações para incluir ou excluir classes usando padrões de nome de classe.

=> Verifique aqui para ver os tutoriais de treinamento A-Z do JUnit .

Ordem de execução de teste JUnit

O que você aprenderá:

Ordem de execução de teste JUnit

Neste tutorial, aprenderemos como definir uma ordem para cada caso de teste para que sejam executados na ordem definida. Aprenderemos como solicitar testes no JUnit 4 e também no JUnit 5.

Os métodos de teste não seguem uma ordem específica por padrão.Os casos de teste não precisam necessariamente ser executados na ordem em que foram escritos.

Existem diferentes maneiras ou modos de definir a ordem de execução dos casos de teste. Também nos aprofundaremos em como o JUnit 4 varia na ordem dos casos de teste em comparação ao JUnit 5.

JUnit 4: @FixedMethodOrder, Class MethodSorters

Iniciando JUnit 4.11, temos a anotação @FixMethodOrder e MethodSorters.class apoiar a facilidade de definir uma ordem para a execução de um teste.

O pacote org.junit.runners. * precisa ser importado para incluir a classe MethodSorters . Esta classe decide como os casos de teste precisam ser ordenados. MethodSorters ter três enum valores.

A seguir, são fornecidos os valores enum da classe, juntamente com a finalidade de cada um dos valores:

MethodSorters.DEFAULT Este valor enum classifica a execução do teste em uma ordem específica. No entanto, nunca é previsível em que ordem os casos de teste serão executados.
É por isso que você tem o controle sobre sua decisão sobre qual caso de teste deve ser executado primeiro e quais devem ser executados em seguida.
Eu observei que uma classe com vários métodos classificados com DEFAULT enum quando executada, a ordem permanece a mesma todas as vezes durante a execução do teste.
No entanto, não há como prever ou descobrir como o pedido foi definido.
MethodSorters.JVM A ordem de execução do teste com o JVM enum é como o nome indica é determinada pela JVM.
Nesse caso, toda vez que você executar a classe, os testes serão executados não da mesma forma, mas em ordem aleatória.
Em outras palavras, a ordem dos testes muda durante cada execução.
MethodSorters.NAME_ASCENDING Este enum classifica os métodos de teste na ordem lexicográfica do nome do método. Portanto, você pode ficar tranquilo, pois esta é a maneira mais previsível de ordenar a execução do teste.
Você pode, portanto, decidir de antemão a sequência de testes com base na ordem lexicográfica do nome que você definiu.

A anotação @FixedMethodOrder recebe o parâmetro de entrada de MethodSorters com seu valor enum. O pacote necessário para a anotação é org.junit.FixedMethodOrder.

Vamos ver como isso é implementado por meio do código.

Implementação de código para MethodSorters.DEFAULT

Vamos criar um arquivo de classe JUnit ‘ Junit4TestOrder.java ' onde vamos usar MethodSorters.DEFAULT

O código para 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 '); } }

Executamos a classe três vezes e vemos a mesma ordem de testes sendo executados conforme abaixo, entretanto, os casos de teste podem ou não ser executados na ordem classificada.

A janela do console mostrou os resultados abaixo - a ordem de execução do teste é TestCase_3, TestCase_1 e TestCase_2 e a ordem não muda com o número de execuções.

janela de console 1

Implementação de código para MethodSorters. JVM

Vamos agora atualizar ‘Junit4TestOrder.java’ para ter MethodSorters.JVM

O snippet de código para Junit4TestOrder.java

@FixMethodOrder(MethodSorters . JVM ) public class JUnit4TestOrder {

Executamos a classe duas vezes e a ordem de execução dos testes muda a cada execução.

A janela do console para o primeiro a execução é conforme mostrado abaixo:

janela de console PRIMEIRA execução

A janela do console para o segundo a execução é conforme mostrado abaixo:

segunda execução da janela do console

Observe atentamente a mudança na ordem em que os testes são executados em ambas as execuções. A ordem dos testes nas duas execuções foi diferente.

Implementação de código para MethodSorters.NAME_ASCENDING

Vamos agora atualizar ‘Junit4TestOrder.java’ para ter MethodSorters.NAME_ASCENDING

O snippet de código para Junit4TestOrder.java

@FixMethodOrder(MethodSorters.NAME_ASCENDING) public class JUnit4TestOrder {

Executamos a classe duas vezes, a ordem dos testes executados permanece a mesma e é executada pela ordem crescente do nome do método.

A janela do console mostra o resultado dos testes executados na ordem TestCase_1, TestCase_2 e TestCase_3.

Resultado dos testes

JUnit 5: @TestMethodOrder, @Order, Interface MethodOrderer

Para controlar a ordem de execução dos testes, as entidades abaixo ajudam a fazer o mesmo:

  1. A anotação @TestMethodOrder
  2. A anotação @Order
  3. As classes que pertencem às interfaces MethodOrderer

As classes incorporadas do MethodOrderer e seus detalhes são os seguintes:

Classe incorporada de MethodOrdererDo pacoteDetalhes
Alfanumérico org.junit.jupiter.api.MethodOrderer.AlphanumericClassifica métodos de teste alfanumericamente com base em seus nomes
OrderAnnotation org.junit.jupiter.api.MethodOrderer.OrderAnnotationClassifica métodos de teste numericamente com base nos valores passados ​​para a anotação @Order
Aleatória org.junit.jupiter.api.MethodOrderer.RandomClassifica métodos de teste aleatoriamente, assim como no caso MethodSorters.JVM em JUnit 4

Vejamos agora a demonstração de cada uma dessas estratégias de pedido:

Implementação de código para Alphanumeric.class

Vamos criar um arquivo de classe JUnit 5 denominado JUnit5TestOrder.java igual a JUnit4TestOrder.java e usar a anotação com Alphanumeric.class para ordenar os testes alfanumericamente.

O código para 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 '); } }

Executamos a classe três vezes e ainda vemos a mesma ordem de testes sendo executados na ordem de classificação alfanumérica do nome do método de teste.

Pós-execução do arquivo de classe, a ordem de execução do teste:

  1. Caso de teste_1,
  2. Caso de teste_2 e
  3. Testcase_3

Nota: A estratégia de classificação alfanumérica é sensível a maiúsculas então, no caso de termos outro caso de teste com o nome testcase_1.

A ordem de execução seria:

  1. Caso de teste_1,
  2. Caso de teste_2,
  3. Testcase_3,
  4. testcase_1.

Portanto, as maiúsculas têm prioridade sobre os nomes dos métodos em minúsculas.

Implementação de código para Random.class

Agora vamos atualizar a classe JUnit 5 JUnit5TestOrder.java para usar a anotação com Random.class

O snippet de código para Junit5TestOrder.java

@TestMethodOrder (Random.class) public class JUnit5TestOrder {

Executamos a classe duas vezes e vimos que todas as vezes, executamos a classe, a ordem de execução do teste era ordenada aleatoriamente.

Pós-execução do arquivo de classe para o primeira vez , a ordem de execução do teste foi:

  1. Caso de teste_2,
  2. Caso de Teste_1
  3. Testcase_3

A ordem de execução quando executado para o segundo tempo mostrado:

  1. Caso de teste_2,
  2. Testcase_3
  3. Caso de Teste_1 .

Implementação de código para OrderAnnotation.class

Agora vamos atualizar a classe JUnit 5 JUnit5TestOrder.java para usar a anotação com OrderAnnotation.class. A anotação @Ordem também desempenhará um papel importante na definição de prioridade dos métodos de teste aqui.

O snippet de código para 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 '); } }

Portanto, nesta estratégia de configurar a ordem de execução do teste, a anotação @Order impõe que os métodos de teste sejam executados de acordo com o valor do pedido sendo definido para isso.

Quanto menor for o valor de @Order para um método de teste, maior será sua prioridade durante a execução.

Após a execução, a ordem dos testes foi executada da seguinte forma:

  1. Testcase_3,
  2. Caso de Teste_1
  3. Caso de teste_2 porque a ordem definida para os casos de teste é 1,2 e 3, respectivamente.

É por isso que não importa se os casos de teste são escritos em ordem. Além disso, não importa se os nomes dos métodos estão ou não em ordem alfanumérica.

JUnit 5: Criação de pedido personalizado

Além disso, as classes Order integradas, JUnit 5 também oferece suporte a pedidos personalizados implementando a interface MethodOrderer . A partir do JUnit 5 versão 5.4, a classificação personalizada é compatível.

Vamos ver rapidamente como criar e implementar um pedido personalizado por comprimento do método.

Passo 1: Criou uma classe de pedido personalizada implementando a interface MethodOrderer e nomeou a classe como TestCaseLengthOrder

O código para 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())); } }

Explicação do código TestCaseLengthOrder:

  1. Uma classe de pedido personalizado é criada implementando a interface MethodOrderer.
  2. void orderMethods (MethodOrderContext context) {} método que é o método embutido implementado a partir da Interface MethodOrderer. Aqui é onde você define a implementação da lógica de pedido de teste.
  3. MethodDescriptor é uma interface que contém detalhes sobre um método:
    • O método MethodDescriptor.getMethod () obtém o nome do método para este descritor.
    • O nome do método é convertido em String com o método getName (), ou seja, MethodDescriptor.getMethod (). GetName () e
    • O método length () busca o comprimento do método (assim como string.length () busca o comprimento de um valor de string).
    • Todos os nomes de métodos são comparados entre si usando o método compareTo ().
  4. O método getMethodDescriptors () obtém a lista de todos os descritores de método em uma classe.
  5. O método sort () classifica os objetos MethodDescriptor.

Agora que entendemos cada API de MethodOrderer claramente, esperamos que seja fácil interpretar o código acima.

Passo 2 : Use a classe de pedido personalizado como você usa qualquer pedido embutido na classe de teste.

Como uma entrada para a anotação @TestMethodOrder.

O código para 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(){ }

Etapa 3:

Pós-execução de JUnit_CustomOrder.class , a ordem de execução do teste é a seguinte com base na ordem crescente do comprimento do nome dos casos de teste:

  1. adicionar(),
  2. subt (),
  3. divide ()
  4. multiplicar()

Conclusão

Para concluir este tutorial sobre a ordem de execução de teste JUnit.

  1. Aprendemos como definir a ordem dos casos de teste usando anotações específicas, bem como classes específicas.
  2. Também aprendemos várias maneiras de solicitar testes para JUnit 4 e JUnit 5, com base nas quais as estratégias de pedido mudaram.
  3. Além disso, aprendemos como no JUnit 5, também podemos criar uma classe de classificação personalizada e usá-la para ordenar os casos de teste durante sua execução.

=> Dê uma olhada no guia para iniciantes JUnit aqui.

Leitura recomendada

^