verify() method in Mockito example

The verify() method in Mockito is used to confirm that specific interactions with mocked objects occurred. This is particularly useful in testing when you want to ensure that a certain method was called with specific arguments during the execution of your code.

Below is an example of a Spring Boot application with a service and controller layer, where the verify() method is used in a test.

Create Spring Boot Starter Project with Spring Web Dependency and execute the below example

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></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></url>
 <licenses>
  <license></license>
 </licenses>
 <developers>
  <developer></developer>
 </developers>
 <scm>
  <connection></connection>
  <developerconnection></developerconnection>
  <tag></tag>
  <url></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 Application
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 with 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);
    }
}

Explanation

Mocking with @Mock:

The EmployeeService is mocked, meaning its behavior can be controlled without relying on the actual implementation.

Injecting Mocks with @InjectMocks:

The EmployeeController uses the mocked EmployeeService.

verify() Method:

Confirms that the saveEmployee() method of the mocked EmployeeService was called exactly once with the specified Employee object.

Ensures that the method was invoked once. Other options like never() or atLeastOnce() can be used for different verification needs.

Why is verify() Useful?

Ensures Expected Interactions: Confirms the tested logic interacts with dependent components as intended.

Prevents Overcalls: Ensures methods are not called more times than necessary, which can highlight redundant or unwanted logic.

Readable Tests: Clearly communicates the expected interactions between components.

Output for the Test

If the method saveEmployee() is called once, the test will pass. Otherwise, it will fail with an assertion error, showing that the expected interaction didn't occur.

The above is the detailed content of verify() method in Mockito example. For more information, please follow other related articles on the PHP Chinese website!