Configurando um ambiente de teste no JUnit

3.1 Anotações @BeforeEach, @AfterEach

Observe que no exemplo anterior, em cada método tivemos que escrever um código para criar um objetocalculadora.

É claro que isso é apenas uma linha, mas se testarmos sistemas reais, muitas vezes teremos uma situação em que precisamos criar e configurar vários objetos, o que pode levar várias dezenas de linhas de código. Exemplo:

//Create an HttpClient object
   HttpClient client = HttpClient.newBuilder()
    	.version(Version.HTTP_1_1)
    	.followRedirects(Redirect.NORMAL)
        .connectTimeout(Duration.ofSeconds(20))
    	.proxy(ProxySelector.of(new InetSocketAddress("proxy.example.com", 80)))
        .authenticator(Authenticator.getDefault())
    	.build();

   //Create an HttpRequest object
  HttpRequest request = HttpRequest.newBuilder()
     .uri(new URI("https://codegym.cc"))
     .headers("Content-Type", " application/octet-stream")
     .POST( HttpRequest.BodyPublishers. ofInputStream ( () -> is; ))
     .build();

   //Call the send() method
   HttpResponse response = client.send(request, BodyHandlers.ofString());
   System.out.println(response.statusCode());
   System.out.println(response.body());

No exemplo acima, criamos e configuramos um objetoHttpClientNamee deseja testar o método send() .

Para que cada vez no método de teste não escreva a criação de um objetoHttpClientName, ele pode ser movido para um método separado e receber uma anotação especial @BeforeEach . Então o Junit chamará este método antes de cada método de teste. Exemplo:

class HttpClientTest {
     	public HttpClient client;

   	@BeforeEach
    	public void init(){
   	   client = HttpClient.newBuilder()
   	        .version(Version.HTTP_1_1)
   	        .followRedirects(Redirect.NORMAL)
   	        .connectTimeout(Duration.ofSeconds(20))
   	        .proxy(ProxySelector.of(new InetSocketAddress("proxy.example.com", 80)))
   	        .authenticator(Authenticator.getDefault())
   	        .build();
    	}

   	@Test
    	public void send200() throws Exception {
     	   //Create an HttpRequest() object
         	HttpRequest request = HttpRequest.newBuilder(new URI("https://codegym.cc")).build();

     	   //Call the send() method
     	   HttpResponse response = client.send(request, BodyHandlers.ofString());
        	assertEquals(200, response.statusCode());
        }

   	@Test
    	public void send404() throws Exception {
     	   //Create an HttpRequest() object
         	HttpRequest request = HttpRequest.newBuilder(new URI("https://codegym.cc/unknown")).build();

     	   //Call the send() method
     	   HttpResponse response = client.send(request, BodyHandlers.ofString());
        	assertEquals(404, response.statusCode());
    	}
}

Você também pode criar um método especial que será chamado sempre após o próximo método de teste e limpar os recursos usados ​​, gravar algo no log etc. Esse método deve ser marcado com a anotação @AfterEach .

Se você tiver 3 métodos de teste test1() , test2() e test3() , a ordem de chamada será:

• antes de cada método
• teste1()
• método AfterEach
• antes de cada método
• teste2()
• método AfterEach
• antes de cada método
• teste3()
• método AfterEach

3.2 Anotações @BeforeAll, @AfterAll

JUnit também permite adicionar um método que será chamado uma vez antes de todos os métodos de teste . Tal método deve ser anotado com @BeforeAll . Ele também possui uma anotação emparelhada @AfterAll . O método marcado com ele será chamado pelo JUnit após todos os métodos de teste.

Vamos escrever um exemplo especial que permite entender melhor como tudo funciona. Vamos tomar como base os testes de nossa calculadora:

class CalculatorTest {
    private Calculator calc = new Calculator();

    @BeforeAll
    public static void init(){
        System.out.println("BeforeAll init() method called");
    }

    @BeforeEach
    public void initEach(){
        System.out.println("BeforeEach initEach() method called");
    }

    @Test
    public void add(){
        System.out.println("Testing Addition");
    }

    @Test
    public void sub() {
        System.out.println("Testing Subtraction");
    }

    @Test
    public void mul(){
        System.out.println("Testing Multiplication");
    }

    @Test
    public void div() {
        System.out.println("Testing Division");
    }
}

Este teste imprimirá o seguinte texto no console:

BeforeAll init() method called
BeforeEach initEach() method called
Testing Addition
 
BeforeEach initEach() method called
Testing Subtraction
 
BeforeEach initEach() method called
Testing Multiplication
 
BeforeEach initEach() method called
Testing Division