Guida per principianti a JUnit 5

Tutorial

JUnit

JUnit 5 è un framework di test software utilizzato dai developer per testare in modo unitario il proprio codice. È un framework basato su Java che consente di scrivere ed eseguire test sulla piattaforma Java, tra cui un reporter integrato che visualizza i risultati dei test.

JUnit può essere utilizzato per il testing automatizzato a due scopi principali:

Verificare che il software funzioni come previsto
Trovare e segnalare errori nel codice e correggerli il prima possibile

In questo articolo, ci concentreremo su come configurare e utilizzare i metodi di base di JUnit 5.

Cos’è JUnit 5?

JUnit 5 è l’ultima versione del framework di testing JUnit. Supporta Java 8 e versioni successive, permette stili di test diversi e offre una base moderna per i test sul lato sviluppatore nella JVM.

Il principale vantaggio nell’utilizzare JUnit è la sua modularità, in quanto contiene diversi moduli che consentono ai developer di testare facilmente diverse componenti del software. Può anche essere utilizzato per testare singole classi dell’applicazione anziché l’intera applicazione.

Caratteristiche di JUnit 5

Di seguito sono elencate alcune delle caratteristiche popolari e importanti di JUnit 5 che lo distinguono da altri framework di test unitari.

Feature	Description	Annotations/Method
Suite di Test	Le suite di test sono essenzialmente un gruppo di test, come Smoke, Sanity, o un insieme di test relativi a una particolare funzionalità. JUnit 5 consente la creazione di suite di test che possono essere eseguite insieme.	Per utilizzare le Suite di Test, è necessario aggiungere una dipendenza JUnit Platform Suite e utilizzare le seguenti annotazioni. `@SelectPackages`, `@SelectClasses`, `@Suite`
Assert	Le asserzioni sono utilizzate per verificare il comportamento atteso del software. JUnit 5 fornisce metodi di asserzione integrati che possono aiutare a eseguire facilmente le asserzioni.	Sono disponibili diversi metodi di asserzione nella classe `import org.junit.jupiter.api.Assertions;`. Di seguito sono elencati alcuni metodi: `assertTrue()`, `assertFalse()`, `assertEquals()`, `assertAll()`, `assertNotEquals()`
Ordine di Esecuzione dei Test	Personalizza l’ordine di esecuzione dei test. Consente allo sviluppatore di prendere il controllo dell’esecuzione dei test e di eseguire i test nell’ordine specifico desiderato.	`@TestMethodOrder`, `@Order`, `@TestClassOrder`
Test di eccezioni	Esegue il test delle eccezioni che verifica che l’eccezione richiesta venga lanciata nel test.	Il seguente metodo dalla `import org.junit.jupiter.api.Assertions;` classe è utilizzato: `assertThrows()`
Test delle dipendenze	Le dipendenze dei test consentono test sequenziali fornendo la possibilità di far dipendere i metodi di test l’uno dall’altro. Ciò significa che il metodo di test successivo, dipendente dal metodo di test precedente, non verrà eseguito a meno che il precedente non superi. Questa è una funzionalità utile durante la scrittura dei test di integrazione.	@TestInstance
Disabilitazione dei test	Disabilita i test o le classi di test.	@Disabled
Timeout	Non supera un test se il tempo di esecuzione supera una durata specificata.	@Timeout
Report	Fornisce un reporter integrato per analizzare i risultati dei test e visualizzare informazioni dettagliate. Genera un file `.html` con i risultati dell’esecuzione del test.	N/A

JUnit 4 vs. JUnit 5

Con il rilascio dell’ultima versione di JUnit, cioè JUnit 5, sono state apportate molte modifiche e nuove funzionalità al framework. Le differenze tra le due versioni sono elencate nella tabella sottostante:

criteria	JUNIT4	JUNIT5
Architettura	Tutto era confezionato insieme in un singolo file JAR.	Diviso in 3 sottoprogetti: – JUnit Platform – JUnit Jupiter – JUnit Vintage
Requisito di Versione JDK	Richiede Java 5 o superiore	Richiede Java 8 o superiore
Integrazione di Terze Parti	Nessun supporto per integrazioni di terze parti per plugin e IDE	Sottoprogetto dedicato (JUnit Platform) per integrazioni di terze parti
Supporto per Test Annidati	Nessuna annotazione fornita per scrivere test annidati	Fornisce l’annotazione `@Nested` per scrivere test annidati
Supporto per Registrazione di Estensioni Personalizzate	Nessun supporto per estensioni personalizzate	Fornisce l’annotazione `@ExtendWith` per registrare estensioni personalizzate
Cambiamenti apportati alle Annotazioni Comunemente Usate	– `@BeforeClass` – `@AfterClass` – `@Before` – `@After` – `@Ignore`	– `@BeforeAll` – `@AfterAll` – `@BeforeEach` – `@AfterEach` – `@Disabled`
Cambiamenti nelle Annotazioni per Tagging e Filtraggio	L’annotazione `@Category` è utilizzata	L’annotazione `@Tag` è utilizzata
Suite di Test	Le annotazioni `@RunWith` e `@Suite` sono state utilizzate	`@Suite`, `@SelectPackages` e `@SelectClasses` annotazioni sono utilizzate

Iniziare con JUnit 5

In questa sezione, impareremo come scrivere i casi di test JUnit 5 utilizzando IntelliJ IDE. Poiché è già fornito con JUnit 5, non dobbiamo effettuare ulteriori installazioni per usarlo.

Dobbiamo creare un nuovo progetto Maven, aggiungere le dipendenze di JUnit 5 e iniziare a scrivere i test immediatamente.

Aggiunta delle dipendenze di JUnit nel progetto Maven

Le seguenti dipendenze di JUnit 5 devono essere aggiunte nel file pom.xml:

JUnit Jupiter Engine
JUnit Jupiter API
JUnit Platform Suite (Aggregatore)
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>

Ecco il file completo pom.xml

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>

Dopo aver aggiunto le dipendenze, siamo pronti a scrivere il test. Ma prima di passare a scrivere i test utilizzando JUnit 5, comprendiamo prima le annotazioni di base che potrebbero aiutarci a configurare efficacemente la suite di test e a eseguire i test come desiderato.

Annotazioni di base utilizzate in JUnit 5

Le seguenti sono annotazioni di base che sono più comunemente utilizzate dagli sviluppatori mentre scrivono i test utilizzando JUnit 5.

@BeforeAll Annotazione

L’annotazione @BeforeAll indica che il metodo annotato deve essere eseguito prima di qualsiasi metodo @Test, @RepeatedTest, @ParameterizedTest o @TestFactory nella classe corrente. Deve essere un metodo statico nella classe di test.

@BeforeAll funge da sostituto dell’annotazione @BeforeClass utilizzata in JUnit 4.x

Sintassi:

Java

public class BasicTest {

​

   @BeforeAll

   public static void beforeAllTest() {

​

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

   }

​

//..

}

Annotazione `@BeforeEach`

L’annotazione @BeforeEach indica che il metodo annotato deve essere eseguito prima di ogni invocazione dei metodi @Test, @RepeatedTest, @ParameterizedTest o @TestFactory nella classe corrente.

È parte dei metodi del ciclo di vita del test e sostituisce l’annotazione @Before utilizzata in JUnit 4.

Sintassi:

Java

public class BasicTest {

​

   @BeforeEach

   public void beforeEachTest() {

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

   }

//...

}

Annotazione `@AfterAll`

L’annotazione @AfterAll indica che il metodo annotato deve essere chiamato dopo che tutti i test nella classe corrente sono stati eseguiti. Deve essere un metodo statico ed è utilizzato come metodo di chiusura nella classe di test.

L’annotazione @AfterAll è la sostituzione dell’annotazione @AfterClass in JUnit 4.

Sintassi:

Java

public class BasicTest {

​

//...

​

@AfterAll

public static void afterAllMethod() {

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

   }

}

Annotazione `@AfterEach`

L’annotazione @AfterEach indica che il metodo annotato deve essere eseguito dopo ogni metodo @Test, @RepeatedTest, @ParameterizedTest o @TestFactory nella classe corrente.

Serve come sostituto di JUnit 5 per l’annotazione @After utilizzata in JUnit 4.

Sintassi:

Java

public class BasicTest {

​

//...

​

@AfterEach

public void afterEachMethod() {

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

   }

}

Annotation @Test

L’annotazione @Test indica che il metodo annotato è un metodo di test. Il metodo di test non deve essere privato o statico e non deve restituire un valore.

Sintassi:

Java

public class BasicTest {

​

//.. 

@Test

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

Annotation @DisplayName

L’annotazione @DisplayName viene utilizzata per specificare un nome personalizzato per la classe o il metodo di test annotato. Questi nomi personalizzati possono includere spazi, caratteri speciali e persino emoji e vengono tipicamente utilizzati nei report di test generati da IDE e strumenti di build.

Sintassi:

Java

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

Annotation @Disabled

L’annotazione @Disabled in JUnit 5 viene utilizzata per escludere il metodo di test o la classe di test dalla suite di test per l’esecuzione.

Quando applicata a una classe di test, tutti i metodi all’interno della classe di test vengono considerati automaticamente disabilitati. Questa annotazione ha un parametro opzionale che consente di specificare il motivo per la disabilitazione del test.

Sintassi:

Java

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

Come Scrivere Casi di Test Automatizzati Utilizzando JUnit 5

È tempo di immergersi nel codice e sporcarci le mani con JUnit 5. Creeremo una nuova classe Java, BasicTest.

Java

public class BasicTest {
//..
}

Tutte le annotazioni di base che abbiamo discusso saranno trattate come parte della dimostrazione.

Aggiungiamo metodi nella classe BasicTest per dimostrare l’uso delle annotazioni @BeforeAll, @BeforeEach, @AfterAll, @AfterEach, @Test, @DisplayName e @Disabled disponibili in 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!!");
   }
}

Analisi del Codice

L’annotazione @DisplayName sopra la classe di test mostrerà il nome del test come “Classe di test dimostrativa” nei risultati quando il test viene eseguito.

Il metodo beforeAllTest() verrà eseguito prima che venga eseguito qualsiasi test e stamperà il testo “Metodo Before All chiamato!!”. Successivamente, il metodo beforeEachTest() verrà eseguito prima di ogni test e stamperà il testo “Metodo Before Each chiamato!!”.

Ci sono tre metodi di test in questa classe, ovvero testMethodOne(), testMethodTwo() e disabledTest(). Tutti e tre i metodi di test hanno l’@Test annotation sopra di essi, che indica che si tratta di metodi di test.

Il metodo disabledTest() non verrà eseguito in quanto ha l’annotazione @Disabled posta sopra di esso.

Dopo che l’esecuzione di ogni test è completata, il afterEachTestMethod() verrà eseguito poiché ha l’annotazione @AfterEach posta sopra di esso.

Infine, dopo che tutti i test sono stati eseguiti, il afterAllMethod() verrà eseguito poiché ha l’annotazione @AfterAll posta sopra di esso.

Esecuzione del Test

I test possono essere eseguiti facendo clic con il pulsante destro del mouse sulla classe di test e selezionando Esegui ‘<Nome della classe di test>’(“BasicTest” nel nostro caso).

Un altro modo è fare clic sull’icona Play di colore verde accanto alla dichiarazione della classe di test, come mostrato nello screenshot sottostante:

Nello screenshot seguente da IntelliJ IDE si può vedere che i test sono stati eseguiti con successo.

Nello screenshot precedente si può notare che il nome visualizzato della classe di test è stato stampato, così come il test disabilitato che è visibile e il motivo per cui è disabilitato è stampato nella console.

Tutti i metodi di test, inclusi quelli beforetest e aftertest, sono stati eseguiti con successo e i risultati rispettivi sono stati stampati sulla console.

Riepilogo

JUnit 5 è un framework di testing potente utilizzato dai developer per eseguire il testing unitario del codice. È anche utilizzato dagli ingegneri di automazione dei test per scrivere ed eseguire gli script di automazione dei test. Ha funzionalità avanzate che permettono ai developer e ai tester di scrivere gli script di test e eseguire il testing unitario del codice.

Fornisce anche vari metodi per eseguire asserzioni e verifiche che sono utili durante la scrittura dei test automatizzati. Oltre alla scrittura ed esecuzione degli script di test, fornisce anche un report di test che può essere utilizzato per mostrare i risultati dell’esecuzione del test agli stakeholder per dimostrare la copertura dei test.

Buon testing!

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

Cos’è JUnit 5?

Caratteristiche di JUnit 5

JUnit 4 vs. JUnit 5

Iniziare con JUnit 5

Aggiunta delle dipendenze di JUnit nel progetto Maven

Annotazioni di base utilizzate in JUnit 5

@BeforeAll Annotazione

Annotazione @BeforeEach

Annotazione @AfterAll

Annotazione @AfterEach

Annotation @Test

Annotation @DisplayName

Annotation @Disabled

Come Scrivere Casi di Test Automatizzati Utilizzando JUnit 5

Analisi del Codice

Esecuzione del Test

Riepilogo

Annotazione `@BeforeEach`

Annotazione `@AfterAll`

Annotazione `@AfterEach`