Die Methode ?Verify()“ in Mockito wird verwendet, um zu best?tigen, dass bestimmte Interaktionen mit simulierten Objekten stattgefunden haben. Dies ist besonders nützlich beim Testen, wenn Sie sicherstellen m?chten, dass eine bestimmte Methode w?hrend der Ausführung Ihres Codes mit bestimmten Argumenten aufgerufen wurde.

Unten ist ein Beispiel einer Spring Boot-Anwendung mit einer Service- und Controller-Schicht, bei der die Methode ?Verify()“ in einem Test verwendet wird.

Erstellen Sie ein Spring Boot Starter-Projekt mit Spring Web-Abh?ngigkeit und führen Sie das folgende Beispiel aus

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>

Spring Boot-Anwendung
Employee.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);
    }
}

JUnit-Test mit 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);
    }
}

Erkl?rung

Verspotten mit @Mock:

Der EmployeeService wird verspottet, was bedeutet, dass sein Verhalten gesteuert werden kann, ohne auf die tats?chliche Implementierung angewiesen zu sein.

Mocks mit @InjectMocks injizieren:

Der EmployeeController verwendet den simulierten EmployeeService.

verify() Methode:

Best?tigt, dass die saveEmployee()-Methode des simulierten EmployeeService genau einmal mit dem angegebenen Employee-Objekt aufgerufen wurde.

Stellt sicher, dass die Methode einmal aufgerufen wurde. Andere Optionen wie never() oder atLeastOnce() k?nnen für unterschiedliche Verifizierungsanforderungen verwendet werden.

Warum ist verify() nützlich?

Stellt erwartete Interaktionen sicher: Best?tigt, dass die getestete Logik wie beabsichtigt mit abh?ngigen Komponenten interagiert.

Verhindert überaufrufe: Stellt sicher, dass Methoden nicht ?fter als n?tig aufgerufen werden, was auf redundante oder unerwünschte Logik hinweisen kann.

Lesbare Tests: Kommuniziert klar die erwarteten Wechselwirkungen zwischen Komponenten.

Ausgabe für den Test

Wenn die Methode saveEmployee() einmal aufgerufen wird, ist der Test bestanden. Andernfalls schl?gt der Vorgang mit einem Assertionsfehler fehl und zeigt an, dass die erwartete Interaktion nicht stattgefunden hat.

Das obige ist der detaillierte Inhalt vonMethode ?Verify()' im Mockito-Beispiel. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!