Méthode verify() dans l'exemple Mockito

La méthode verify() dans Mockito est utilisée pour confirmer que des interactions spécifiques avec des objets simulés se sont produites. Ceci est particulièrement utile lors des tests lorsque vous souhaitez vous assurer qu'une certaine méthode a été appelée avec des arguments spécifiques lors de l'exécution de votre code.

Vous trouverez ci-dessous un exemple d'application Spring Boot avec une couche de service et de contrôleur, où la méthode verify() est utilisée dans un test.

Créez un projet Spring Boot Starter avec Spring Web Dependency et exécutez l'exemple ci-dessous

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>3.4.1</version>
  <relativePath/> <!-- lookup parent from repository -->
 </parent>
 <groupId>com.example</groupId>
 <artifactId>VerifySpringBootExample</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <name>VerifySpringBootExample</name>
 <description>Demo project for Spring Boot</description>
 <url/>
 <licenses>
  <license/>
 </licenses>
 <developers>
  <developer/>
 </developers>
 <scm>
  <connection/>
  <developerConnection/>
  <tag/>
  <url/>
 </scm>
 <properties>
  <java.version>17</java.version>
 </properties>
 <dependencies>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
  </dependency>

  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
  </dependency>
 </dependencies>

 <build>
  <plugins>
   <plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
   </plugin>
  </plugins>
 </build>

</project>

Application Spring Boot
Employé.java

package com.example.demo.model;

public class Employee {
    private String id;
    private String name;

    // Constructor, Getters, and Setters
    public Employee(String id, String name) {
        this.id = id;
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

EmployeeService.java

package com.example.demo.service;

import com.example.demo.model.Employee;
import org.springframework.stereotype.Service;

@Service
public class EmployeeService {
    public void saveEmployee(Employee employee) {
        // Business logic to save the employee (e.g., in a database)
        System.out.println("Employee saved: " + employee.getName());
    }
}

EmployeeController.java

package com.example.demo.controller;

import com.example.demo.model.Employee;
import com.example.demo.service.EmployeeService;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class EmployeeController {
    private final EmployeeService employeeService;

    public EmployeeController(EmployeeService employeeService) {
        this.employeeService = employeeService;
    }

    @PostMapping("/employees")
    public void saveEmployee(@RequestBody Employee employee) {
        employeeService.saveEmployee(employee);
    }
}

Test JUnit avec Mockito
EmployeeControllerTest.java

package com.example.demo.controller;

import com.example.demo.model.Employee;
import com.example.demo.service.EmployeeService;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import static org.mockito.Mockito.*;

class EmployeeControllerTest {

    @Mock
    private EmployeeService employeeService;

    @InjectMocks
    private EmployeeController employeeController;

    public EmployeeControllerTest() {
        MockitoAnnotations.openMocks(this); // Initialize mocks
    }

    @Test
    void testSaveEmployee() {
        // Arrange
        Employee employee = new Employee("1", "John Doe");

        // Act
        employeeController.saveEmployee(employee);

        // Assert
        // Verify that the saveEmployee method was called once with the correct argument
        verify(employeeService, times(1)).saveEmployee(employee);
    }
}

Explication

Se moquer avec @Mock :

Le EmployeeService est simulé, ce qui signifie que son comportement peut être contrôlé sans dépendre de l'implémentation réelle.

Injecter des Mocks avec @InjectMocks :

Le EmployeeController utilise le EmployeeService simulé.

Méthode verify() :

Confirme que la méthode saveEmployee() du EmployeeService simulé a été appelée exactement une fois avec l'objet Employee spécifié.

Garantit que la méthode a été invoquée une fois. D'autres options comme never() ou atLeastOnce() peuvent être utilisées pour différents besoins de vérification.

Pourquoi verify() est-il utile ?

Garantit les interactions attendues : confirme que la logique testée interagit avec les composants dépendants comme prévu.

Empêche les surappels : garantit que les méthodes ne sont pas appelées plus de fois que nécessaire, ce qui peut mettre en évidence une logique redondante ou indésirable.

Tests lisibles : communique clairement les interactions attendues entre les composants.

Sortie pour le test

Si la méthode saveEmployee() est appelée une fois, le test réussira. Sinon, il échouera avec une erreur d'assertion, montrant que l'interaction attendue ne s'est pas produite.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!