Como usar as anotações @Before e @After no JUnit

Quando você está escrevendo um conjunto de testes de unidade, pode haver algumas atividades não relacionadas a testes que você precisa realizar. Essas atividades podem assumir qualquer forma. Talvez você precise se conectar a um banco de dados ou reunir recursos antes de realizar um teste. Após a execução de cada caso de teste, talvez seja necessário liberar alguns recursos.

A execução de qualquer uma dessas atividades não relacionadas a testes fora do escopo de uma classe de teste de unidade pode ser tediosa, se não impossível. A execução bem-sucedida de sua classe de teste pode depender dessas atividades, portanto, o JUnit fornece dois pares de anotações para resolver esse problema.

A anotação @BeforeAll

Uma classe de teste JUnit pode ter um ou mais métodos de teste. A anotação @BeforeAll sinaliza que um método específico deve ser executado antes de todos os métodos de teste em uma classe de teste. O método associado a esta anotação é executado apenas uma vez (no início do teste), independentemente do número de métodos de teste na classe de teste.

Qualquer método que use a anotação @BeforeAll deve seguir algumas estipulações. Esses métodos devem ter um tipo de retorno void, devem ser públicos e não devem ser privados. A anotação @BeforeAll é ideal para estabelecer um conexão com um banco de dados ou criando um novo arquivo. Este artigo usa uma classe de teste de calculadora para mostrar como você pode usar a anotação @BeforeAll.

A classe da calculadora

pacote com.app;
públicoclasseCalculadora{
públicoestáticointadicionar(int número1, int número2){
Retorna num1 + num2;
 }
públicoestáticointsubtrair(int número1, int número2){
Retorna num1 - num2;
 }
públicoestáticointmultiplicar(int número1, int número2){
Retorna num1 * num2;
 }
públicoestáticointdividir(int número1, int número2){
Retorna num1 / num2;
 }
}

A classe de teste Calculator

importarestáticoorg.junit.Júpiter.api.Afirmações.*;
importarorg.junit.Júpiter.api.Antes de tudo;
importarorg.junit.Júpiter.api.Teste;
importarorg.junit.Júpiter.api.Nome em Exibição;
@DisplayName("Classe de teste demonstrando como usar a antes daedepois anotações.")
classeTeste da Calculadora{
@Antes de tudo
públicoestáticovaziopowerOnCalculator(){
 System.out.println("A calculadora está ligada");
 }
@Teste
 @Nome em Exibição("Método de teste que adiciona dois valores inteiros.")
públicovaziotesteAdicionar(){
assertEquals(7, Calculadora.adicionar(3, 4));
 } 
@Teste
 @Nome em Exibição("Método de teste que subtrai um valor inteiro de outro.")
públicovaziotesteSubtrair(){
assertEquals(6, Calculadora.subtrair(9, 3));
 }
@Teste
 @Nome em Exibição("Método de teste que multiplica dois valores inteiros")
públicovaziotesteMultiplique(){
assertEquals(10, Calculadora.multiplicar(5, 2));
 }
@Teste
 @Nome em Exibição("Método de teste que divide um valor inteiro por outro")
públicovaziotestDivide(){
assertEquals(2, Calculadora.dividir(4, 2));
 }
}

Nesta classe, a anotação @BeforeAll funciona com o método powerOnCalculator(), que imprime “A calculadora está ligada” antes de qualquer execução de teste. A execução do teste bem-sucedida imprime o seguinte relatório de teste:

Como você pode ver, o método associado à anotação @BeforeAll não aparece no relatório de teste. No entanto, se houver um erro no método de anotação @BeforeAll, os resultados do relatório de teste indicarão isso com uma falha.

A anotação @BeforeEach

Assim como o método anotado @BeforeAll, o método anotado @BeforeEach não aparecerá no relatório de teste. O método anotado @BeforeEach é executado antes de cada método de teste em uma classe de teste. Portanto, se uma classe de teste contiver dois métodos de teste, a anotação @BeforeEach será executada duas vezes.

importarestáticoorg.junit.Júpiter.api.Afirmações.*;
importarorg.junit.Júpiter.api.Antes de tudo;
importarorg.junit.Júpiter.api.Antes de cada;
importarorg.junit.Júpiter.api.Teste;
@DisplayName("Classe de teste demonstrando como usar a antes daedepois anotações.")
classeTeste da Calculadora{
@Antes de tudo
públicoestáticovaziopowerOnCalculator(){
 System.out.println("A calculadora está ligada");
 }
@BeforeEach
públicovazioclearCalculator(){
 System.out.println("A calculadora está pronta");
 }
@Teste
 @Nome em Exibição("Método de teste que adiciona dois valores inteiros.")
públicovaziotesteAdicionar(){
assertEquals(7, Calculadora.adicionar(3, 4));
 } 
@Teste
 @Nome em Exibição("Método de teste que subtrai um valor inteiro de outro.")
públicovaziotesteSubtrair(){
assertEquals(6, Calculadora.subtrair(9, 3));
 }
@Teste
 @Nome em Exibição("Método de teste que multiplica dois valores inteiros")
públicovaziotesteMultiplique(){
assertEquals(10, Calculadora.multiplicar(5, 2));
 }
@Teste
 @Nome em Exibição("Método de teste que divide um valor inteiro por outro")
públicovaziotestDivide(){
assertEquals(2, Calculadora.dividir(4, 2));
 }
}

Adicionar a anotação @BeforeEach à classe CalculatorTest produz a seguinte saída:

O método associado à anotação @BeforeEach é executado quatro vezes, uma vez antes de cada método de teste. Você deve observar que o método @BeforeEach não é estático, tem um tipo de retorno void e não é privado, pois são estipulações obrigatórias. Também é importante observar que o método associado à anotação @BeforeEach é executado após o método @BeforeAll.

A anotação @AfterAll

Um método com a anotação @AfterAll será executado depois que todos os métodos de teste na classe de teste concluírem sua execução. A anotação @AfterAll é ideal para operações básicas de arquivo, como fechar um arquivo ou desconectar-se de um banco de dados. A anotação @AfterAll é a contrapartida da anotação @BeforeAll. Assim como a anotação @BeforeAll, a anotação @AfterAll deve ser estática, deve retornar void e não ser privada.

@Afinal
públicoestáticovaziopowerOffCalculadora(){
 System.out.println("A calculadora está desligada");
}

Adicionar o método anotado @AfterAll à classe CalculatorTest existente imprime a seguinte saída no console:

Observe que o método powerOffCalculator(), que usa a anotação @AfterAll, é impresso no final da classe de teste, após a execução de todos os métodos de teste.

A anotação @AfterEach

A anotação @AfterEach é a contrapartida da anotação @BeforeEach. Eles têm as mesmas estipulações obrigatórias, que são ligeiramente diferentes das anotações @BeforeAll e @AfterAll. O que distingue a anotação @AfterEach da anotação @BeforeEach (além de seus nomes) é que o método @AfterEach é executado após cada método de teste.

@Após cada
públicovazioreturnResults(){
 System.out.println("Os resultados estão prontos");
}

A execução da classe CalculatorTest imprime a seguinte saída no console:

A saída mostra que o método associado à anotação @AfterEach (returnResults) é impresso quatro vezes. Cada execução do método returnResults() só acontece após a execução de cada teste unitário. Isso é evidente pelo fato de que a saída do método returnResults() aparece após cada saída do método associado à anotação @BeforeEach.

Aprimore seus conjuntos de testes usando anotações

JUnit permite que você lide com processos não relacionados a testes usando as anotações de par antes e depois. Essas quatro anotações pertencem a uma lista de várias outras anotações que agregam valor aos seus testes. Outra das anotações do JUnit é @DisplayName.

Os dois exemplos de código que exibem a classe CalculatorTest completa usam a anotação @DisplayName. A anotação @DisplayName ajuda você a criar nomes mais significativos para suas classes de teste e métodos de teste.