Unit-Tests für das Studentenverwaltung-Modul | JUnit 5 & Mockito

Einführung

In diesem Projekt lernst du, wie du mit JUnit 5 und Mockito Unit-Tests für ein Studentenverwaltungsmodul erstellen kannst. Das Projekt umfasst zwei Hauptaufgaben: das Erstellen von Tests für die StudentServiceImpl-Klasse und das Erstellen von Tests für die StudentController-Klasse.

🎯 Aufgaben

In diesem Projekt wirst du lernen:

Wie du eine ServiceTests.java-Datei erstellst, um die StudentServiceImpl-Klasse mit JUnit 5 zu testen
Wie du eine ControllerTests.java-Datei erstellst, um die StudentController-Klasse mit JUnit 5 und Mockito zu testen
Wie du Spring Boot-Testfunktionen wie @SpringBootTest und @MockBean verwendest, um die erforderlichen Komponenten zu laden und Mocks für den Test zu erstellen
Wie du Testfälle schreibst, um die Funktionalität der queryStudents(), insertStudent() und deleteStudent()-Methoden in der StudentServiceImpl-Klasse zu überprüfen
Wie du Testfälle schreibst, um die Funktionalität der getStudents(), getStudent() und modifyStudent()-Methoden in der StudentController-Klasse zu überprüfen

🏆 Errungenschaften

Nach Abschluss dieses Projekts wirst du in der Lage sein:

Die Unit-Tests für eine Spring Boot-Anwendung mit JUnit 5 und Mockito einzurichten
Spring Boot-Testfunktionen verwenden, um die erforderlichen Komponenten zu laden und Mocks für den Test zu erstellen
Effektive Testfälle schreiben, um die Korrektheit der Implementierungen der Service- und Controller-Schicht sicherzustellen
Assertions verwenden, um das erwartete Verhalten der getesteten Methoden zu überprüfen

Erstellen der ServiceTests.java-Datei

In diesem Schritt lernst du, wie du die ServiceTests.java-Datei erstellst, um die StudentServiceImpl-Klasse mit JUnit 5 zu testen.

Öffne deine IDE und navigiere zum Verzeichnis /test/java/org/labex/springboottesting in deinem Projekt.
Erstelle eine neue Java-Datei mit dem Namen ServiceTests.java.
Füge im ServiceTests.java-Datei folgenden Code hinzu:

package org.labex.springboottesting;

import org.junit.jupiter.api.Test;
import org.labex.springboottesting.service.StudentServiceImpl;
import org.labex.springboottesting.entity.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;

@SpringBootTest(classes = StudentServiceImpl.class)
class ServiceTests {

    @Autowired
    private StudentServiceImpl service;

    @Test
    void testQueryStudents() {
        // Testen der queryStudents()-Methode des Diensts, um die korrekte Datenabrufung sicherzustellen.
        List<Student> result = service.queryStudents();

        // Überprüfen, dass die Größe der zurückgegebenen Liste der erwarteten Größe entspricht.
        assertEquals(3, result.size());
    }

    @Test
    void testInsertStudent() {
        // Erstellen eines Beispiel-Studentenobjekts zum Einfügen.
        Student student = new Student("1", "test", 18, "male");

        // Testen der insertStudent()-Methode des Diensts, um das erfolgreiche Einfügen sicherzustellen.
        Boolean result = service.insertStudent(student);

        // Überprüfen, dass die Einfügeoperation erfolgreich war.
        assertTrue(result);
    }

    @Test
    void testDeleteStudent() {
        // Testen der deleteStudent()-Methode des Diensts, um das erfolgreiche Löschen sicherzustellen.
        Boolean result = service.deleteStudent("20191001");

        // Überprüfen, dass die Löschoperation erfolgreich war.
        assertTrue(result);
    }
}

Die ServiceTests-Klasse ist mit @SpringBootTest(classes = StudentServiceImpl.class) annotiert, um die StudentServiceImpl-Implementierungs-Klasse in der Testklasse zu laden. Die Klasse enthält drei Testmethoden:

testQueryStudents(): Testet die queryStudents()-Methode der IStudentService-Schnittstelle, um sicherzustellen, dass die zurückgegebene Liste von Studenten die erwartete Größe hat.
testInsertStudent(): Testet die insertStudent()-Methode der IStudentService-Schnittstelle, um sicherzustellen, dass die Studenteneinfügeoperation erfolgreich ist.
testDeleteStudent(): Testet die deleteStudent()-Methode der IStudentService-Schnittstelle, um sicherzustellen, dass die Studentenlöschoperation erfolgreich ist.

Erstellen der ControllerTests.java-Datei

In diesem Schritt lernst du, wie du die ControllerTests.java-Datei erstellst, um die StudentController-Klasse mit dem Mockito-Testframework zu testen.

Öffne deine IDE und navigiere zum Verzeichnis /test/java/org/labex/springboottesting in deinem Projekt.
Erstelle eine neue Java-Datei mit dem Namen ControllerTests.java.
Füge im ControllerTests.java-Datei folgenden Code hinzu:

package org.labex.springboottesting;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.labex.springboottesting.dao.IStudentDAO;
import org.labex.springboottesting.entity.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;

import java.util.ArrayList;

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest // Lädt den Spring Boot-Anwendungscontext.
@EnableWebMvc // Aktiviert die Spring Web MVC-Funktionalitäten.
@AutoConfigureMockMvc // Konfiguriert die MockMvc-Instanz.
class ControllerTests {

    @Autowired
    private MockMvc mockMvc; // Autowired die MockMvc-Instanz zum Simulieren von HTTP-Anfragen.

    private ObjectMapper objectMapper; // ObjectMapper zur JSON-Konvertierung.

    @MockBean // MockBean-Annotation, um einen Mock für IStudentDAO zu erstellen.
    private IStudentDAO studentDAO;

    @BeforeEach
    void setUp() {
        // Initialisiert ObjectMapper, um Objekte in JSON und umgekehrt zu konvertieren.
        this.objectMapper = new ObjectMapper();
    }

    @Test
    void testGetStudents() throws Exception {
        // Erstellen von Beispielstudenten.
        Student s1 = new Student("20191001", "John", 18, "Male");
        Student s2 = new Student("20191069", "Lily", 19, "Female");

        // Erstellen einer Liste von Studenten und Hinzufügen von Beispielstudenten dazu.
        ArrayList<Student> list = new ArrayList<>();
        list.add(s1);
        list.add(s2);

        // Mocken des Verhaltens von studentDAO, um die Liste von Studenten zurückzugeben, wenn findStudentAll() aufgerufen wird.
        when(studentDAO.findStudentAll()).thenReturn(list);

        // Ausführen einer GET-Anfrage, um alle Studenten abzurufen und die Antwort zu validieren.
        this.mockMvc.perform(get("/api/v2/students")
                       .accept("application/json; charset=UTF-8")) // Legt den Accept-Header fest, um den erwarteten Antworttyp anzugeben.
               .andDo(print()) // Druckt Anfrage- und Antwortdetails.
               .andExpect(status().isOk()) // Überprüft, dass der Antwortstatus OK (200) ist.
               .andReturn(); // Gibt das MvcResult-Objekt zurück, um weitere Assertions durchzuführen.
    }

    @Test
    void testGetStudent() throws Exception {
        // Erstellen eines Beispielstudenten.
        Student s1 = new Student("20191001", "John", 18, "Male");

        // Mocken des Verhaltens von studentDAO, um den Beispielstudenten zurückzugeben, wenn findStudentById() mit "20191001" aufgerufen wird.
        when(studentDAO.findStudentById("20191001")).thenReturn(s1);

        // Ausführen einer GET-Anfrage, um einen bestimmten Studenten nach ID abzurufen und die Antwort zu validieren.
        this.mockMvc.perform(get("/api/v2/student/20191001")
                       .accept("application/json; charset=UTF-8"))
               .andDo(print())
               .andExpect(status().isOk())
               .andReturn();
    }

    @Test
    void testModifyStudent() throws Exception {
        // Erstellen eines Beispielstudenten.
        Student s1 = new Student("20191001", "John", 18, "Male");

        // Konvertieren des Beispielstudenten in JSON-Format.
        String content = objectMapper.writeValueAsString(s1);

        // Mocken des Verhaltens von studentDAO, um true zurückzugeben, wenn updateStudent() mit einem beliebigen Studentenobjekt aufgerufen wird.
        when(studentDAO.updateStudent(any())).thenReturn(true);

        // Ausführen einer PUT-Anfrage, um einen Studenten zu modifizieren und die Antwort zu validieren.
        this.mockMvc.perform(put("/api/v2/student")
                       .content(content)
                       .contentType(MediaType.APPLICATION_JSON)
                       .accept("application/json; charset=UTF-8"))
               .andDo(print())
               .andExpect(status().isOk())
               .andReturn();
    }
}

Die ControllerTests-Klasse ist mit @SpringBootTest annotiert, um den Spring Boot-Anwendungscontext zu laden, @EnableWebMvc annotiert, um die Spring Web MVC-Funktionalitäten zu aktivieren und @AutoConfigureMockMvc annotiert, um die MockMvc-Instanz zu konfigurieren. Die Klasse enthält drei Testmethoden:

testGetStudents(): Testet die getStudents()-Methode der StudentController-Klasse, indem das Verhalten der IStudentDAO-Schnittstelle gemockt wird und eine GET-Anfrage an den Endpunkt /api/v2/students ausgeführt wird.
testGetStudent(): Testet die getStudent()-Methode der StudentController-Klasse, indem das Verhalten der IStudentDAO-Schnittstelle gemockt wird und eine GET-Anfrage an den Endpunkt /api/v2/student/20191001 ausgeführt wird.
testModifyStudent(): Testet die modifyStudent()-Methode der StudentController-Klasse, indem das Verhalten der IStudentDAO-Schnittstelle gemockt wird, ein Beispielstudentenobjekt in JSON konvertiert wird und eine PUT-Anfrage an den Endpunkt /api/v2/student ausgeführt wird.

Führe die Tests aus

Jetzt, nachdem Sie die ServiceTests.java- und ControllerTests.java-Dateien erstellt haben, können Sie die Tests ausführen, um die Funktionalität der StudentServiceImpl- und StudentController-Klassen zu überprüfen.

Öffnen Sie ein Terminal oder eine Eingabeaufforderung und navigieren Sie mit dem folgenden Befehl zum Projektverzeichnis:

cd ~/project/springboottesting/

Führen Sie den folgenden Befehl aus, um die ServiceTests-Klasse auszuführen:

mvn test -Dtest=ServiceTests

Dies führt die drei Testmethoden in der ServiceTests-Klasse aus und zeigt die Ergebnisse an.

Führen Sie den folgenden Befehl aus, um die ControllerTests-Klasse auszuführen:

mvn test -Dtest=ControllerTests

Dies führt die drei Testmethoden in der ControllerTests-Klasse aus und zeigt die Ergebnisse an.

Sie sollten die Testergebnisse, einschließlich aller bestanden oder fehlgeschlagenen Tests, in der Konsolenausgabe sehen.

Zusammenfassung

Herzlichen Glückwunsch! Sie haben dieses Projekt abgeschlossen. Sie können in LabEx weitere Übungen absolvieren, um Ihre Fähigkeiten zu verbessern.

Studentenverwaltung-Modul: Unit-Tests