5 Reasons Why Your Mockito Verify Wasn`t Called (Plus Realistic Code Examples)

Table of content

1. Introduction
2. Reason 1: Incorrect Method Call
3. Reason 2: Wrong Argument Values
4. Reason 3: Missing Verification Statement
5. Reason 4: Wrong Verification Mode
6. Reason 5: Incorrect Object Mocking
7. Realistic Code Examples
8. Conclusion

Introduction

Mockito is a popular mocking framework used by developers to facilitate unit testing in Java. Its Verify function is a powerful tool for ensuring that certain method calls have been made on an object during testing. However, there are times when you might find that your Mockito Verify wasn't called, even though you expected it to be. This can be frustrating, but there are several reasons why it might happen.

In this article, we'll explore five common reasons why your Mockito Verify might not have been called during testing. We'll provide realistic code examples to guide you through each scenario, and explain the underlying concepts in clear, accessible language. By the end of the article, you'll have a better understanding of how Mockito works, and how to troubleshoot any issues you encounter while using it. Whether you're a seasoned developer or just starting out in unit testing, this article is sure to be a valuable resource for your projects.

Reason 1: Incorrect Method Call

One of the most common reasons why your Mockito verify wasn't called is due to an incorrect method call. This can happen if you misspell the method name or call the wrong method altogether. One way to prevent this is to use an IDE (Integrated Development Environment) that provides auto-completion, which can help you identify the correct method name and parameters.

Another way to avoid this issue is to carefully review your code for any potential errors before running your tests. It's also important to have a clear understanding of the methods you're calling and their parameters. If you're unsure about a method call, consult the documentation or seek help from a more experienced programmer.

Here's an example of an incorrect method call:

assertEquals(expected, actual);

In this case, we're using the method assertEquals instead of verify, which is the method we want to call to check if a certain method was called. To fix this issue, we need to change the method call to:

verify(mockObject).methodName();

Here, mockObject is the object we're testing and methodName is the method we're checking was called. By ensuring that we're using the correct method call, we can avoid issues with Mockito verify not being called.

Reason 2: Wrong Argument Values

The second reason why your Mockito verify may have not been called is due to incorrect argument values. This refers to the situation where the method was called, but the arguments passed in do not match the expected values.

To mitigate this issue, check the specific argument value used for the verification. If it does not match the actual value used in the method invocation, then the verify method will fail.

For instance, the example code below demonstrates how incorrect argument values can prevent Mockito verify from being called.

#Implementation code
def get_name(id: int):
    if id == 1:
        return "Alice"
    elif id == 2:
        return "Bob"
    else:
        return "Unknown name"
    
#Unit test code
def test_get_name():
    mocked = mock.MagicMock()
    mocked.get_name(1)
    mocked.get_name(2)
    
    verify(mocked).get_name(1)
    verify(mocked).get_name(3)

In this example, the implementation code has a method get_name that returns the name of an individual based on their ID. The unit test code verifies whether the method is called with the expected argument value.

However, in the verify method, the argument 3 is passed in, which does not match any expected values based on the implementation code. As a result, the test fails, and the Mockito verify method is not executed.

To resolve this issue, ensure that the argument values used in the mock method match the expected values used in the implementation code.

Reason 3: Missing Verification Statement

One common reason why Mockito verify wasn't called is missing a verification statement. The verification statement is what tells Mockito which method call to verify after the test has run. Without the verification statement, Mockito has no way to know which call to verify.

Let's take a look at an example:

# Class to test
class BankAccount:
    def __init__(self, balance):
        self.balance = balance
        
    def deposit(self, amount):
        self.balance += amount
        
    def withdraw(self, amount):
        if amount > self.balance:
            raise ValueError("Insufficient funds")
        self.balance -= amount

# Test
def test_withdraw():
    account = BankAccount(100)
    account.withdraw(50)
    verify(account).withdraw(50)

This test checks that the withdraw method was called with the argument 50. However, the verify method is missing the target of the verification, which should be Mockito in this case.

The correct syntax for this test is:

verify(account, times=1).withdraw(50)

This tells Mockito to verify that the withdraw method was called on account exactly once with the argument 50.

In summary, missing a verification statement can cause Mockito verify to not be called. Be sure to include the correct syntax for the verification statement, including the target (the object being tested) and the expected call to that object's method.

Reason 4: Wrong Verification Mode

Another potential reason why your Mockito verify wasn't called is that you may be using the wrong verification mode. Mockito provides different verification modes that allow you to specify how many times a method should be called. If you use an incorrect verification mode, verify won't be called as expected.

The default mode is to verify that a method is called exactly once, so if you want to verify a different number of invocations, you need to specify the mode explicitly. Here are some common verification modes:

• times(int n): verifies that a method is called exactly n times
• atLeast(int n): verifies that a method is called at least n times
• atMost(int n): verifies that a method is called at most n times
• never(): verifies that a method is never called
• only(): verifies that a method is called exactly once

Let's take a look at an example:

List<String> mockedList = mock(List.class);
mockedList.add("foo");
mockedList.add("bar");
mockedList.add("baz");

verify(mockedList).add("foo");
verify(mockedList, times(2)).add(anyString());
verify(mockedList, never()).add("qux");

Here, we're verifying that the add method was called once with the argument "foo", and twice with any string argument. We're also verifying that the add method was never called with the argument "qux". Note how we're using the times and never verification modes explicitly, to ensure that the verification is performed correctly.

If you find that your Mockito verify isn't being called, double-check that you're using the correct verification mode for your use case. If you're unsure which mode to use, check the Mockito documentation or ask for help from more experienced developers.

Reason 5: Incorrect Object Mocking

When you mock an object during testing, it's important that you mock the correct object. If you mock a different object, your verify will not be called, leading to false negative results.

Here's an example:

//Correct Object Mocking
when(mockedList.add("item")).thenReturn(true);

//Incorrect Object Mocking
when(mockedList2.add("item")).thenReturn(true);

In the correct example, we're mocking the correct object mockedList.add("item"). In the incorrect example, we're mocking a different object mockedList2.add("item") which will not be called during the test, leading to verify not being called.

Ensure that you're mocking the correct object in your test to avoid this issue.

Realistic Code Examples

:

Let's take a look at some that can help you identify why your Mockito verify wasn't called.

1. Verify a Method Was Called Once:

@Test
public void testMethodWasCalledOnce() {
    MyClass myClassMock = mock(MyClass.class);
    myClassMock.methodCall();

    verify(myClassMock, times(1)).methodCall();
}

In this example, we create a mock for the MyClass class and call a method on it. We then use the verify() method to check if the methodCall() method was called once on the mock object.

2. Check That a Method Was Called With Specific Arguments:

@Test
public void testMethodWasCalledWithSpecificArguments() {
    MyClass myClassMock = mock(MyClass.class);
    int arg1 = 5;
    String arg2 = "test";
    myClassMock.methodCall(arg1, arg2);

    verify(myClassMock).methodCall(eq(arg1), eq(arg2));
}

In this example, we create a mock object of the MyClass class and pass it two arguments. We then use the verify() method to check if methodCall() method was called with these specific arguments. We use the eq() method to compare the arguments.

3. Verify Multiple Method Calls in a Particular Order:

@Test
public void testMultipleMethodCallsInSpecificOrder() {
    MyClass myClassMock = mock(MyClass.class);
    myClassMock.methodCall1();
    myClassMock.methodCall2();

    InOrder inOrder = inOrder(myClassMock);
    inOrder.verify(myClassMock).methodCall1();
    inOrder.verify(myClassMock).methodCall2();
}

In this example, we create a mock object of the MyClass class and call two methods on it. We then use the InOrder object to verify that the methods were called in a specific order. The inOrder() method takes the mock object as an argument.

4. Verify That a Method Was Not Called:

@Test
public void testMethodWasNotCalled() {
    MyClass myClassMock = mock(MyClass.class);
    verifyZeroInteractions(myClassMock);
}

In this example, we create a mock object of the MyClass class but do not call any methods on it. We then use the verifyZeroInteractions() method to check if any methods were called on the mock object.

5. Verify That a Mock Object Was Not Touched:

@Test
public void testMockObjectWasNotTouched() {
    MyClass myClassMock = mock(MyClass.class);

    verifyNoMoreInteractions(myClassMock);
}

In this example, we create a mock object of the MyClass class but do not call any methods on it. We then use the verifyNoMoreInteractions() method to check if any methods were called on the mock object.

Conclusion

In , Mockito verify is a powerful tool for ensuring that method calls are made during your tests. However, there are several reasons why your verify might not have been called, ranging from syntax errors to incorrect test setup. By following the steps outlined in this article, you should be able to troubleshoot your verify issues and get your tests running smoothly.

Remember to check that you have the correct method name and parameters in your verify statement, and that the method is actually called in the code you are testing. Make sure to create any necessary mocks or stubs, and to set up your test environment properly.

By using the tips and techniques in this article, you can improve the accuracy and reliability of your unit tests, leading to more robust and error-free code. Start experimenting with Mockito verify today, and see how much it can improve your testing process.