Test d'unité du module de gestion d'étudiants | JUnit 5 & Mockito

Introduction

Dans ce projet, vous allez apprendre à créer des tests unitaires pour un module de gestion d'étudiants à l'aide de JUnit 5 et Mockito. Le projet comprend deux tâches principales : créer des tests pour la classe StudentServiceImpl et créer des tests pour la classe StudentController.

🎯 Tâches

Dans ce projet, vous allez apprendre :

Comment créer un fichier ServiceTests.java pour tester la classe StudentServiceImpl à l'aide de JUnit 5
Comment créer un fichier ControllerTests.java pour tester la classe StudentController à l'aide de JUnit 5 et Mockito
Comment utiliser les fonctionnalités de test de Spring Boot, telles que @SpringBootTest et @MockBean, pour charger les composants nécessaires et créer des doubles pour les tests
Comment écrire des cas de test pour vérifier le fonctionnement des méthodes queryStudents(), insertStudent() et deleteStudent() dans la classe StudentServiceImpl
Comment écrire des cas de test pour vérifier le fonctionnement des méthodes getStudents(), getStudent() et modifyStudent() dans la classe StudentController

🏆 Réalisations

Après avoir terminé ce projet, vous serez capable de :

Configurer les tests unitaires pour une application Spring Boot à l'aide de JUnit 5 et Mockito
Utiliser les fonctionnalités de test de Spring Boot pour charger les composants nécessaires et créer des doubles pour les tests
Écrire des cas de test efficaces pour vous assurer de la correction des implémentations des couches de service et de contrôleur
Utiliser des assertions pour vérifier le comportement attendu des méthodes testées

Créer le fichier ServiceTests.java

Dans cette étape, vous allez apprendre à créer le fichier ServiceTests.java pour tester la classe StudentServiceImpl à l'aide de JUnit 5.

Ouvrez votre IDE et accédez au répertoire /test/java/org/labex/springboottesting de votre projet.
Créez un nouveau fichier Java nommé ServiceTests.java.
Dans le fichier ServiceTests.java, ajoutez le code suivant :

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() {
        // Teste la méthode queryStudents() du service pour s'assurer du bon retrait des données.
        List<Student> result = service.queryStudents();

        // Vérifie que la taille de la liste renvoyée correspond à la taille attendue.
        assertEquals(3, result.size());
    }

    @Test
    void testInsertStudent() {
        // Crée un objet étudiant d'échantillonnage pour l'insérer.
        Student student = new Student("1", "test", 18, "male");

        // Teste la méthode insertStudent() du service pour s'assurer de l'insertion réussie.
        Boolean result = service.insertStudent(student);

        // Vérifie que l'opération d'insertion a réussi.
        assertTrue(result);
    }

    @Test
    void testDeleteStudent() {
        // Teste la méthode deleteStudent() du service pour s'assurer de la suppression réussie.
        Boolean result = service.deleteStudent("20191001");

        // Vérifie que l'opération de suppression a réussi.
        assertTrue(result);
    }
}

La classe ServiceTests est annotée avec @SpringBootTest(classes = StudentServiceImpl.class) pour charger la classe d'implémentation StudentServiceImpl dans la classe de test. La classe contient trois méthodes de test :

testQueryStudents() : Teste la méthode queryStudents() de l'interface IStudentService pour s'assurer que la liste d'étudiants renvoyée a la taille attendue.
testInsertStudent() : Teste la méthode insertStudent() de l'interface IStudentService pour s'assurer que l'opération d'insertion d'étudiant est réussie.
testDeleteStudent() : Teste la méthode deleteStudent() de l'interface IStudentService pour s'assurer que l'opération de suppression d'étudiant est réussie.

Créer le fichier ControllerTests.java

Dans cette étape, vous allez apprendre à créer le fichier ControllerTests.java pour tester la classe StudentController à l'aide du framework de test Mockito.

Ouvrez votre IDE et accédez au répertoire /test/java/org/labex/springboottesting de votre projet.
Créez un nouveau fichier Java nommé ControllerTests.java.
Dans le fichier ControllerTests.java, ajoutez le code suivant :

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 // Charge le contexte d'application Spring Boot.
@EnableWebMvc // Active les fonctionnalités Spring Web MVC.
@AutoConfigureMockMvc // Configure l'instance MockMvc.
class ControllerTests {

    @Autowired
    private MockMvc mockMvc; // Injecte l'instance MockMvc pour simuler des requêtes HTTP.

    private ObjectMapper objectMapper; // ObjectMapper pour la conversion JSON.

    @MockBean // Annotation MockBean pour créer un mock de IStudentDAO.
    private IStudentDAO studentDAO;

    @BeforeEach
    void setUp() {
        // Initialise ObjectMapper pour convertir des objets en JSON et vice versa.
        this.objectMapper = new ObjectMapper();
    }

    @Test
    void testGetStudents() throws Exception {
        // Crée des étudiants d'échantillonnage.
        Student s1 = new Student("20191001", "John", 18, "Male");
        Student s2 = new Student("20191069", "Lily", 19, "Female");

        // Crée une liste d'étudiants et ajoute les étudiants d'échantillonnage à la liste.
        ArrayList<Student> list = new ArrayList<>();
        list.add(s1);
        list.add(s2);

        // Simule le comportement de studentDAO pour renvoyer la liste d'étudiants lorsqu'on appelle findStudentAll().
        when(studentDAO.findStudentAll()).thenReturn(list);

        // Effectue une requête GET pour récupérer tous les étudiants et valide la réponse.
        this.mockMvc.perform(get("/api/v2/students")
                       .accept("application/json; charset=UTF-8")) // Définit l'en-tête accept pour spécifier le type de réponse attendu.
               .andDo(print()) // Affiche les détails de la requête et de la réponse.
               .andExpect(status().isOk()) // Vérifie que le statut de la réponse est OK (200).
               .andReturn(); // Retourne l'objet MvcResult pour des assertions supplémentaires.
    }

    @Test
    void testGetStudent() throws Exception {
        // Crée un étudiant d'échantillonnage.
        Student s1 = new Student("20191001", "John", 18, "Male");

        // Simule le comportement de studentDAO pour renvoyer l'étudiant d'échantillonnage lorsqu'on appelle findStudentById() avec "20191001".
        when(studentDAO.findStudentById("20191001")).thenReturn(s1);

        // Effectue une requête GET pour récupérer un étudiant spécifique par son ID et valide la réponse.
        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 {
        // Crée un étudiant d'échantillonnage.
        Student s1 = new Student("20191001", "John", 18, "Male");

        // Convertit l'étudiant d'échantillonnage au format JSON.
        String content = objectMapper.writeValueAsString(s1);

        // Simule le comportement de studentDAO pour renvoyer true lorsqu'on appelle updateStudent() avec n'importe quel objet étudiant.
        when(studentDAO.updateStudent(any())).thenReturn(true);

        // Effectue une requête PUT pour modifier un étudiant et valide la réponse.
        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();
    }
}

La classe ControllerTests est annotée avec @SpringBootTest pour charger le contexte d'application Spring Boot, @EnableWebMvc pour activer les fonctionnalités Spring Web MVC et @AutoConfigureMockMvc pour configurer l'instance MockMvc. La classe contient trois méthodes de test :

testGetStudents() : Teste la méthode getStudents() de la classe StudentController en simulant le comportement de l'interface IStudentDAO et en effectuant une requête GET sur l'endpoint /api/v2/students.
testGetStudent() : Teste la méthode getStudent() de la classe StudentController en simulant le comportement de l'interface IStudentDAO et en effectuant une requête GET sur l'endpoint /api/v2/student/20191001.
testModifyStudent() : Teste la méthode modifyStudent() de la classe StudentController en simulant le comportement de l'interface IStudentDAO, en convertissant un objet étudiant d'échantillonnage au format JSON et en effectuant une requête PUT sur l'endpoint /api/v2/student.

Exécuter les tests

Maintenant que vous avez créé les fichiers ServiceTests.java et ControllerTests.java, vous pouvez exécuter les tests pour vérifier le fonctionnement des classes StudentServiceImpl et StudentController.

Ouvrez un terminal ou une invite de commande et accédez au répertoire de votre projet en utilisant la commande suivante :

cd ~/project/springboottesting/

Exécutez la commande suivante pour exécuter la classe ServiceTests :

mvn test -Dtest=ServiceTests

Cela exécutera les trois méthodes de test dans la classe ServiceTests et affichera les résultats.

Exécutez la commande suivante pour exécuter la classe ControllerTests :

mvn test -Dtest=ControllerTests

Cela exécutera les trois méthodes de test dans la classe ControllerTests et affichera les résultats.

Vous devriez voir les résultats des tests, y compris les tests réussis ou échoués, dans la sortie de la console.

Résumé

Félicitations ! Vous avez terminé ce projet. Vous pouvez pratiquer d'autres laboratoires sur LabEx pour améliorer vos compétences.