doNothing()method example Spring Boot

When to Use doNothing()?

When testing void methods that perform side effects (e.g., sending emails, logging, updating databases).

When you want to verify that a void method was called without actually executing it.

Spring Boot Example Using doNothing()

Employee.java (Model Class)

package com.example.demo.model;

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

    public Employee(String id, String name) {
        this.id = id;
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

EmployeeRepository.java (Simulating Database Calls)

package com.example.demo.repository;

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

import java.util.HashMap;
import java.util.Map;

@Repository
public class EmployeeRepository {
    private final Map<String, Employee> employeeData = new HashMap<>();

    public void save(Employee employee) {
        System.out.println("Saving employee to database: " + employee.getName());
        employeeData.put(employee.getId(), employee);
    }
}

EmployeeService.java (Business Logic)

package com.example.demo.service;

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

@Service
public class EmployeeService {
    private final EmployeeRepository employeeRepository;

    public EmployeeService(EmployeeRepository employeeRepository) {
        this.employeeRepository = employeeRepository;
    }

    public void addEmployee(Employee employee) {
        employeeRepository.save(employee); // Void method that interacts with DB
    }
}

Writing a Test Using doNothing()

Scenario:
We don’t want save() to actually modify data in the repository during the test. Instead, we mock it using doNothing().

package com.example.demo.service;

import com.example.demo.model.Employee;
import com.example.demo.repository.EmployeeRepository;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;

import static org.mockito.Mockito.*;

@ExtendWith(MockitoExtension.class)
class EmployeeServiceTest {

    @Mock
    private EmployeeRepository employeeRepository; // Mock repository

    @InjectMocks
    private EmployeeService employeeService; // Inject mocks into service

    @Test
    void testAddEmployee_DoNothing() {
        // Arrange
        Employee employee = new Employee("1", "Mock Employee");

        // Stub the void method to do nothing
        doNothing().when(employeeRepository).save(employee);

        // Act
        employeeService.addEmployee(employee);

        // Assert: Verify the method was called once but didn’t execute
        verify(employeeRepository, times(1)).save(employee);
    }
}

Explanation of doNothing()

Why doNothing()?

Since save() is a void method, when().thenReturn() won’t work.

doNothing().when(employeeRepository).save(employee) prevents actual execution.

Why verify()?

Ensures save(employee) was actually called once, without executing its logic.

When to Use doNothing()?

Mocking void methods to prevent unwanted side effects.

Avoiding actual database writes or external API calls.

Testing only method calls and execution flow.

Conclusion

Use doNothing() to mock void methods that should not execute real logic.

Combine it with verify() to ensure method invocation.

Helps isolate business logic from dependencies during testing.