Kaedah verify() dalam Mockito digunakan untuk mengesahkan bahawa interaksi khusus dengan objek yang diejek telah berlaku. Ini amat berguna dalam ujian apabila anda ingin memastikan bahawa kaedah tertentu dipanggil dengan hujah tertentu semasa pelaksanaan kod anda.

Di bawah ialah contoh aplikasi Spring Boot dengan lapisan perkhidmatan dan pengawal, dengan kaedah pengesahan() digunakan dalam ujian.

Buat Projek Spring Boot Starter dengan Spring Web Dependency dan laksanakan contoh di bawah

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>

Aplikasi Spring Boot
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);
    }
}

Ujian JUnit dengan 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);
    }
}

Penjelasan

Mengejek dengan @Mock:

Perkhidmatan Pekerja diejek, bermakna tingkah lakunya boleh dikawal tanpa bergantung pada pelaksanaan sebenar.

Menyuntik Olok-olok dengan @InjectMocks:

EmployeeController menggunakan EmployeeService yang dipermainkan.

cara sahkan():

Mengesahkan bahawa kaedah saveEmployee() EmployeeService yang dipermainkan telah dipanggil tepat sekali dengan objek Pekerja yang ditentukan.

Memastikan kaedah itu digunakan sekali. Pilihan lain seperti never() atau atLeastOnce() boleh digunakan untuk keperluan pengesahan yang berbeza.

Mengapa verify() Berguna?

Memastikan Interaksi yang Dijangkakan: Mengesahkan logik yang diuji berinteraksi dengan komponen bergantung seperti yang dimaksudkan.

Menghalang Overcalls: Memastikan kaedah tidak dipanggil lebih daripada yang diperlukan, yang boleh menyerlahkan logik berlebihan atau tidak diingini.

Ujian Boleh Dibaca: Menyampaikan dengan jelas interaksi yang dijangkakan antara komponen.

Output untuk Ujian

Jika kaedah saveEmployee() dipanggil sekali, ujian akan lulus. Jika tidak, ia akan gagal dengan ralat penegasan, menunjukkan bahawa interaksi yang dijangkakan tidak berlaku.

Atas ialah kandungan terperinci kaedah pengesahan () dalam contoh Mockito. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!