Master Mockito Verify: Ensure Proper Method Calls in Your Java Tests

Want to write more robust and reliable Java tests? Mockito verify() is your key tool. This guide provides practical examples and insights to help you use Mockito verify effectively, confirm expected behaviors, and catch unexpected interactions in your tests.

Why Use Mockito verify() in Your Java Tests?

• Confirm Expected Behavior: Ensure specific methods on your mocked objects are called during the test.
• Early Bug Detection: Identify discrepancies between the expected and actual interactions with your mocks, preventing issues from slipping into production.
• Improved Test Readability: Clearly define and communicate the intended behavior of your system under test.

Mockito verify(): The Basics

The verify() method ensures that a specific method on a mock object was called during the test.

@Test
void test() {
  List mockList = mock(List.class);
  mockList.add("Pankaj");

  verify(mockList).add("Pankaj"); // Verifies add("Pankaj") was called
}

This example verifies that the add("Pankaj") method was called exactly once on mockList. Let's learn how to test number of method invocations in the next section.

Counting Method Invocations Using Mockito

Mockito lets you specify the number of times a method should be invoked:

• times(n): Exactly n times
• atLeastOnce(): At least once
• atMost(n): At most n times
• atLeast(n): At least n times
• never(): Never called

verify(mockList, times(1)).size();   // Called exactly once
verify(mockList, atLeastOnce()).size(); // Called at least once
verify(mockList, atMost(2)).size();    // Called at most twice
verify(mockList, never()).clear();     // Never called

These options provide fine-grained control over verifying invocation counts.

Argument Matching with Mockito verify()

Often, you need to verify a method call with a flexible argument. Use ArgumentMatchers for this:

import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.any;

verify(mockList).add(anyString());    // Any String argument
verify(mockList).add(any(String.class)); // Also matches any String

ArgumentMatchers make your verifications more adaptable. Use mockito verify with ArgumentMatchers to avoid hardcoding specific input values.

Ensuring All Interactions Are Verified

Mockito provides verifyNoMoreInteractions() to guarantee that all interactions with a mock are explicitly verified.

mockList.add("Pankaj");
verify(mockList).add("Pankaj");
verifyNoMoreInteractions(mockList); // No unverified interactions

Using verifyNoMoreInteractions() will cause a test to fail if there are unverified method calls on the mock.

Mockito also offers verifyZeroInteractions(), which confirms that no methods at all were called on the mock.

Mockito Verify Order: Enforcing Method Call Sequence

The InOrder class allows you to verify that method calls occurred in a specific order.

List mockList = mock(List.class);
Map mockMap = mock(Map.class);

mockList.add("Pankaj");
mockList.size();
mockList.isEmpty();
mockMap.isEmpty();

InOrder inOrder = inOrder(mockList, mockMap);
inOrder.verify(mockList).add("Pankaj");
inOrder.verify(mockList).size();
inOrder.verify(mockList).isEmpty();
inOrder.verify(mockMap).isEmpty();

This ensures the methods were called in the exact sequence specified. Order verification is crucial for tests where sequence matters. It also ensures that mockito inOrder is correctly used.

Only Verify One Method Call with Mockito

Use only() to verify that exactly one method was called on a mock.

Map mockMap = mock(Map.class);
mockMap.isEmpty();
verify(mockMap, only()).isEmpty();

This asserts that isEmpty() was the only method invoked on mockMap.

Real-World Example: Verifying Service Calls

Let's say you have a UserService that relies on a UserDao to retrieve user data.

class UserService {
    private UserDao userDao;

    public UserService(UserDao userDao) {
        this.userDao = userDao;
    }

    public User getUser(int id) {
        return userDao.getUserById(id);
    }
}

interface UserDao {
    User getUserById(int id);
}

class User {
  private int id;
  public User(int id){
    this.id = id;
  }
}

Here's how you can test UserService with Mockito verify():

@Test
void testGetUser() {
    UserDao mockDao = mock(UserDao.class);
    UserService userService = new UserService(mockDao);
    User expectedUser = new User(123);

    when(mockDao.getUserById(123)).thenReturn(expectedUser);

    User actualUser = userService.getUser(123);

    assertEquals(expectedUser, actualUser);
    verify(mockDao).getUserById(123); // Verify the DAO method call
}

This test ensures that the getUserById() method is called on the UserDao with the correct ID.

Conclusion: Mockito Verify Best Practices

• Focus on Behavior: Use verify() to confirm that your code behaves as intended by interacting with its dependencies correctly.
• Write Focused Tests: Avoid over-specifying interactions. Verify only what is essential for the test.
• Readability Matters: Arrange your verify() calls clearly, making it easy to understand the expected interactions.

By mastering Mockito verify(), you'll write cleaner, more effective unit tests, leading to more robust and maintainable Java code.