JUnit Basics verständlich erklärt

JUnit ist das Standardwerkzeug für automatisierte Tests im Java-Umfeld. Wenn du mit Java arbeitest, wirst du früher oder später nicht daran vorbeikommen. Tests sind kein Selbstzweck und auch kein akademisches Konstrukt, sondern ein Werkzeug, das dir im Alltag hilft, Fehler früh zu erkennen und Änderungen sicher umzusetzen. Gerade bei wachsendem Codebestand ist das entscheidend.

Im Kern geht es bei JUnit darum, Erwartungen an deinen Code klar zu formulieren und automatisch zu überprüfen. Du beschreibst, was eine Methode liefern soll, und JUnit prüft genau das. Schlägt ein Test fehl, weißt du sofort, wo du nachsehen musst. Läuft er durch, hast du zumindest eine gewisse Sicherheit, dass sich dein Code wie geplant verhält.

Was ist ein Unit-Test

Ein Unit-Test testet eine kleine, klar abgegrenzte Einheit deines Codes. In der Regel ist das eine einzelne Methode. Ziel ist nicht, das komplette System zu prüfen, sondern eine konkrete Logik. Je kleiner und fokussierter der Test ist, desto hilfreicher ist er. Du testest also keine Datenbank, kein Netzwerk und keine komplexen Abhängigkeiten, sondern reine Logik.

Ein einfaches Beispiel ist eine Methode, die zwei Zahlen addiert. Das klingt banal, ist aber ideal, um das Prinzip zu verstehen.

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

Diese Methode kannst du mit JUnit testen, indem du erwartest, dass das Ergebnis für bestimmte Eingaben korrekt ist.

JUnit 5 Grundstruktur

Aktuell wird in den meisten Projekten JUnit 5 eingesetzt. Ein Test besteht aus einer normalen Java-Klasse. Diese liegt üblicherweise im Verzeichnis src/test/java und spiegelt die Paketstruktur des produktiven Codes wider.

Ein minimaler Test für den Calculator sieht so aus:

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

class CalculatorTest {

    @Test
    void addiertZweiZahlen() {
        Calculator calculator = new Calculator();
        int result = calculator.add(2, 3);
        assertEquals(5, result);
    }
}

Die Annotation @Test markiert eine Methode als Test. JUnit führt diese Methode automatisch aus. Mit assertEquals vergleichst du das erwartete Ergebnis mit dem tatsächlichen Ergebnis. Stimmen beide nicht überein, schlägt der Test fehl.

Assertions verstehen

Assertions sind das Herzstück eines Tests. Sie formulieren deine Erwartung. JUnit stellt dafür eine ganze Reihe von Methoden bereit. Die wichtigsten wirst du sehr häufig verwenden.

assertEquals prüft Gleichheit. assertTrue und assertFalse prüfen Bedingungen. assertNotNull stellt sicher, dass ein Objekt existiert.

assertTrue(result > 0);
assertNotNull(calculator);

Wichtig ist, dass jede Assertion klar und eindeutig ist. Ein Test sollte im Fehlerfall verständlich zeigen, was schiefgelaufen ist. Mehrere Assertions in einem Test sind möglich, aber du solltest es nicht übertreiben. Wenn zu viele Dinge auf einmal geprüft werden, wird der Test schwerer wartbar.

Arrange, Act, Assert

Eine bewährte Struktur für Tests ist das sogenannte Arrange-Act-Assert-Prinzip. Dabei teilst du den Test gedanklich in drei Abschnitte.

Im Arrange-Teil bereitest du alles vor. Du erzeugst Objekte und setzt den benötigten Zustand. Im Act-Teil führst du die zu testende Aktion aus. Im Assert-Teil überprüfst du das Ergebnis.

@Test
void addiertPositiveZahlen() {
    Calculator calculator = new Calculator();
    int result = calculator.add(4, 6);
    assertEquals(10, result);
}

Auch wenn das Beispiel kurz ist, hilft dir diese Struktur, Tests übersichtlich und lesbar zu halten. Gerade bei komplexerer Logik zahlt sich das aus.

Exceptions testen

Nicht jede Methode liefert ein Ergebnis. Manche Methoden sollen bei ungültigen Eingaben eine Exception werfen. Auch das kannst du gezielt testen.

@Test
void wirftExceptionBeiNull() {
    Calculator calculator = new Calculator();
    assertThrows(IllegalArgumentException.class, () -> {
        calculator.add(1, Integer.parseInt(null));
    });
}

Mit assertThrows prüfst du, ob eine bestimmte Exception geworfen wird. Der Code, der die Exception auslösen soll, wird als Lambda-Ausdruck übergeben. So bleibt der Test klar und präzise.

Tests in der Praxis ausführen

In der Praxis führst du Tests selten manuell aus. In IntelliJ kannst du einzelne Tests, ganze Klassen oder alle Tests eines Projekts starten. Maven integriert JUnit automatisch über das Surefire-Plugin. Beim Bauen des Projekts werden die Tests dann automatisch ausgeführt.

Das ist besonders wichtig, wenn du Änderungen am Code vornimmst. Ein schneller Testlauf zeigt dir sofort, ob bestehende Funktionalität unbeabsichtigt beschädigt wurde. Tests geben dir damit Sicherheit bei Refactorings und Erweiterungen.

Gute Tests schreiben

Ein guter Test ist verständlich, klein und stabil. Er testet genau eine Sache und ist unabhängig von anderen Tests. Vermeide Abhängigkeiten zwischen Tests, da sie sonst in unterschiedlicher Reihenfolge unterschiedliche Ergebnisse liefern können.

Tests sind ebenfalls Code und sollten entsprechend gepflegt werden. Unklare Namen, überladene Testmethoden oder unnötige Komplexität helfen niemandem. Wenn du einen Test nach ein paar Wochen nicht mehr verstehst, ist das ein Warnsignal.

Fazit

JUnit ist kein kompliziertes Werkzeug, sondern ein solides Fundament für sauberen Java-Code. Wenn du früh anfängst, Tests als normalen Bestandteil deiner Arbeit zu sehen, profitierst du langfristig davon. Du bekommst schneller Feedback, findest Fehler früher und kannst Änderungen mit mehr Ruhe durchführen. Tests ersetzen kein Nachdenken, aber sie unterstützen dich dabei, verlässlichen Code zu schreiben.