Java einfach erklärt

Plain Java

Unit-Testing in Java mit JUnit 5

Was ist Unit-Testing?

Unit-Testing ist eine Methode des Softwaretests, bei der einzelne Einheiten oder Komponenten einer Software unabhängig voneinander überprüft werden, um sicherzustellen, dass sie gemäß den Spezifikationen funktionieren. Diese Einheiten können Funktionen, Methoden oder Klassen sein, die den kleinsten ausführbaren Code darstellen. Ziel des Unit-Testings ist es, sicherzustellen, dass jede Einheit ordnungsgemäß funktioniert und dass Änderungen an einer Einheit keine unerwünschten Auswirkungen auf andere Teile des Codes haben.

Unit-Tests sind unverzichtbar, um die Qualität und Zuverlässigkeit von Software zu gewährleisten. Sie ermöglichen es Entwicklern, Fehler frühzeitig zu erkennen und zu beheben, bevor sie sich auf andere Teile des Codes auswirken oder in die Produktion gelangen.

JUnit 5: Ein Überblick

JUnit ist ein weit verbreitetes Framework für das Unit-Testing in der Java-Programmierung. Mit JUnit können Entwickler Testfälle schreiben und automatisch ausführen, um sicherzustellen, dass ihre Code-Einheiten korrekt funktionieren. JUnit 5 ist die neueste Version dieses Frameworks und bietet viele Verbesserungen und neue Funktionen im Vergleich zu früheren Versionen.

Die wichtigsten Merkmale von JUnit 5 sind:

1. Modulare Architektur:

JUnit 5 wurde mit einer modularen Architektur entwickelt, die es ermöglicht, nur die benötigten Teile des Frameworks zu verwenden. Dies erhöht die Flexibilität und erleichtert die Integration mit anderen Tools und Bibliotheken.

2. Erweiterte Annotations:

JUnit 5 bietet eine erweiterte und verbesserte Annotation-Syntax, mit der Entwickler Testfälle und Testmethoden kennzeichnen können. Dies macht den Code leserlicher und wartungsfreundlicher.

3. Parameterisierte Tests:

JUnit 5 unterstützt parameterisierte Tests, bei denen Sie denselben Testfall mit verschiedenen Eingabewerten ausführen können. Dies erleichtert die Überprüfung von verschiedenen Szenarien.

4. Erweiterbare Architektur:

Entwickler können eigene Erweiterungen und Plugins für JUnit 5 erstellen, um spezifische Anforderungen zu erfüllen oder benutzerdefinierte Funktionalitäten hinzuzufügen.

Installation von JUnit 5

Bevor Sie mit JUnit 5 Unit-Tests schreiben können, müssen Sie sicherstellen, dass Sie JUnit 5 in Ihrem Projekt installiert haben. Dies kann auf verschiedene Arten erfolgen, abhängig von Ihrem Build-Tool (z.B. Maven oder Gradle) und Ihrer Entwicklungsumgebung (z.B. Eclipse oder IntelliJ IDEA).

Maven

Wenn Sie Maven verwenden, können Sie JUnit 5 zu Ihren Abhängigkeiten in der pom.xml-Datei Ihres Projekts hinzufügen:

<dependencies>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.7.2</version> <!-- Aktuelle Version überprüfen -->
        <scope>test</scope>
    </dependency>
</dependencies>Code-Sprache: HTML, XML (xml)

Stellen Sie sicher, dass Sie die aktuelle Version von JUnit 5 verwenden, indem Sie die Versionsnummer in der pom.xml-Datei aktualisieren.

Gradle

Wenn Sie Gradle verwenden, können Sie JUnit 5 in Ihrer build.gradle-Datei hinzufügen:

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.2' // Aktuelle Version überprüfen
}Code-Sprache: JavaScript (javascript)

Führen Sie nach dem Hinzufügen der Abhängigkeit einen Build Ihres Projekts durch, um JUnit 5 herunterzuladen und zu installieren.

Entwicklungsumgebung

In den meisten Entwicklungsumgebungen wie Eclipse oder IntelliJ IDEA ist JUnit 5 bereits integriert. Sie müssen lediglich sicherstellen, dass Sie die entsprechenden Bibliotheken korrekt konfiguriert haben, um JUnit 5 in Ihren Tests verwenden zu können.

Schreiben von Unit-Tests mit JUnit 5

Nach der Installation von JUnit 5 können Sie damit beginnen, Unit-Tests für Ihre Java-Code-Einheiten zu schreiben. Dies erfolgt in drei Schritten: das Annotieren von Testfällen, das Erstellen von Testmethoden und das Ausführen der Tests.

1. Annotieren von Testfällen

Um einen Testfall zu erstellen, kennzeichnen Sie eine Klasse mit der @Test-Annotation von JUnit 5. Ein Testfall ist eine Sammlung von Testmethoden, die verschiedene Aspekte der zu testenden Einheit abdecken.

import org.junit.jupiter.api.Test;

public class MeinTestfall {

    @Test
    public void testErfolgreicheBerechnung() {
        // Hier schreiben Sie Ihren Testcode
    }

    @Test
    public void testFehlerhafteBerechnung() {
        // Hier schreiben Sie Ihren Testcode
    }
}Code-Sprache: JavaScript (javascript)

2. Erstellen von Testmethoden

Nachdem Sie Ihren Testfall erstellt haben, können Sie Testmethoden in dieser Klasse hinzufügen. Diese Methoden sollten mit der @Test-Annotation gekennzeichnet sein und den Code enthalten, der Ihre zu testende Einheit überprüft. Hier ist ein einfaches Beispiel:

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class MeinTestfall {

    @Test
    public void testAddition() {
        // Arrange
        int a = 5;
        int b = 3;

        // Act
        int sum = a + b;

        // Assert
        assertEquals(8, sum);
    }
}Code-Sprache: JavaScript (javascript)

In diesem Beispiel testen wir die Addition zweier Zahlen. Wir arrangieren (Arrange) die Eingabewerte, führen die Berechnung durch (Act) und überprüfen das erwartete Ergebnis (Assert) mit der assertEquals

-Methode von JUnit 5.

3. Ausführen der Tests

Nachdem Sie Ihre Testfälle und -methoden erstellt haben, können Sie die Tests ausführen. In den meisten Entwicklungsumgebungen können Sie dies einfach tun, indem Sie auf die Schaltfläche „Tests ausführen“ oder „Testen“ klicken. JUnit 5 führt dann automatisch alle Testmethoden in Ihren Testfällen aus und gibt das Ergebnis zurück.

Assert-Methoden in JUnit 5

JUnit 5 bietet eine Vielzahl von Assert-Methoden, die Sie verwenden können, um Ihre Testergebnisse zu überprüfen. Hier sind einige häufig verwendete Assert-Methoden:

  • assertEquals(expected, actual): Überprüft, ob actual gleich expected ist.
  • assertNotEquals(expected, actual): Überprüft, ob actual nicht gleich expected ist.
  • assertTrue(condition): Überprüft, ob condition wahr ist.
  • assertFalse(condition): Überprüft, ob condition falsch ist.
  • assertNull(object): Überprüft, ob object null ist.
  • assertNotNull(object): Überprüft, ob object nicht null ist.
  • assertArrayEquals(expectedArray, actualArray): Überprüft, ob die Arrays expectedArray und actualArray gleich sind.

Sie können auch benutzerdefinierte Assertionen erstellen, indem Sie eigene Bedingungen und Fehlermeldungen definieren.

Parameterisierte Tests

JUnit 5 ermöglicht es Ihnen, parameterisierte Tests zu erstellen, bei denen Sie denselben Testfall mit verschiedenen Eingabewerten ausführen können. Dies ist besonders nützlich, wenn Sie denselben Code mit verschiedenen Daten überprüfen möchten. Um parameterisierte Tests in JUnit 5 zu erstellen, verwenden Sie die @ParameterizedTest-Annotation.

Hier ist ein einfaches Beispiel für einen parameterisierten Test:

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import static org.junit.jupiter.api.Assertions.*;

public class ParameterisierteTests {

    @ParameterizedTest
    @ValueSource(ints = {1, 2, 3, 4, 5})
    public void testIsGeradeZahl(int zahl) {
        assertTrue(zahl % 2 == 0);
    }
}Code-Sprache: JavaScript (javascript)

In diesem Beispiel führen wir denselben Test für verschiedene Eingabewerte (1, 2, 3, 4, 5) aus und überprüfen, ob es sich um gerade Zahlen handelt.

Ausnahmen testen

Manchmal ist es notwendig, zu überprüfen, ob eine Methode eine erwartete Ausnahme wirft. JUnit 5 bietet die assertThrows-Methode, um dies zu ermöglichen.

Hier ist ein Beispiel:

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class AusnahmeTests {

    @Test
    public void testDivisionDurchNull() {
        assertThrows(ArithmeticException.class, () -> {
            int result = 5 / 0; // Division durch Null
        });
    }
}Code-Sprache: JavaScript (javascript)

In diesem Beispiel testen wir, ob die Division durch Null eine ArithmeticException auslöst. Die assertThrows-Methode erwartet den erwarteten Ausnahmetyp und den Lambda-Ausdruck, der den Code enthält, der die Ausnahme auslöst.

Testlebenszyklus in JUnit 5

JUnit 5 definiert einen klaren Lebenszyklus für Tests, der aus verschiedenen Phasen besteht:

  1. @BeforeAll: Diese Methode wird einmal vor dem Start aller Tests in einer Klasse ausgeführt.
  2. @BeforeEach: Diese Methode wird vor jeder Testmethode in einer Klasse ausgeführt.
  3. @Test: Dies ist die eigentliche Testmethode, die den Code für die Überprüfung enthält.
  4. @AfterEach: Diese Methode wird nach jeder Testmethode in einer Klasse ausgeführt.
  5. @AfterAll: Diese Methode wird einmal nach dem Abschluss aller Tests in einer Klasse ausgeführt.

Sie können diese Annotationen verwenden, um bestimmte Aktionen vor oder nach Ihren Tests auszuführen, z. B. das Initialisieren von Ressourcen oder das Aufräumen nach den Tests.

Test-Tagging und -Filtering

JUnit 5 bietet die Möglichkeit, Tests mit Tags zu versehen und diese Tags zu verwenden, um Tests auszuwählen oder auszuschließen. Dies ist besonders nützlich, wenn Sie Tests in verschiedenen Kategorien organisieren oder bestimmte Tests in verschiedenen Umgebungen ausführen möchten.

Hier ist ein Beispiel für das Tagging von Tests:

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Tag;
import static org.junit.jupiter.api.Assertions.*;

@Tag("integration")
public class Integrationstests {

    @Test
    public void testIntegrationTest1() {
        // Testcode für Integrationstest 1
    }

    @Test
    public void testIntegrationTest2() {
        // Testcode für Integrationstest 2
    }
}Code-Sprache: JavaScript (javascript)

Sie können dann JUnit 5-Filter verwenden, um Tests basierend auf Tags auszuwählen oder auszuschließen.

Zusammenfassung und Best Practices

Unit-Testing ist eine entscheidende Praxis in der Softwareentwicklung, um die Qualität und Zuverlässigkeit Ihres Codes sicherzustellen. JUnit 5 ist ein leistungsfähiges Framework, das die Erstellung und Ausführung von Unit-Tests in Java erleichtert.

Hier sind einige bewährte Praktiken für das Unit-Testing mit JUnit 5:

  • Schreiben Sie Tests frühzeitig: Beginnen Sie bereits während der Entwicklung damit, Tests zu schreiben, um frühzeitig Fehler zu erkennen.
  • Halten Sie Tests unabhängig: Stellen Sie sicher, dass Tests unabhängig voneinander ausgeführt werden können, ohne auf den Zustand anderer Tests zu angewiesen zu sein.
  • Nutzen Sie parameterisierte Tests: Verwenden Sie parameterisierte Tests, um denselben Testfall mit verschiedenen Eingabewerten auszuführen.
  • Überprüfen Sie Ausnahmen: Testen Sie, ob Ihre Methoden die erwarteten Ausnahmen auslösen.
  • Verwenden Sie Tags und Filtering: Verwenden Sie Tags, um Tests zu organisieren und Filter zu erstellen, um Tests auszuwählen oder auszuschließen.

Mit JUnit 5 und diesen bewährten Praktiken können Sie sicherstellen, dass Ihr Java-Code fehlerfrei und zuverlässig ist und somit die Qualität Ihrer Software verbessern.