Fala, meus consagrados! Beleza?
Os testes unitários são uma peça fundamental no desenvolvimento de software e o JUnit 5 se destaca como uma poderosa e flexível estrutura para criar e executar testes em aplicações Java. Com a versão 5, temos uma série de recursos avançados e melhorias que tornam o processo de teste mais eficiente e abrangente.
JUnit é uma ferramenta para projetos Java de automatização de testes unitários e de regressão. Ele facilita a criação e manutenção do código para a automação de testes com apresentação dos resultados:
- Se todos os testes forem executados com sucesso, é apresentada uma barra verde ao desenvolvedor;
- Caso contrário, tem-se uma barra vermelha com uma indicação de onde ocorreu a falha do teste.
Essa ferramenta pode ser usada para verificar se cada método de uma classe funciona da forma esperada, exibindo possíveis erros e falhas e podendo ser utilizado tanto para a execução de baterias de testes como para extensão.
O JUnit 5 é composto por módulos distintos, como o JUnit Platform, JUnit Jupiter e JUnit Vintage:
- JUnit Platform atua como a base para a execução dos testes, oferecendo suporte para diferentes ambientes de execução;
- JUnit Jupiter traz novas funcionalidades, como anotações poderosas e recursos de parametrização; e
- JUnit Vintage possibilita a execução de testes legados.
As anotações do JUnit 5, como @Test, @BeforeEach, @AfterEach, @BeforeAll e @AfterAll, simplificam a estruturação e configuração dos testes. Além disso, as extensões permitem a personalização e extensibilidade dos testes, adicionando funcionalidades extras de forma flexível e sem complicação.
Vamos construir um exemplo de teste com JUnit 5. Devemos seguir, primeiro, algumas regras:
- A classe Java de teste:
- Deve ser uma classe pública;
- Não deve ser não abstrata; e
- Deve ter um construtor público e sem parâmetros;
- Métodos de teste:
- Devem ser públicos;
- Devem ser anotados com @Test
- Não podem ter:
- Nenhum valor de retorno;
- Nenhum parâmetro.
Sobre as anotações, as principais são:
- @Test é usado para anotar os métodos para serem executados como um teste;
- @BeforeAll:
- Um método anotado com essa anotação:
- Deve ser um método estático; e
- Será executado uma vez antes de qualquer teste ser executado;
- Um método anotado com essa anotação:
- @BeforeEach:
- Um método anotado com essa anotação será executado uma vez antes de cada método de teste anotado com @Test;
- @AfterAll é semelhante ao @BeforeAll, mas será executado após a execução de todos os testes; e
- @AfterEach é semelhante ao @BeforeEach, mas será executado uma vez após a execução de cada teste.
Considere um simples exemplo de um teste usando JUnit 5 para uma classe Calculadora, onde queremos verificar a funcionalidade da adição de dois números:
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class CalculadoraTest {
@Test
public void testSoma() {
Calculadora calc = new Calculadora();
int resultado = calc.somar(3, 5);
assertEquals(8, resultado, “A soma de 3 e 5 deve ser igual a 8”);
}
}
Neste exemplo, utilizamos a anotação @Test para indicar que o método testSoma é um caso de teste. Com a ajuda do método assertEquals, verificamos se o resultado da soma de 3 e 5 é de fato igual a 8.
O JUnit 5 também se destaca pela integração contínua e execução paralela de testes, essenciais para ambientes modernos de desenvolvimento. Isso garante a rapidez e eficiência na validação contínua do código durante todo o ciclo de desenvolvimento.
A simplicidade de uso e a compatibilidade do JUnit 5 com as principais ferramentas de build, como Maven e Gradle, além de ambientes de desenvolvimento como IntelliJ IDEA, tornam-no uma escolha natural para os desenvolvedores que buscam uma estrutura de teste confiável e poderosa.
Em resumo, o JUnit 5 oferece uma gama abrangente de recursos e funcionalidades para testes unitários em Java. Sua modularidade, anotações poderosas, suporte à programação assíncrona e facilidade de uso fazem dele uma ferramenta essencial para garantir a qualidade do código em qualquer projeto de desenvolvimento de software.
Questão de concurso
[FGV 2023 DPE/RS – Técnico – Apoio Especializado – Programador] O ferramental de testes padrão para a plataforma Java é o JUnit, que utiliza anotações sobre classes e métodos para especificar o conjunto de testes unitários necessários para o projeto. Considere uma classe de teste para ações de inserção em um banco de dados, onde a conexão é preestabelecida, não fazendo parte das ações de inserção, e encerrada ao final de todos os testes.
A anotação que precisa ser utilizada no método que abre a conexão, considerando-se a versão 5 do JUnit, é:
A) @BeforeEach;
B) @AfterAll;
C) @AfterEach;
D) @BeforeAll;
E) @AfterClass.
Comentários:
No contexto descrito, onde a conexão é preestabelecida antes das ações de inserção e encerrada ao final de todos os testes, a anotação adequada para o método que abre a conexão, considerando a versão 5 do JUnit, é a letra d (@BeforeAll). Esta anotação é usada para indicar que o método deve ser executado uma única vez antes de todos os testes na classe de teste.
Enquanto a anotação @BeforeEach é usada para indicar um método a ser executado antes de cada método de teste e o @AfterEach é executado após cada método de teste, o @AfterAll é aplicado para métodos que devem ser executados uma vez após todos os testes na classe. Já o @AfterClass não é uma anotação do JUnit 5, sendo uma anotação associada a estruturas de teste como o JUnit 4.
Portanto, para garantir que a conexão seja aberta antes de qualquer teste na classe e encerrada após a execução de todos os testes, a anotação correta a ser utilizada no método que inicia a conexão é o @BeforeAll.
Gabarito: letra D.
Espero que tenham gostado!
Forte abraço e até a próxima jornada!
_________________________
Professor Rogerão Araújo
Clique nos links abaixo:
Receba gratuitamente no seu celular as principais notícias do mundo dos concursos!
Clique no link abaixo e inscreva-se gratuitamente: