The any() method in Mockito is used as a matcher to specify that any value of a given type can be passed to a mocked method.

1️⃣ When to Use any()?

When you don’t care about the exact argument value and just need to verify that the method was called.

When dealing with dynamically generated values, such as randomly generated IDs, timestamps, or user input.

2️⃣ Spring Boot Example Using any()

Scenario:

We have an EmployeeService that adds an employee using an EmployeeRepository. Instead of checking for a specific Employee object, we use any(Employee.class) to verify the method was called.

📌 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;

@Repository
public class EmployeeRepository {
    public void save(Employee employee) {
        System.out.println("Saving employee: " + employee.getName());
    }
}

📌 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);
    }
}

3️⃣ Writing a Test Using any()
✅ Scenario:

We mock EmployeeRepository so that its save() method is not actually executed.

We verify that save() was called, but without checking the exact Employee object.

We use any(Employee.class) to match any Employee instance.

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_UsingAnyMatcher() {
        // Arrange
        Employee employee = new Employee("1", "Mock Employee");

        // Stub the void method
        doNothing().when(employeeRepository).save(any(Employee.class));

        // Act
        employeeService.addEmployee(employee);

        // Assert: Verify the save() method was called, but ignore exact argument
        verify(employeeRepository, times(1)).save(any(Employee.class));
    }
}

✅ Conclusion

Use any() when the exact argument doesn’t matter.
Helps mock dynamic values that are not predictable.
Combine with verify() to confirm method calls.

any() method in Mockito Spring Boot example