Como baixar o JUnit 5
JUnit é uma das estruturas de teste de unidade mais populares para Java. Ele permite que você escreva e execute testes que verificam a funcionalidade e a qualidade do seu código. JUnit 5 é a versão mais recente do JUnit, que apresenta muitos novos recursos e melhorias em relação ao JUnit 4.
download junit 5
Neste artigo, mostraremos como baixar e usar o JUnit 5 em seus projetos Java. Também abordaremos alguns dos principais recursos do JUnit 5 que o tornam uma ferramenta de teste poderosa e flexível.
O que é JUnit 5 e por que usá-lo?
JUnit 5 é a próxima geração de JUnit. É composto por três componentes principais:
Plataforma JUnit: uma base para o lançamento de estruturas de teste na JVM.
JUnit Jupiter: um modelo de programação e extensão para escrever testes e extensões no JUnit 5.
JUnit Vintage: um mecanismo de teste para executar testes JUnit 3 e JUnit 4 na plataforma.
O JUnit 5 aproveita os recursos do Java 8 e superior, como expressões lambda, fluxos e tipos opcionais. Ele também suporta muitos estilos diferentes de teste, como testes parametrizados, testes dinâmicos, testes aninhados e testes repetidos. Além disso, permite estender sua funcionalidade com anotações, condições e extensões personalizadas.
Alguns dos benefícios do uso do JUnit 5 são:
É mais modular e flexível que o JUnit 4.
É mais expressivo e legível que o JUnit 4.
É compatível com outras estruturas e bibliotecas de teste.
É suportado pela maioria dos IDEs e ferramentas de construção.
Pré-requisitos
Para usar o JUnit 5, você precisa ter:
Java 8 ou superior instalado em sua máquina.
Maven ou Gradle como sua ferramenta de construção.
Baixando JUnit 5
Você pode baixar o JUnit 5 usando Maven ou Gradle. Em ambos os casos, você precisa adicionar algumas dependências ao arquivo de configuração do seu projeto.
Usando o Maven
Se você estiver usando o Maven, precisará adicionar a seguinte dependência ao seu arquivo pom.xml:
<dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-engine</artifactId> <version>5.9.2</version> <scope>test</scope> </dependency>
Essa dependência inclui o módulo junit-jupiter-api, que contém as principais anotações e asserções para escrever testes, e o módulo junit-jupiter-engine, que contém a implementação do mecanismo de teste para executar testes.
Para executar seus testes usando o Maven, você pode usar o plug-in maven-surefire ou o plug-in maven-failsafe. Por exemplo, você pode executar seus testes com o seguinte comando:
teste mvn
Usando o Gradle
Se você estiver usando o Gradle, precisará adicionar a seguinte dependência ao seu arquivo build.gradle:
dependencies testImplementation 'org.junit.jupiter:junit-jupiter-engine:5.9.2'
Essa dependência inclui o módulo junit-jupiter-api e o módulo junit-jupiter-engine também.
Para executar seus testes usando o Gradle, você pode usar a tarefa de teste fornecida pelo plug-in java. Por exemplo, você pode executar seus testes com o seguinte comando:
teste gradle
Conclusão
Recursos e exemplos do JUnit 5
Agora que baixamos o JUnit 5, vamos ver alguns dos recursos que o tornam uma ferramenta de teste poderosa e flexível. Também mostraremos alguns exemplos de como utilizá-los em nossos testes.
Nomes de exibição
Um dos novos recursos do JUnit 5 é a capacidade de personalizar o nome de exibição de uma classe de teste ou método de teste. Isso pode ser útil para tornar os nomes dos testes mais descritivos e legíveis.
Para definir um nome de exibição personalizado, podemos usar a anotação @DisplayName. Por exemplo:
@DisplayName ("um caso de teste especial") classe DisplayNameDemo @Test @DisplayName ("Nome do teste personalizado contendo espaços") void testWithDisplayNamEContainingsPaces () @Test @DisPlayName (" ) @TesttSTSTSTWith (@Testwname (" @) @TestTSTSTWith) isPlayName ("?") void testWithDisplayNameContainingemoji () }
Os nomes de exibição serão mostrados nos relatórios de teste e nos IDEs. Por exemplo, no IntelliJ IDEA, podemos ver algo assim:
Asserções
Asserções são o núcleo de qualquer estrutura de teste.Eles nos permitem verificar o comportamento esperado e o resultado do nosso código. O JUnit 5 fornece um rico conjunto de asserções na classe org.junit.jupiter.api.Assertions. Alguns deles são:
assertEquals(esperado, real): afirma que dois objetos são iguais.
assertNotEquals(esperado, real): afirma que dois objetos não são iguais.
assertTrue(condição): afirma que uma condição é verdadeira.
assertFalse(condição): afirma que uma condição é falsa.
assertNull(object): afirma que um objeto é nulo.
assertNotNull(object): afirma que um objeto não é nulo.
assertSame(esperado, real): afirma que dois objetos se referem à mesma instância.
assertNotSame(esperado, real): afirma que dois objetos não se referem à mesma instância.
assertArrayEquals(esperado, real): afirma que dois arrays são iguais.
assertIterableEquals(esperado, real): afirma que dois iteráveis são iguais.
assertThrows(exceptionType, executable): afirma que um executável lança uma exceção do tipo especificado.
assertTimeout(duração, executável): afirma que um executável é concluído antes de um determinado tempo limite.
Todas essas asserções aceitam um parâmetro de mensagem opcional que pode ser usado para fornecer informações adicionais em caso de falha. Por exemplo:
@Test void testAssertEquals() assertEquals(2, 1 + 1, "1 + 1 deve ser igual a 2");
O parâmetro message também pode ser uma função de fornecedor que avalia lentamente a mensagem apenas quando necessário. Por exemplo:
@Test void testAssertEqualsWithMessageSupplier() assertEquals(2, 1 + 1, () -> "1 + 1 deve ser igual a " + (1 + 1));
Além dessas asserções, o JUnit 5 também oferece suporte a expressões lambda para escrever testes mais concisos e legíveis. Por exemplo, podemos usar assertAll para agrupar várias asserções em uma única asserção. Isso nos permite executar todas as asserções em um grupo, mesmo que uma delas falhe. Por exemplo:
@Test void testAssertAll() assertAll( () -> assertEquals(2, 1 + 1), () -> assertTrue('a' assertNotNull(new Object()) );
Também podemos usar assertDoesNotThrow para verificar se um executável não lança nenhuma exceção. Por exemplo:
@Test void testAssertDoesNotThrow() assertDoesNotThrow(() -> int x = 0; int y = 1 / x; );
Testes aninhados
Testes aninhados são um recurso do JUnit 5 que nos permite agrupar testes relacionados em classes aninhadas. Isso pode nos ajudar a estruturar nossos testes de forma mais hierárquica e organizada. Os testes aninhados também herdam quaisquer anotações de sua classe delimitadora, como @BeforeEach ou @AfterEach.
Para criar testes aninhados, precisamos usar a anotação @Nested na classe aninhada. Por exemplo:
@DisplayName("Uma pilha") class StackTest { Pilha Testes repetidos
Outro recurso do JUnit 5 é a capacidade de repetir um teste várias vezes com a anotação @RepeatedTest. Isso pode ser útil para testar cenários que envolvem aleatoriedade, simultaneidade ou desempenho.
Para criar um teste repetido, precisamos usar a anotação @RepeatedTest em vez da anotação @Test e especificar o número de repetições. Por exemplo:
@RepeatedTest(5) void repeatTest() System.out.println("Teste de repetição"); assertTrue(Math.random() > 0.1);
Este teste será executado cinco vezes e cada vez ele afirmará que um número aleatório é maior que 0,1.
Também podemos personalizar o nome de exibição de cada repetição usando o atributo name da anotação @RepeatedTest. Podemos usar espaços reservados como currentRepetition, totalRepetitions e displayName para incluir informações dinâmicas. Por exemplo:
@RepeatedTest(value = 5, name = "Repetição currentRepetition de totalRepetitions") void repeatTestWithCustomDisplayName() System.out.println("Teste de repetição com nome de exibição personalizado"); assertTrue(Math.random() > 0.1);
Os nomes de exibição serão mostrados nos relatórios de teste e nos IDEs. Por exemplo, no IntelliJ IDEA, podemos ver algo assim:
Também podemos acessar informações sobre a repetição atual e o total de repetições usando o parâmetro RepetitionInfo. Este parâmetro pode ser injetado no método de teste ou em um método @BeforeEach ou @AfterEach. Por exemplo:
@BeforeEach void beforeEach(RepetitionInfo repeatInfo) int currentRepetition = repeatInfo.getCurrentRepetition(); int totalRepetitions = repeatInfo.getTotalRepetitions(); System.out.println("Antes da repetição " + currentRepetition + " of " + totalRepetitions); @RepeatedTest(5) void repeatTestWithRepetitionInfo(RepetitionInfo repeatInfo) System.out.println("Teste de repetição com informação de repetição"); assertTrue(Math.random() > 0.1); @AfterEach void afterEach(RepetitionInfo repeatInfo) int currentRepetition = repeatInfo.getCurrentRepetition(); int totalRepetitions = repeatInfo.getTotalRepetitions(); System.out.println("Após a repetição " + currentRepetition + " of " + totalRepetitions); Testes Dinâmicos
Testes dinâmicos são um recurso do JUnit 5 que permite gerar testes em tempo de execução. Ao contrário dos testes estáticos, que são totalmente especificados em tempo de compilação, os testes dinâmicos podem ser criados com base em dados, configuração ou outras fontes. Isso pode ser útil para testar cenários que não são fáceis de expressar com testes estáticos, como carregar casos de teste de um recurso externo, gerar casos de teste com base em alguma lógica ou criar testes parametrizados com argumentos complexos.
Para criar testes dinâmicos, precisamos usar a anotação @TestFactory em um método que retorna uma coleção de instâncias de DynamicTest. Um DynamicTest consiste em um nome de exibição e um bloco de código executável. Por exemplo:
Coleção @TestFactory dynamicTestsFromCollection() return Arrays.asList( DynamicTest.dynamicTest("Primeiro teste dinâmico", () -> assertTrue(true)), DynamicTest.dynamicTest("Segundo teste dinâmico", () -> assertEquals(4, 2 * 2)) );
Este exemplo cria dois testes dinâmicos com nomes e asserções diferentes. O método @TestFactory também pode retornar instâncias Iterable, Iterator ou Stream de DynamicTest. Por exemplo:
Fluxo @TestFactory dynamicTestsFromStream() return Stream.of("A", "B", "C") .map(str -> DynamicTest.dynamicTest("teste" + str, () -> assertTrue(str.startsWith("A"))));
Este exemplo cria três testes dinâmicos com base em um fluxo de strings. Cada teste tem um nome que inclui a string e uma asserção que verifica se a string começa com "A".
Os testes dinâmicos são executados de forma diferente dos testes estáticos e não suportam callbacks ou extensões de ciclo de vida. Portanto, os métodos @BeforeEach e @AfterEach não serão executados para testes dinâmicos. No entanto, podemos usar os métodos @BeforeAll e @AfterAll para executar operações de configuração e desmontagem para toda a fábrica de teste.
Também podemos usar o parâmetro TestInfo para acessar informações sobre o teste dinâmico atual, como seu nome de exibição, tags ou ID exclusivo. Por exemplo:
Fluxo @TestFactory dynamicTestsFromStreamWithTestInfo(TestInfo testInfo) assertEquals("dynamicTestsFromStreamWithTestInfo", testInfo.getDisplayName()); return Stream.of("A", "B", "C") .map(str -> DynamicTest.dynamicTest("teste" + str, () -> assertTrue(str.startsWith("A"))));
Este exemplo afirma que o nome de exibição do método de fábrica de teste é igual ao nome do método. Testes Parametrizados
Os testes parametrizados são um recurso do JUnit 5 que nos permite executar o mesmo teste várias vezes com diferentes argumentos. Eles podem nos ajudar a evitar a duplicação e aumentar a cobertura do teste. Eles usam a anotação @ParameterizedTest em vez da anotação @Test.Eles também exigem uma fonte de argumentos, que pode ser fornecida por várias anotações, como @ValueSource, @EnumSource, @MethodSource, @CsvSource e @ArgumentsSource.
Para criar um teste parametrizado, precisamos usar a anotação @ParameterizedTest e especificar uma fonte de argumentos. Por exemplo:
@ParameterizedTest @ValueSource(strings = "racecar", "radar", "capaz de eu ver elba") void palindromes(String candidate) assertTrue(Strings.isPalindrome(candidate));
Este teste será executado três vezes e, a cada vez, confirmará que a string candidata é um palíndromo.
Também podemos usar outros tipos de argumentos, como ints, longs, doubles, booleanos, enums, métodos, arquivos csv, etc. Por exemplo:
@ParameterizedTest @EnumSource(TimeUnit.class) void testWithEnumSource(TimeUnit timeUnit) assertNotNull(timeUnit);
Esse teste será executado seis vezes e, a cada vez, ele confirmará que o valor da enumeração timeUnit não é nulo.
Também podemos personalizar o nome de exibição de cada chamada usando o atributo name da anotação @ParameterizedTest. Podemos usar espaços reservados como index, arguments e displayName para incluir informações dinâmicas. Por exemplo:
@ParameterizedTest(name = "index ==> a classificação de ''0'' é 1") @CsvSource("apple, A", "banana, B", "cherry, C", "date, D") void testWithCustomDisplayNames(String fruit, String rank) assertNotNull(fruit); assertNotNull(classificação);
Os nomes de exibição serão mostrados nos relatórios de teste e nos IDEs. Por exemplo, no IntelliJ IDEA, podemos ver algo assim:
Extensões
As extensões são um recurso do JUnit 5 que nos permite estender o comportamento de classes ou métodos de teste. Eles podem ser usados para várias finalidades, como fornecer lógica comum de configuração e desmontagem, injeção de dependências, manipulação de exceções, pular testes, etc.
Para criar uma extensão, precisamos implementar uma ou mais APIs de extensão que correspondam a diferentes pontos de extensão no ciclo de vida de execução do teste. Por exemplo, podemos implementar a interface BeforeAllCallback para executar algum código antes de todos os testes em uma classe de teste.
Para registrar uma extensão, podemos usar um dos seguintes métodos:
Use a anotação @ExtendWith em uma classe de teste ou um método de teste.
Use a anotação @RegisterExtension em um campo em uma classe de teste.
Use o mecanismo ServiceLoader para registrar extensões automaticamente.
Por exemplo, vamos criar uma extensão que se conecta a um banco de dados antes de todos os testes e se desconecta após todos os testes. Podemos usar as interfaces BeforeAllCallback e AfterAllCallback para implementar esta lógica:
classe pública DatabaseExtension implementa BeforeAllCallback, AfterAllCallback conexão de conexão privada; @Override public void beforeAll(ExtensionContext context) lança Exception connection = DriverManager.getConnection("jdbc:h2:mem:test", "sa", ""); System.out.println("Conectado ao banco de dados"); @Override public void afterAll(ExtensionContext context) lança Exception connection.close(); System.out.println("Desconectado do banco de dados");
Então, podemos registrar esta extensão usando a anotação @ExtendWith em nossa classe de teste:
@ExtendWith(DatabaseExtension.class) class DatabaseTest @Test void someTest() // usa conexão
Também podemos registrar várias extensões usando a mesma anotação. Por exemplo:
@ExtendWith(DatabaseExtension.class, LoggingExtension.class) class DatabaseTest @Test void someTest() // usa conexão e logger
O JUnit 5 também fornece algumas extensões internas que podemos usar em nossos testes. Por exemplo, a extensão TempDirectory cria e limpa diretórios temporários para cada teste.Podemos usar a anotação @TempDir para injetar uma instância Path ou File em nosso método de teste ou classe de teste. Por exemplo:
@ExtendWith(TempDirectory.class) class TempDirectoryTest @TempDir Path tempDir; @Test void writeItemsToFile() throws IOException Path file = tempDir.resolve("test.txt"); novo ListWriter().writeItemsToFile(arquivo); assertEquals(2, Files.readAllLines(file).size());
Também podemos criar nossas próprias anotações personalizadas compostas de outras anotações. Por exemplo, podemos criar uma anotação que combine as anotações @ExtendWith e @Tag:
@Target( ElementType.TYPE, ElementType.METHOD ) @Retention(RetentionPolicy.RUNTIME) @Tag("database") @ExtendWith(DatabaseExtension.class) public @interface DatabaseTest
Em seguida, podemos usar essa anotação em nossa classe de teste ou método de teste em vez de usar várias anotações:
@DatabaseTest class DatabaseTest @Test void someTest() // usa conexão Conclusão
Neste artigo, aprendemos como baixar e usar o JUnit 5 em nossos projetos Java. Também exploramos alguns dos recursos do JUnit 5 que o tornam uma ferramenta de teste poderosa e flexível, como nomes de exibição, asserções, testes aninhados, testes repetidos, testes dinâmicos, testes parametrizados e extensões.
O JUnit 5 é uma grande melhoria em relação ao JUnit 4 e oferece muitos benefícios para escrever e executar testes. Ele aproveita os recursos do Java 8 e superior e oferece suporte a diferentes estilos de teste. Também é compatível com outras estruturas e bibliotecas de teste e é compatível com a maioria dos IDEs e ferramentas de construção.
Se você quiser saber mais sobre o JUnit 5, pode conferir os seguintes recursos:
O site oficial do JUnit 5: [
O guia do usuário do JUnit 5: [
A documentação de referência do JUnit 5: [
O repositório GitHub do JUnit 5: [
perguntas frequentes
Aqui estão algumas perguntas frequentes sobre o JUnit 5:
P: Como faço para migrar do JUnit 4 para o JUnit 5?
R: Você pode usar a dependência junit-vintage-engine para executar seus testes JUnit 4 existentes na plataforma JUnit. Você também pode usar o módulo junit-jupiter-migrationsupport para usar algumas das anotações JUnit 4 em seus testes JUnit 5. Para obter mais detalhes, consulte [
P: Como executo testes JUnit 5 na linha de comando?
R: Você pode usar o Console Launcher para executar seus testes JUnit 5 a partir da linha de comando. Você pode baixar o arquivo jar de [ e executá-lo com o comando java -jar. Para obter mais detalhes, consulte [
P: Como executo testes JUnit 5 no Eclipse?
R: Você precisa ter o Eclipse Oxygen (4.7) ou posterior para executar os testes JUnit 5 no Eclipse. Você pode usar a opção Run As > JUnit Test para executar seus testes normalmente. Você também pode usar a visualização JUnit para ver os resultados do teste. Para obter mais detalhes, consulte [
P: Como executo testes JUnit 5 no IntelliJ IDEA?
R: Você precisa ter o IntelliJ IDEA 2016.2 ou posterior para executar testes JUnit 5 no IntelliJ IDEA. Você pode usar a opção Executar > Executar... para executar seus testes normalmente. Você também pode usar a janela da ferramenta Executar para ver os resultados do teste. Para mais detalhes, consulte [
P: Como escrevo extensões personalizadas para JUnit 5?
R: Você pode escrever extensões personalizadas para JUnit 5 implementando uma ou mais APIs de extensão e registrando-as com a anotação @ExtendWith ou outros métodos. Você também pode usar o parâmetro ExtensionContext para acessar informações sobre a execução do teste atual.Para mais detalhes, consulte [ 0517a86e26
Comments