Um Guia para Iniciantes sobre JUnit 5

Tutoriais

JUnit

JUnit 5 é um framework de teste 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 automatizados para dois principais propósitos:

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

Neste blog, vamos nos concentrar e aprender 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 recentes, 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 facilmente diferentes componentes do software. Ele 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
Conjuntos de Testes	Conjuntos de testes são basicamente um grupo de testes, como Smoke, Sanity, ou um grupo de testes relacionados a uma funcionalidade específica. JUnit 5 permite a criação de conjuntos de testes que podem ser executados juntos.	Para usar Conjuntos de Testes, precisamos adicionar uma dependência do JUnit Platform Suite e usar as seguintes anotações. `@SelectPackages`, `@SelectClasses`, `@Suite`
Aserções	Asserções são usadas para verificar o comportamento esperado do software. O JUnit 5 fornece métodos de asserção embutidos que podem ajudar a realizar as asserções facilmente.	Existem múltiplos métodos de asserçã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 de Testes	Personaliza a ordem de execução dos testes. Permite que o desenvolvedor tenha controle sobre a execução dos testes e execute os testes em uma ordem específica, conforme necessário.	`@TestMethodOrder`, `@Order`, `@TestClassOrder`
Teste de Exceção	Realiza teste de exceção que verifica se a exceção necessária é lançada no teste.	Método a seguir da `import org.junit.jupiter.api.Assertions;` classe é utilizado: `assertThrows()`
Dependências de Teste	As 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. Isso é um recurso útil ao escrever testes de integração.	@TestInstance
Desabilitar Testes	Desabilita testes ou classes de teste.	@Disabled
Tempos Limite	Falha em 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 juntamente em um único arquivo JAR.	Dividido em 3 subprojetos: – JUnit Platform – JUnit Jupiter – JUnit Vintage
Requisitos 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 (JUnit Platform) para integrações de terceiros
Suporte para Testes Aninhados	Sem anotação fornecida para escrever testes aninhados	Fornece a anotação `@Nested` para escrever testes aninhados
Suporte para Registro de 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 Usadas	– `@BeforeClass` – `@AfterClass` – `@Before` – `@After` – `@Ignore`	– `@BeforeAll` – `@AfterAll` – `@BeforeEach` – `@AfterEach` – `@Disabled`
Alterações de Anotação para Marcação e Filtragem	A anotação `@Category` é usada	A anotação `@Tag` é usada
Conjuntos de Testes	As anotações `@RunWith` e `@Suite` foram usadas	As anotações `@Suite`, `@SelectPackages` e `@SelectClasses` são usadas

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 da Plataforma JUnit (Aggregator)
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>

Após adicionar as dependências, estamos prontos para escrever o teste. Mas, antes de seguirmos para escrever os 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 populares usadas pelos desenvolvedores ao escrever os testes com o JUnit 5.

@BeforeAll Annotation

A anotação @BeforeAll indica que o método anotado deve ser executado antes de qualquer método @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 de @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 após todos os testes na classe atual terem sido executados. Deve ser um método estático e é usado como um 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 a substituição 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 pode ser um método privado ou estático e não pode 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 ou método de teste anotado. Esses nomes personalizados podem incluir espaços, caracteres especiais e até emojis, e são geralmente utilizados nos relatórios de teste gerados por IDEs e ferramentas de compilaçã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 a classe de teste da suíte de testes para execução.

Quando aplicada a uma classe de teste, todos os métodos dentro da classe de teste são automaticamente considerados desativados. Esta anotação tem um parâmetro opcional que permite especificar o motivo para desativar o 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 JUnit 5

É hora de entrar no código e colocar a mão 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 cobertas 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 sobre a 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 de qualquer execução de teste e imprimirá o texto “Método Before All chamado!!”. Em seguida, o método beforeEachTest() será executado antes de cada teste e imprimirá o texto “Método Before Each chamado!!”.

Existem 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 estes são métodos de teste.

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

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

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

Execução de Teste

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 de reprodução verde ao lado da declaração da classe de teste, como mostrado na captura de tela abaixo:

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

Pode ser visto na captura de tela acima que o nome de exibição da classe de teste foi impresso, também o teste desabilitado pode ser visto e o motivo para o teste desabilitado é impresso no console.

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

Resumo

O JUnit 5 é um poderoso framework de teste usado por desenvolvedores para realizar testes unitários do código. Também é utilizado por engenheiros de automação de teste para escrever e executar scripts de automação de teste. Possui recursos avançados que permitem aos desenvolvedores e testadores escrever os scripts de teste e realizar testes unitários do código.

Também fornece vários métodos para realizar asserções e verificações que são úteis ao escrever testes automatizados. Além de escrever e executar os scripts de teste, também fornece um relatório de teste que pode ser usado para demonstrar os resultados da execução do teste para os interessados, mostrando a cobertura do teste.

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 JUnit 5

Visão Geral do Código

Execução de Teste

Resumo

Anotação `@BeforeEach`

Anotação `@AfterAll`

Anotação `@AfterEach`