Erstellen Sie Ihrer Schweizer Taschenmesser auf der Java-Test-Stack

Die Codetestierbarkeiten garantieren mehrere hervorragende Punkte in einer effizienten Codegestaltung, wie zum Beispiel Wartbarkeit; sie unterstützen die Dokumentation und erleichtern das Refactoring sowie die Erstellung einer evolutionären Design-/Architektur. Darüber besteht kein Zweifel, aber was ist ein gutes Teststapel, um ein Projekt zu starten? Dieses Video wird die minimale Teststapel erklären, mit der Sie Ihr Projekt in Java beginnen können.

Der erste Punkt, der zu verstehen ist, wenn wir von minimal sprechen, ist, dass es im Teststapel keine Allheilmittel gibt. Irgendwann müssen Abhängigkeiten hinzugefügt oder entfernt werden, insbesondere wenn es um Legacy-Code geht. Angesichts dessen werde ich meinen bevorzugten Teststapel in Java vorstellen, den ich verwende und als Minimum für einen Neustart empfehle:

• JUnit-Jupiter: Die fünfte Version von JUnit bricht die Kompatibilität mit der vorherigen Version; dennoch lohnt es sich, da sie mehrere Funktionen bietet, insbesondere zur Erstellung benutzerdefinierter Erweiterungen.

• Mockito: Ein sehr beliebter Mock-Framework mit Java. Diese Popularität und die große Community ermöglichen mehrere Erweiterungen, wie zum Beispiel mit JUnit-Jupiter.

• AssertJ: Wenn du, wie ich, eine flüssige API liebst, ist AssertJ eine außergewöhnliche Bibliothek für dich.  

Indem man das Maven-Projekt nutzt, kann man Abhängigkeiten dieser Bibliotheken hinzufügen:

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-engine</artifactId>
    <version>${junit.version}</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-params</artifactId>
    <version>${junit.version}</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>${mockito.verson}</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-junit-jupiter</artifactId>
    <version>${mockito.verson}</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.assertj</groupId>
    <artifactId>assertj-core</artifactId>
    <version>${assertj.verson}</version>
    <scope>test</scope>
</dependency>

Angenommen, wir befinden uns in einem Fußball-Meisterschaftskontext, in dem eine Mannschaft elf Spieler haben sollte, deren Namen im gesamten Meisterschaftskalender einzigartig sein müssen. Wir können Tests dafür entwickeln.

Beginnend mit JMockito und Tests, müssen wir den Service testen, bei dem wir prüfen müssen, ob der Name aus der Datenbank existiert, um die Logik durchzuführen. An dieser Stelle benötigen wir es nicht und möchten keinen Integrations-Test erstellen. 

Wir möchten uns auf das Geschäft konzentrieren, daher möchten wir die Datenbank oder das Framework nicht testen, sondern nur meinen Code. Daher werden wir das Repository in zwei Szenarien mocken, wenn der Name existiert und wenn er nicht existiert.

Mit der Integration von Mockito mit JUnit-Jupiter kann man Mocks nur mithilfe von Annotationen injizieren. Der folgende Code zeigt den Test mit JMockito, bei dem wir keine Datenbank benötigen oder uns vom Kerntest des Geschäfts ablenken müssen.

@ExtendWith(MockitoExtension.class)
class ChampionshipServiceTest {

    @Mock
    private ChampionRepository repository;

    @InjectMocks
    private ChampionshipService service;

    @Test
    public void shouldRegister() {
        Mockito.when(repository.existByName("Bahia")).thenReturn(false);
        Team bahia = Team.of("Bahia");
        service.register(bahia);

        Mockito.verify(repository).existByName("Bahia");
    }
    @Test
    @DisplayName("should return an exception when there is a team with a name")
    public void shouldThrownAnExceptionWhenTeamNameExists() {
        Mockito.when(repository.existByName("Bahia")).thenReturn(true);
        Team bahia = Team.of("Bahia");
        Assertions.assertThrows(IllegalArgumentException.class, () ->
                service.register(bahia));

        Mockito.verify(repository).existByName("Bahia");
    }
}

AssertJ vereinfacht die Assertions, dank der fließenden API, die die Bibliothek unterstützt. Sie können Tests für Sammlungen, Karten oder einzelne Instanzen durchführen. Zum Beispiel können wir mit ihr überprüfen, ob ein Spieler einem Team hinzugefügt wurde.

@Test
public void shouldCreatePlayers() {
    Team bahia = Team.of("Bahia");
    bahia.add(Player.of("Neymar", "Santos", 10));
    bahia.add(Player.of("Cristiano Ronaldo", "Lisbon", 10));

    org.assertj.core.api.Assertions.assertThat(bahia.players())
            .hasSize(2)
            .map(Player::name)
            .contains("Neymar", "Cristiano Ronaldo");
}

Schau dir dieses und weitere Informationen in diesem Video an.

Zusammenfassung:

• A minimum test stack to start Java

• Erfahre mehr über JUnit und warum es eine gute Wahl ist

• Erfahre mehr über Mocks, indem du mit JMockito erkundest

• Mache deine Tests schön mit der fließenden API von Assert: AssertJ