Erste Schritte mit JUnit 5 und Mockito für Unit-Tests

1 min read

Wenn du programmierst, willst du sicher sein, dass dein Code richtig funktioniert. Genau dabei helfen dir Unit-Tests. Ein Unit-Test prüft eine kleine Einheit deines Programms, z. B. eine Methode.

In diesem Artikel lernst du:

was Unit-Tests sind,
wie du mit JUnit 5 Tests schreibst,
und wie du mit Mockito Abhängigkeiten „faken“ kannst.

1. Was ist ein Unit-Test?

Stell dir vor, du hast eine Methode add(a, b), die zwei Zahlen addiert. Ein Unit-Test ruft die Methode mit bestimmten Werten auf und prüft, ob das Ergebnis stimmt.

2. Projekt vorbereiten

Damit du loslegen kannst, brauchst du JUnit 5 und Mockito in deinem Projekt. Wenn du Maven benutzt, füge in deine pom.xml folgendes ein:

<dependencies>
    <!-- JUnit 5 -->
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter</artifactId>
      <version>5.13.4</version>
      <scope>test</scope>
    </dependency>

    <!-- Mockito -->
    <dependency>
      <groupId>org.mockito</groupId>
      <artifactId>mockito-core</artifactId>
      <version>5.19.0</version>
      <scope>test</scope>
  </dependency>
</dependencies>

3. Erster Test mit JUnit 5

Nehmen wir eine kleine Klasse, die einfach zwei Zahlen addiert:

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

Jetzt schreiben wir einen Test:

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

class CalculatorTest {

    @Test
    void shouldAddTwoNumbers() {
        Calculator calculator = new Calculator();
        int result = calculator.add(2, 3);

        assertEquals(5, result);
    }
}

👉 Erklärung:

@Test sagt: Das ist ein Test.
assertEquals(5, result) prüft, ob das Ergebnis wirklich 5 ist.

4. Mockito: Abhängigkeiten testen

Oft rufen Klassen andere Klassen auf. Beispiel: Ein UserService fragt ein UserRepository nach Daten. Das Repository wollen wir im Test aber nicht wirklich an eine Datenbank anschließen. Hier hilft Mockito.

public class UserService {
    private final UserRepository repository;

    public UserService(UserRepository repository) {
        this.repository = repository;
    }

    public String getUserName(int id) {
        return repository.findNameById(id);
    }
}

public interface UserRepository {
    String findNameById(int id);
}

Jetzt der Test mit Mockito:

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.*;

class UserServiceTest {

    @Test
    void shouldReturnUserNameFromRepository() {
        // Mock (Fake) Repository bauen
        UserRepository repository = Mockito.mock(UserRepository.class);
        when(repository.findNameById(1)).thenReturn("Alice");

        // Service mit Fake-Repository testen
        UserService service = new UserService(repository);
        String name = service.getUserName(1);

        assertEquals("Alice", name);
    }
}

👉 Erklärung:

Mockito.mock(...) baut ein Fake-Objekt.
when(...).thenReturn(...) sagt, wie sich das Fake-Objekt verhalten soll.

5. Fazit

JUnit 5: zum Schreiben von Tests.
Mockito: zum „Faken“ von Abhängigkeiten.
So kannst du deine Klassen isoliert testen, ohne z. B. echte Datenbanken oder Web-Services.

#webdevelopment#java#springboot