Um Guia para Iniciantes sobre JUnit 5

Tutoriais

JUnit

JUnit 5 é um framework de testes de software usado por desenvolvedores para realizar testes unitários em seu código. É um framework baseado em Java que permite escrever e executar testes na plataforma Java, incluindo um relatório integrado que exibe os resultados dos testes.

JUnit pode ser usado para testes de automação com dois objetivos principais:

Testar se o software está funcionando conforme esperado
Encontrar e relatar erros no código e corrigi-los o mais rápido possível

Neste blog, estaremos focando e aprendendo sobre a configuração, configuração e métodos básicos usados no JUnit 5.

O que é JUnit 5?

JUnit 5 é a versão mais recente do framework de testes JUnit. Ele suporta Java 8 e versões mais novas, acomoda diferentes estilos de teste e oferece uma base moderna para testes do lado do desenvolvedor na JVM.

O principal benefício de usar o JUnit é sua modularidade, pois contém múltiplos módulos que permitem aos desenvolvedores testar diferentes componentes do software facilmente. Também pode ser usado para testar classes individuais da aplicação em vez de toda a aplicação.

Características do JUnit 5

As seguintes são algumas das características populares e importantes do JUnit 5 que o distinguem de outros frameworks de testes unitários.

Feature	Description	Annotations/Method
Suites de Teste	Suites de teste são basicamente um grupo de testes, como Smoke, Sanity, ou um grupo de testes relacionados a uma característica específica. O JUnit 5 permite a criação de suites de teste que podem ser executadas juntas.	Para usar Suites de Teste, precisamos adicionar uma dependência JUnit Platform Suite e usar as seguintes anotações. `@SelectPackages`, `@SelectClasses`, `@Suite`
Afirmações	Afirmações são usadas para verificar o comportamento esperado do software. O JUnit 5 fornece métodos de afirmação integrados que podem ajudar a realizar facilmente as afirmações.	Há vários métodos de afirmação disponíveis na classe `import org.junit.jupiter.api.Assertions;`. Alguns dos métodos estão listados abaixo: `assertTrue()`, `assertFalse()`, `assertEquals()`, `assertAll()`, `assertNotEquals()`
Ordem de Execução dos Testes	Personaliza a ordem de execução dos testes. Permite ao desenvolvedor controlar a execução dos testes e executá-los na ordem específica conforme necessário.	`@TestMethodOrder`, `@Order`, `@TestClassOrder`
Teste de Exceção	Realiza testes de exceção que verificam se a exceção necessária é lançada no teste.	Método a seguir da classe `import org.junit.jupiter.api.Assertions;` é utilizado: `assertThrows()`
Dependências de Teste	Dependências de teste permitem testes sequenciais, fornecendo a facilidade de permitir que métodos de teste dependam uns dos outros. Isso significa que o próximo método de teste, que depende do método de teste anterior, não será executado a menos que o anterior passe. Este é um recurso útil ao escrever testes de integração.	@TestInstance
Desabilitar Testes	Desabilita testes ou classes de teste.	@Disabled
Tempos Limite	Falha um teste se o tempo de execução exceder uma duração especificada.	@Timeout
Relatórios	Fornece um relatório integrado para analisar os resultados dos testes e exibir informações detalhadas. Gera um arquivo `.html` com os resultados da execução dos testes.	N/A

JUnit 4 vs. JUnit 5

Com o lançamento da última versão do JUnit, ou seja, JUnit 5, várias mudanças e novos recursos foram adicionados ao framework. As diferenças entre as duas versões estão listadas na tabela abaixo:

criteria	JUNIT4	JUNIT5
Arquitetura	Tudo estava empacotado em um único arquivo JAR.	Dividido em 3 subprojetos: – Plataforma JUnit – JUnit Jupiter – JUnit Vintage
Requisito de Versão do JDK	Requer Java 5 ou superior	Requer Java 8 ou superior
Integração de Terceiros	Sem suporte para integração de terceiros para plugins e IDEs	Subprojeto dedicado (Plataforma JUnit) para integrações de terceiros
Suporte para Testes Aninhados	Nenhuma anotação fornecida para escrever testes aninhados	Fornece a anotação `@Nested` para escrever testes aninhados
Suporte para Registrar Extensões Personalizadas	Sem suporte para extensões personalizadas	Fornece a anotação `@ExtendWith` para registrar extensões personalizadas
Alterações Feitas em Anotações Comumente Utilizadas	– `@BeforeClass` – `@AfterClass` – `@Before` – `@After` – `@Ignore`	– `@BeforeAll` – `@AfterAll` – `@BeforeEach` – `@AfterEach` – `@Disabled`
Alterações de Anotação para Marcação e Filtragem	A anotação `@Category` é utilizada	A anotação `@Tag` é utilizada
Suites de Teste	As anotações `@RunWith` e `@Suite` eram utilizadas	As anotações `@Suite`, `@SelectPackages` e `@SelectClasses` são utilizadas

Começando com o JUnit 5

Nesta seção, aprenderemos como escrever casos de teste JUnit 5 usando o IntelliJ IDE. Como ele já vem com o JUnit 5, não precisamos realizar nenhuma instalação adicional para usá-lo.

Precisamos criar um novo projeto Maven, adicionar as dependências do JUnit 5 e começar a escrever os testes imediatamente.

Adicionando as Dependências do JUnit no Projeto Maven

As seguintes dependências do JUnit 5 precisam ser adicionadas no arquivo pom.xml:

JUnit Jupiter Engine
JUnit Jupiter API
Suite JUnit Platform (Agregador)
JUnit Jupiter Params

XML

<dependency>

    <groupId>org.junit.jupiter</groupId>

    <artifactId>junit-jupiter-engine</artifactId>

    <version>5.11.4</version>

    <scope>test</scope>

</dependency>

<dependency>

    <groupId>org.junit.jupiter</groupId>

    <artifactId>junit-jupiter-api</artifactId>

    <version>5.11.4</version>

    <scope>test</scope>

</dependency>

<dependency>

    <groupId>org.junit.platform</groupId>

    <artifactId>junit-platform-suite</artifactId>

    <version>1.11.4</version>

    <scope>test</scope>

</dependency>

<dependency>

    <groupId>org.junit.jupiter</groupId>

    <artifactId>junit-jupiter-params</artifactId>

    <version>5.11.4</version>

    <scope>test</scope>

</dependency>

Aqui está o arquivo pom.xml completo

XML

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

​

    <groupId>io.github.mfaisalkhatri</groupId>

    <artifactId>junit-basic</artifactId>

    <version>1.0-SNAPSHOT</version>

    <packaging>jar</packaging>

​

    <name>junit-basic</name>

    <url>http://maven.apache.org</url>

​

    <properties>

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

    </properties>

​

    <dependencies>

        <dependency>

            <groupId>org.junit.jupiter</groupId>

            <artifactId>junit-jupiter-engine</artifactId>

            <version>5.11.4</version>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.junit.jupiter</groupId>

            <artifactId>junit-jupiter-api</artifactId>

            <version>5.11.4</version>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.junit.platform</groupId>

            <artifactId>junit-platform-suite</artifactId>

            <version>1.11.4</version>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.junit.jupiter</groupId>

            <artifactId>junit-jupiter-params</artifactId>

            <version>5.11.4</version>

            <scope>test</scope>

        </dependency>

    </dependencies>

</project>

Depois de adicionar as dependências, estamos prontos para escrever o teste. No entanto, antes de prosseguirmos com a escrita dos testes usando o JUnit 5, vamos primeiro entender as anotações básicas que podem nos ajudar a configurar eficientemente o conjunto de testes e executar os testes conforme desejado.

Anotações Básicas Usadas no JUnit 5

As seguintes são as anotações básicas mais popularmente usadas pelos desenvolvedores ao escrever os testes usando o JUnit 5.

@BeforeAll Annotation

A anotação @BeforeAll indica que o método anotado deve ser executado antes de quaisquer métodos @Test, , @RepeatedTest, @ParameterizedTest ou @TestFactory na classe atual. Deve ser um método estático na classe de teste.

@BeforeAll serve como substituto da anotação @BeforeClass usada no JUnit 4.x

Sintaxe:

Java

public class BasicTest {

​

   @BeforeAll

   public static void beforeAllTest() {

​

       System.out.println("Before All method called!!");

   }

​

//..

}

Anotação `@BeforeEach`

A anotação @BeforeEach indica que o método anotado deve ser executado antes de cada invocação dos métodos @Test, , @RepeatedTest, @ParameterizedTest ou @TestFactory na classe atual.

Faz parte dos métodos do ciclo de vida do teste e substitui a anotação @Before usada no JUnit 4.

Sintaxe:

Java

public class BasicTest {

​

   @BeforeEach

   public void beforeEachTest() {

       System.out.println("Before Each method called!!");

   }

//...

}

Anotação `@AfterAll`

A anotação @AfterAll indica que o método anotado deve ser chamado depois que todos os testes na classe atual foram executados. Deve ser um método estático e é usado como método de finalização na classe de teste.

A anotação @AfterAll é o substituto da anotação @AfterClass no JUnit 4.

Sintaxe:

Java

public class BasicTest {

​

//...

​

@AfterAll

public static void afterAllMethod() {

   System.out.println("After All method called!!");

   }

}

Anotação `@AfterEach`

A anotação @AfterEach indica que o método anotado deve ser executado após cada método @Test, , @RepeatedTest, @ParameterizedTest ou @TestFactory na classe atual.

Serve como substituto do JUnit 5 para a anotação @After usada no JUnit 4.

Sintaxe:

Java

public class BasicTest {

​

//...

​

@AfterEach

public void afterEachMethod() {

   System.out.println("After Each method called!!");

   }

}

Anotação @Test

A anotação @Test indica que o método anotado é um método de teste. O método de teste não deve ser privado ou estático e não deve retornar um valor.

Sintaxe:

Java

public class BasicTest {

​

//.. 

@Test

public void testMethod() {
   System.out.println("Test Method Called!!");
  }
}

Anotação @DisplayName

A anotação @DisplayName é usada para especificar um nome personalizado para a classe de teste ou método anotado. Esses nomes personalizados podem incluir espaços, caracteres especiais e até emojis e são tipicamente utilizados nos relatórios de teste gerados por IDEs e ferramentas de construção.

Sintaxe:

Java

@DisplayName("Demo Test class")
public class BasicTest {
​
//...
​
@DisplayName("This is a demo test")
@Test
public void testMethod() {
   System.out.println("Test Method Called!!");
   }
}

Anotação @Disabled

A anotação @Disabled no JUnit 5 é usada para excluir o método de teste ou classe de teste da suíte de testes para execução.

Ao ser aplicada a uma classe de teste, todos os métodos dentro da classe de teste são automaticamente considerados desativados. Esta anotação possui um parâmetro opcional que permite especificar o motivo da desativação do teste.

Sintaxe:

Java

public class BasicTest {
​
@Disabled("Test method disabled")
public void testMethod() {
   System.out.println("Test Method Called!!");
 }
//...
}

Como Escrever Casos de Teste Automatizados Usando o JUnit 5

É hora de entrar no código e colocar as mãos na massa com o JUnit 5. Vamos criar uma nova classe Java, BasicTest.

Java

public class BasicTest {
//..
}

Todas as anotações básicas que discutimos serão abordadas como parte da demonstração.

Vamos adicionar métodos na classe BasicTest para demonstrar o uso das anotações @BeforeAll, @BeforeEach, @AfterAll, @AfterEach, @Test, @DisplayName e @Disabled disponíveis no JUnit 5.

Java

@DisplayName("Demo Test class")
public class BasicTest {
​
   @BeforeAll
   public static void beforeAllTest() {
​
       System.out.println("Before All method called!!");
   }
​
   @BeforeEach
   public void beforeEachTest() {
       System.out.println("Before Each method called!!");
   }
​
   @DisplayName("This is a demo test")
   @Test
   public void testMethodOne() {
       System.out.println("Test Method One Called!!");
   }
​
   @Test
   @Disabled("This test is disabled to demo disable annotation")
   public void disabledTest() {
       System.out.println("This is a disabled test!!");
   }
​
   @Test
   public void testMethodTwo() {
       System.out.println("Test Method Two Called!!");
​
   }
​
   @AfterEach
   public void afterEachMethod() {
       System.out.println("After Each method called!!");
   }
​
   @AfterAll
   public static void afterAllMethod() {
       System.out.println("After All method called!!");
   }
}

Visão Geral do Código

A anotação @DisplayName na classe de teste exibirá o nome do teste como “Classe de teste de demonstração” nos resultados quando o teste for executado.

O método beforeAllTest() será executado antes que qualquer teste seja executado e imprimirá o texto “Método Antes de Todos Chamado!!”. Em seguida, o método beforeEachTest() será executado antes de cada teste e imprimirá o texto “Método Antes de Cada Chamado!!”.

Há três métodos de teste nesta classe, a saber, testMethodOne(), testMethodTwo() e disabledTest(). Todos os três métodos de teste têm a@Test annotation sobre eles, o que indica que esses são métodos de teste.

O método disabledTest() não será executado, pois possui a anotação @Disabled sobre ele.

Após a conclusão da execução de cada teste, o afterEachTestMethod() será executado, pois possui a anotação @AfterEach colocada acima dele.

Finalmente, após a execução de todos os testes, o afterAllMethod() será executado, pois possui a anotação @AfterAll colocada sobre ele.

Execução de Testes

Os testes podem ser executados clicando com o botão direito na classe de teste e selecionando Executar ‘<Nome da Classe de Teste>’(“BasicTest” no nosso caso).

Outra maneira é clicar no ícone verde de Play ao lado da declaração da classe de teste, conforme mostrado na captura de tela abaixo:

A captura de tela a seguir do IntelliJ IDE mostra que os testes foram executados com sucesso.

Pode-se ver na captura de tela acima que o nome exibido da classe de teste foi impresso, também o teste desabilitado pode ser visto e a razão para o teste desabilitado está impressa no console.

Todos os outros métodos de teste, incluindo os beforetest e aftertest, foram executados com sucesso, e os respectivos resultados foram impressos no console.

Resumo

JUnit 5 é um poderoso framework de testes usado por desenvolvedores para realizar testes unitários do código. Ele também é utilizado por engenheiros de automação de testes para escrever e executar scripts de automação de testes. Possui recursos ricos que permitem que desenvolvedores e testadores escrevam os scripts de teste e realizem testes unitários do código.

Além de escrever e executar os scripts de teste, ele também fornece um relatório de testes que pode ser usado para demonstrar os resultados da execução dos testes para as partes interessadas, mostrando a cobertura dos testes.

Teste feliz!

Source:
https://dzone.com/articles/beginners-guide-to-junit-5

O que é JUnit 5?

Características do JUnit 5

JUnit 4 vs. JUnit 5

Começando com o JUnit 5

Adicionando as Dependências do JUnit no Projeto Maven

Anotações Básicas Usadas no JUnit 5

@BeforeAll Annotation

Anotação @BeforeEach

Anotação @AfterAll

Anotação @AfterEach

Anotação @Test

Anotação @DisplayName

Anotação @Disabled

Como Escrever Casos de Teste Automatizados Usando o JUnit 5

Visão Geral do Código

Execução de Testes

Resumo

Anotação `@BeforeEach`

Anotação `@AfterAll`

Anotação `@AfterEach`