Ein Anfängerleitfaden zu JUnit 5

Tutorials

JUnit

JUnit 5 ist ein Software-Testframework, das von Entwicklern verwendet wird, um ihren Code zu unit testen. Es handelt sich um ein auf Java basierendes Framework, das das Schreiben und Ausführen von Tests auf der Java-Plattform ermöglicht, einschließlich eines integrierten Reporters, der die Testergebnisse anzeigt.

JUnit kann für die Automatisierungstests für zwei Hauptzwecke verwendet werden:

Testen, ob die Software so funktioniert, wie es erwartet wird
Fehler im Code finden und melden und sie so schnell wie möglich beheben

In diesem Blog werden wir uns auf das Setup, die Konfiguration und die grundlegenden Methoden von JUnit 5 konzentrieren und darüber lernen.

Was ist JUnit 5?

JUnit 5 ist die neueste Version des JUnit-Testframeworks. Es unterstützt Java 8 und neuere Versionen, bietet Platz für verschiedene Teststile und bietet eine moderne Grundlage für Entwicklerseitige Tests auf der JVM.

Der Hauptvorteil von JUnit ist seine Modularität, da es mehrere Module enthält, die es den Entwicklern ermöglichen, verschiedene Komponenten der Software leicht zu testen. Es kann auch verwendet werden, um einzelne Klassen der Anwendung anstelle der gesamten Anwendung zu testen.

Features von JUnit 5

Die folgenden Funktionen von JUnit 5 sind einige der beliebten und wichtigen Funktionen, die es von anderen Unit-Testframeworks unterscheiden.

Feature	Description	Annotations/Method
Test Suites	Test-Suiten sind im Grunde eine Gruppe von Tests, wie Smoke, Sanity, oder eine Gruppe von Tests, die mit einem bestimmten Feature zusammenhängen. JUnit 5 ermöglicht die Erstellung von Test-Suiten, die gemeinsam ausgeführt werden können.	Um Test-Suiten zu verwenden, müssen wir eine JUnit Platform Suite-Abhängigkeit hinzufügen und die folgenden Annotationen verwenden. `@SelectPackages`, `@SelectClasses`, `@Suite`
Assertions	Assertions werden verwendet, um das erwartete Verhalten der Software zu überprüfen. JUnit 5 bietet eingebaute Assert-Methode, die dabei helfen können, die Überprüfungen einfach durchzuführen.	Es gibt mehrere Assert-Methode in der Klasse `import org.junit.jupiter.api.Assertions;`. Einige der Methoden sind unten aufgeführt: `assertTrue()`, `assertFalse()`, `assertEquals()`, `assertAll()`, `assertNotEquals()`
Testausführungsreihenfolge	Passen Sie die Testausführungsreihenfolge an. Es ermöglicht dem Entwickler, die Kontrolle über die Testausführung zu übernehmen und die Tests in einer bestimmten Reihenfolge auszuführen, wie erforderlich.	`@TestMethodOrder`, `@Order`, `@TestClassOrder`
Ausnahmeprüfung	Führt eine Ausnahmeprüfung durch, die überprüft, ob die erforderliche Ausnahme im Test ausgelöst wird.	Der folgende Methode aus der `import org.junit.jupiter.api.Assertions;` -Klasse wird verwendet: `assertThrows()`
Test Abhängigkeiten	Testabhängigkeiten ermöglichen die sequenzielle Prüfung, indem sie die Möglichkeit bieten, dass Testmethoden voneinander abhängig sind. Das bedeutet, dass die nächste Testmethode, die von der vorherigen Testmethode abhängt, erst ausgeführt wird, wenn die vorherige bestanden wurde. Diese Funktion ist hilfreich beim Schreiben von Integrationstests.	@TestInstance
Tests deaktivieren	Deaktiviert Tests oder Testklassen.	@Disabled
Timeouts	Einen Test fehlschlagen lassen, wenn seine Ausführungszeit eine bestimmte Dauer überschreitet.	@Timeout
Berichte	Bietet einen integrierten Berichtersteller zur Analyse von Testergebnissen und zeigt detaillierte Informationen an. Generiert eine `.html`-Datei mit den Testausführungsergebnissen.	N/A

JUnit 4 vs. JUnit 5

Mit der Veröffentlichung der neuesten Version von JUnit, d.h. JUnit 5, wurden dem Framework mehrere Änderungen und neue Funktionen hinzugefügt. Die Unterschiede zwischen den beiden Versionen sind in der folgenden Tabelle aufgeführt:

criteria	JUNIT4	JUNIT5
Architektur	Alles war in einer einzigen JAR-Datei verpackt.	In 3 Unterprojekte unterteilt: – JUnit-Plattform – JUnit Jupiter – JUnit Vintage
JDK-Version Anforderungen	Erfordert Java 5 oder höher	Erfordert Java 8 oder höher
Integration von Drittanbietern	Keine Unterstützung für die Integration von Drittanbietern für Plugins und IDEs	Eigenes Unterprojekt (JUnit-Plattform) für Integrationen von Drittanbietern
Unterstützung für geschachtelte Tests	Keine Annotation zum Schreiben von geschachtelten Tests bereitgestellt	Bietet die `@Nested` Annotation zum Schreiben von geschachtelten Tests
Unterstützung für die Registrierung benutzerdefinierter Erweiterungen	Keine Unterstützung für benutzerdefinierte Erweiterungen	Bietet die `@ExtendWith` Annotation zur Registrierung benutzerdefinierter Erweiterungen
Änderungen an häufig verwendeten Annotationen	– `@BeforeClass` – `@AfterClass` – `@Before` – `@After` – `@Ignore`	– `@BeforeAll` – `@AfterAll` – `@BeforeEach` – `@AfterEach` – `@Disabled`
Änderungen an Annotationen für Tagging und Filtern	`@Category` Annotation wird verwendet	`@Tag` Annotation wird verwendet
Test-Suiten	`@RunWith` und `@Suite` Annotationen wurden verwendet	Die Annotationen `@Suite`, `@SelectPackages` und `@SelectClasses` werden verwendet

Erste Schritte mit JUnit 5

In diesem Abschnitt werden wir lernen, wie man Testfälle mit JUnit 5 unter Verwendung der IntelliJ IDE schreibt. Da sie bereits mit JUnit 5 gebündelt ist, müssen wir keine zusätzliche Installation durchführen, um sie zu verwenden.

Wir müssen ein neues Maven-Projekt erstellen, die JUnit 5-Abhängigkeiten hinzufügen und sofort mit dem Schreiben der Tests beginnen.

Hinzufügen der JUnit-Abhängigkeiten im Maven-Projekt

Die folgenden JUnit 5-Abhängigkeiten müssen in der pom.xml-Datei hinzugefügt werden:

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

Hier ist die vollständige pom.xml-Datei

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>

Nachdem die Abhängigkeiten hinzugefügt wurden, sind wir bereit, den Test zu schreiben. Bevor wir jedoch mit dem Schreiben der Tests mit JUnit 5 beginnen, wollen wir zuerst die grundlegenden Annotationen verstehen, die uns dabei helfen können, das Test-Suite effizient einzurichten und Tests wie gewünscht auszuführen.

Grundlegende Annotationen, die in JUnit 5 verwendet werden

Die folgenden sind grundlegende Annotationen, die von Entwicklern am häufigsten verwendet werden, während sie Tests mit JUnit 5 schreiben.

@BeforeAll Annotation

Die @BeforeAll-Annotation zeigt an, dass die annotierte Methode vor allen @Test, @RepeatedTest, @ParameterizedTest oder @TestFactory-Methoden in der aktuellen Klasse ausgeführt werden soll. Sie muss eine statische Methode in der Testklasse sein.

@BeforeAll dient als Ersatz für die @BeforeClass-Annotation, die in JUnit 4.x verwendet wurde

Syntax:

Java

public class BasicTest {

​

   @BeforeAll

   public static void beforeAllTest() {

​

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

   }

​

//..

}

@BeforeEach-Annotation

Die @BeforeEach-Annotation zeigt an, dass die annotierte Methode vor jedem Aufruf von @Test, @RepeatedTest, @ParameterizedTest oder @TestFactory-Methoden in der aktuellen Klasse ausgeführt werden soll.

Sie ist Teil der Methoden des Testlebenszyklus und ersetzt die @Before-Annotation, die in JUnit 4 verwendet wurde.

Syntax:

Java

public class BasicTest {

​

   @BeforeEach

   public void beforeEachTest() {

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

   }

//...

}

@AfterAll-Annotation

Die @AfterAll-Annotation zeigt an, dass die annotierte Methode aufgerufen werden soll, nachdem alle Tests in der aktuellen Klasse ausgeführt wurden. Sie muss eine statische Methode sein und wird als Aufräummethode in der Testklasse verwendet.

@AfterAll ist der Ersatz für die @AfterClass-Annotation in JUnit 4.

Syntax:

Java

public class BasicTest {

​

//...

​

@AfterAll

public static void afterAllMethod() {

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

   }

}

@AfterEach-Annotation

Die @AfterEach-Annotation zeigt an, dass die annotierte Methode nach jeder @Test, @RepeatedTest, @ParameterizedTest oder @TestFactory-Methode in der aktuellen Klasse ausgeführt werden soll.

Es dient als Ersatz für die JUnit 4 @After Annotation.

Syntax:

Java

public class BasicTest {

​

//...

​

@AfterEach

public void afterEachMethod() {

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

   }

}

@Test Annotation

Die @Test Annotation zeigt an, dass die annotierte Methode eine Testmethode ist. Die Testmethode darf nicht privat oder statisch sein und muss keinen Wert zurückgeben.

Syntax:

Java

public class BasicTest {

​

//.. 

@Test

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

@DisplayName Annotation

Die @DisplayName Annotation wird verwendet, um einen benutzerdefinierten Namen für die annotierte Testklasse oder -methode anzugeben. Diese benutzerdefinierten Namen können Leerzeichen, Sonderzeichen und sogar Emojis enthalten und werden in der Regel in den von IDEs und Build-Tools generierten Testberichten verwendet.

Syntax:

Java

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

@Disabled Annotation

Die @Disabled Annotation in JUnit 5 wird verwendet, um die Testmethode oder die Testklasse aus dem Testlauf auszuschließen.

Wenn sie auf eine Testklasse angewendet wird, werden automatisch alle Methoden innerhalb der Testklasse als deaktiviert betrachtet. Diese Annotation verfügt über einen optionalen Parameter, der es ermöglicht, den Grund für die Deaktivierung des Tests anzugeben.

Syntax:

Java

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

Wie man automatisierte Testfälle mit JUnit 5 schreibt

Es ist an der Zeit, in den Code einzutauchen und mit JUnit 5 zu arbeiten. Wir werden eine neue Java-Klasse erstellen, BasicTest.

Java

public class BasicTest {
//..
}

Alle grundlegenden Annotationen, die wir besprochen haben, werden im Rahmen der Demonstration behandelt.

Lassen Sie uns Methoden in der BasicTest-Klasse hinzufügen, um die Verwendung der @BeforeAll, @BeforeEach, @AfterAll, @AfterEach, @Test, @DisplayName und @Disabled Annotationen, die in JUnit 5 verfügbar sind, zu demonstrieren.

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!!");
   }
}

Code Durchgang

Die @DisplayName Annotation über der Testklasse zeigt den Testnamen als „Demo-Testklasse“ in den Ergebnissen an, wenn der Test ausgeführt wird.

Die beforeAllTest() Methode wird vor der Ausführung eines der Tests aufgerufen und gibt den Text „Before All method Called!!“ aus. Als Nächstes wird die beforeEachTest() Methode vor jedem Test ausgeführt und gibt den Text „Before Each Method called!!“ aus.

Es gibt drei Testmethoden in dieser Klasse, nämlich testMethodOne(), testMethodTwo() und disabledTest(). Alle drei Testmethoden haben die @Test Annotation darüber, was bedeutet, dass dies Testmethoden sind.

Die disabledTest() Methode wird nicht ausgeführt, da sie die @Disabled Annotation darüber hat.

Nach der Ausführung jedes Tests wird die afterEachTestMethod() ausgeführt, da sie die @AfterEach Annotation darüber hat.

Schließlich, nachdem alle Tests ausgeführt wurden, wird die afterAllMethod() ausgeführt, da sie die @AfterAll Annotation darüber hat.

Testausführung

Die Tests können ausgeführt werden, indem Sie mit der rechten Maustaste auf die Testklasse klicken und „Ausführen ‚‚“ auswählen(„BasicTest“ in unserem Fall).

Eine andere Möglichkeit besteht darin, auf das grün gefärbte Play-Symbol neben der Deklaration der Testklasse zu klicken, wie im folgenden Screenshot gezeigt:

Der folgende Screenshot aus der IntelliJ IDE zeigt, dass die Tests erfolgreich ausgeführt wurden.

Im obigen Screenshot ist zu sehen, dass der Anzeigename der Testklasse gedruckt wurde, auch der deaktivierte Test ist zu sehen und der Grund für den deaktivierten Test wird in der Konsole gedruckt.

Alle Testmethoden, einschließlich der beforetest und aftertest, wurden erfolgreich ausgeführt, und die entsprechenden Ergebnisse wurden in der Konsole gedruckt.

Zusammenfassung

JUnit 5 ist ein leistungsstarkes Testframework, das von Entwicklern zur Durchführung von Modultests des Codes verwendet wird. Es wird auch von Testautomatisierungsingenieuren verwendet, um Testautomatisierungsskripte zu schreiben und auszuführen. Es verfügt über umfangreiche Funktionen, die es Entwicklern und Testern ermöglichen, die Testskripte zu schreiben und Modultests des Codes durchzuführen.

Es bietet auch mehrere Methoden zur Durchführung von Behauptungen und Überprüfungen, die beim Schreiben automatisierter Tests nützlich sind. Neben dem Schreiben und Ausführen der Testskripte wird auch ein Testbericht bereitgestellt, der verwendet werden kann, um den Stakeholdern die Testausführungsergebnisse vorzuführen und die Testabdeckung zu präsentieren.

Viel Spaß beim Testen!

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