Real method on mocked object is always called

Problem 1: Unwanted Invocation of Real Methods One common issue with Mockito is the unintentional invocation of real methods when using the mock() method. This can lead to unexpected behavior or even errors in test cases. Consider the following scenario:

public class Example {
    public String getValue() {
        return "Real Value";
    }
}

public class TestExample {
    @Test
    public void testGetValue() {
        Example example = mock(Example.class);
        String value = example.getValue();
        assertEquals("Mocked Value", value); // This assertion fails
    }
}

public class TestExample {
    @Test
    public void testGetValue() {
        Example example = mock(Example.class);
        when(example.getValue()).thenReturn("Mocked Value");

        String value = example.getValue();
        assertEquals("Mocked Value", value); // This assertion passes
    }
}

By using when().thenReturn(), you instruct Mockito to return the specified value when the getValue() method is called on the mock object. This ensures that the desired behavior is correctly mocked, avoiding any unwanted invocation of real methods.

Problem 2: Stubbing Void Methods Mockito provides ways to stub method calls and define their return values. However, stubbing void methods poses a challenge since they don’t have a return value. Consider the following scenario:

public class Example {
    public void performAction() {
        // Perform some action
    }
}

public class TestExample {
    @Test
    public void testPerformAction() {
        Example example = mock(Example.class);
        when(example.performAction()).thenReturn(); // This line causes a compilation error
    }
}

In this case, stubbing the performAction() void method using when().thenReturn() results in a compilation error.

Solution: To address this problem, Mockito provides the doNothing() method that can be used to stub void methods. Here’s an updated solution:

public class TestExample {
    @Test
    public void testPerformAction() {
        Example example = mock(Example.class);
        doNothing().when(example).performAction();

        example.performAction(); // No compilation error
        // Additional assertions or verifications can be performed
    }
}

Using doNothing().when() allows you to stub the void method without specifying a return value. This ensures that the method is correctly stubbed, and you can continue with additional assertions or verifications as needed.

Problem 3: Verification Failure with Argument Matchers Another common issue with Mockito arises when verifying method invocations that use argument matchers. Argument matchers, such as any(), are used to match any value of a specific type. However, improper use of argument matchers can lead to verification failures. Consider the following example:

public class Example {
    public void performAction(String value) {
        // Perform some action
    }
}

public class TestExample {
    @Test
    public void testPerformAction() {
        Example example = mock(Example.class);
        example.performAction("Test");

        verify(example).performAction(any(String.class)); // This verification fails
    }
}

Solution: To resolve this issue, you need to ensure proper usage of argument matchers when verifying method invocations. Mockito provides a set of matcher methods that should be used consistently. Here’s an updated solution:

public class TestExample {
    @Test
    public void testPerformAction() {
        Example example = mock(Example.class);
        example.performAction("Test");

        verify(example).performAction(eq("Test")); // Use 'eq()' to match specific values
    }
}

In the updated solution, the eq() matcher is used instead of any(). The eq() matcher matches the exact value provided as an argument, ensuring the verification passes only when the expected value is encountered.

By using the appropriate argument matchers and ensuring consistency in their usage, you can avoid verification failures and accurately validate method invocations.