JUnit 5 Basics

JUnit 5 ist die neueste Version des beliebten Testing-Frameworks für Java. Es bietet eine Vielzahl von Funktionen, die dir helfen, deine Anwendungen zu testen. Um dir als Anfänger die wichtigsten 20% der Erkenntnisse zu vermitteln, die dir helfen werden, 80% der JUnit 5 Nutzung zu verstehen und anzuwenden, konzentrieren wir uns auf die grundlegenden und häufig benutzten Features.

1. Grundlagen und Installation

JUnit 5 besteht aus drei Hauptkomponenten:

• JUnit Platform: Die Basis zum Starten von Test-Frameworks auf der JVM.
• JUnit Jupiter: Die neue Programmierschnittstelle und Erweiterungsmodell von JUnit 5.
• JUnit Vintage: Ermöglicht die Ausführung von JUnit 3 und JUnit 4 Tests.

Um JUnit 5 in einem Maven-Projekt zu verwenden, fügst du folgende Abhängigkeiten zu deiner pom.xml hinzu:

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-engine</artifactId>
    <version>5.10.3</version>
    <scope>test</scope>
</dependency>

Für Gradle-Nutzer:

testImplementation 'org.junit.jupiter:junit-jupiter-engine:5.10.3'

2. Grundlegende Annotations

Hier sind die wichtigsten Annotations, die du kennen solltest:

• @Test: Markiert eine Methode als Testmethode.
• @BeforeEach: Führt eine Methode vor jedem Test aus.
• @AfterEach: Führt eine Methode nach jedem Test aus.
• @BeforeAll: Führt eine Methode einmal vor allen Tests aus (muss statisch sein).
• @AfterAll: Führt eine Methode einmal nach allen Tests aus (muss statisch sein).

Beispiel:

import org.junit.jupiter.api.*;

public class MyFirstJUnit5Tests {

    @BeforeAll
    static void initAll() {
        System.out.println("Before all tests");
    }

    @BeforeEach
    void init() {
        System.out.println("Before each test");
    }

    @Test
    void succeedingTest() {
        Assertions.assertTrue(true);
    }

    @Test
    void failingTest() {
        Assertions.assertTrue(false);
    }

    @AfterEach
    void tearDown() {
        System.out.println("After each test");
    }

    @AfterAll
    static void tearDownAll() {
        System.out.println("After all tests");
    }
}

3. Assertions

Assertions sind entscheidend, um die Ergebnisse der Tests zu überprüfen. Hier sind die wichtigsten Assertions:

• assertEquals(expected, actual): Prüft, ob zwei Werte gleich sind.
• assertNotEquals(expected, actual): Prüft, ob zwei Werte nicht gleich sind.
• assertTrue(condition): Prüft, ob die Bedingung wahr ist.
• assertFalse(condition): Prüft, ob die Bedingung falsch ist.
• assertNull(value): Prüft, ob ein Wert null ist.
• assertNotNull(value): Prüft, ob ein Wert nicht null ist.
• assertThrows(expectedType, executable): Prüft, ob eine bestimmte Ausnahme geworfen wird.

Beispiel:

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

public class AssertionTests {

    @Test
    void testAssertions() {
        Assertions.assertEquals(4, 2 + 2);
        Assertions.assertNotEquals(5, 2 + 2);
        Assertions.assertTrue(3 > 2);
        Assertions.assertFalse(3 < 2);
        Assertions.assertNull(null);
        Assertions.assertNotNull(new Object());
        Assertions.assertThrows(IllegalArgumentException.class, () -> {
            throw new IllegalArgumentException();
        });
    }
}

4. Parameterisierte Tests

JUnit 5 ermöglicht es, Tests mit verschiedenen Parametern auszuführen. Dies ist besonders nützlich, wenn du eine Methode mit verschiedenen Eingaben testen möchtest.

Beispiel:

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

public class ParameterizedTests {

    @ParameterizedTest
    @ValueSource(strings = { "racecar", "radar", "madam" })
    void palindromeTest(String word) {
        Assertions.assertTrue(isPalindrome(word));
    }

    boolean isPalindrome(String word) {
        return word.equals(new StringBuilder(word).reverse().toString());
    }
}

5. Die @DisplayName Annotation

Mit @DisplayName kannst du eine benutzerdefinierte Bezeichnung für deinen Test angeben. Diese wird in den Testberichten angezeigt.

Beispiel:

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

@DisplayName("Test class demonstrating @DisplayName annotation")
public class DisplayNameTests {

    @Test
    @DisplayName("Test for the successful case")
    void successfulTest() {
        Assertions.assertTrue(true);
    }
}

6. Test-Suiten

JUnit 5 erlaubt es dir, Test-Suiten zu erstellen, um mehrere Testklassen zusammenzufassen und sie als Gruppe auszuführen.

Beispiel:

import org.junit.platform.suite.api.IncludeClassNamePatterns;
import org.junit.platform.suite.api.SelectPackages;
import org.junit.platform.suite.api.Suite;

@Suite
@SelectPackages("com.example.tests")
@IncludeClassNamePatterns(".*Test")
public class SuiteTest {}

Zusammenfassung

Hier sind die wichtigsten 20% der Erkenntnisse zusammengefasst, die dir helfen, 80% von JUnit 5 zu verstehen:

1. Installation und Konfiguration: Hinzufügen der notwendigen Abhängigkeiten zu deinem Projekt.
2. Grundlegende Annotations: Kennen und Anwenden von Annotations wie @Test, @BeforeEach, @AfterEach, @BeforeAll und @AfterAll.
3. Assertions: Verwenden von Assertions, um die Ergebnisse deiner Tests zu überprüfen.
4. Parameterisierte Tests: Verwenden von parameterisierten Tests, um Methoden mit unterschiedlichen Eingaben zu testen.
5. @DisplayName: Nutzen der @DisplayName Annotation für benutzerdefinierte Testnamen.
6. Test-Suiten: Erstellen und Ausführen von Test-Suiten für gruppierte Testausführungen.

Mit diesem Wissen solltest du in der Lage sein, JUnit 5 effektiv zu nutzen und eine solide Basis für das Testen deiner Java-Anwendungen zu legen. Viel Erfolg beim Testen! 🚀