Testing Changes in Arguments for void Methods with Mockito

Learn how to effectively test changes in arguments supplied to `void` methods using Mockito's `ArgumentCaptor`. This guide provides clear steps and examples to resolve common testing issues.
---

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Mockito to test change in variables inside void methods

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Testing Changes in Arguments for void Methods with Mockito

When working with Java and Mockito, you may encounter situations where you need to verify that a void method has modified the arguments you passed to it. This can be particularly challenging when dealing with collections, such as lists, where changes might not be immediately visible or easy to verify. In this post, we will explore a practical example of how to test changes in arguments supplied to void methods using Mockito's ArgumentCaptor.

The Problem: Testing Argument Changes

In your code, you have a method isAuthExpired that modifies a list of errors if a certain condition is met. After invoking this method, you want to verify that an error has been added to the list. However, you might find that capturing these changes is not straightforward, leading to confusion during testing.

Here’s the relevant part of your testing code:

[[See Video to Reveal this Text or Code Snippet]]

In this snippet, you notice that the params list is null after calling the isAuthExpired method, which indicates that no errors were captured. This is likely due to the way the method is invoked and how you are attempting to capture the changes.

The Solution: Using Mockito to Verify Argument Changes

To correctly test that the list has been modified by the isAuthExpired method, follow these steps:

1. Mock the Dependencies

First, instead of using a real list, you will create a mock for your list of errors. This allows you to set expectations and verify interactions.

[[See Video to Reveal this Text or Code Snippet]]

2. Invoke the Method with Mocked Arguments

Next, call the isAuthExpired method while passing a mocked PaymentMethod and the mocked list:

[[See Video to Reveal this Text or Code Snippet]]

3. Capture Added Arguments

Once the method has been executed, you can use ArgumentCaptor to capture the arguments that were added to the mocked list. Ensure that you verify the interaction with your mocked list to capture the argument:

[[See Video to Reveal this Text or Code Snippet]]

4. Assert and Verify

Finally, you can assert and verify that the expected changes occurred. Check that the error object you expect has been added to the list:

[[See Video to Reveal this Text or Code Snippet]]

Conclusion

By following these steps, you can effectively use Mockito to verify that changes made to arguments in void methods are captured correctly. Remember to use mocks for collections or objects you expect to change without relying on real implementations, as they provide a clearer interface for testing interactions.

Mockito’s syntactic sugar allows developers to focus less on boilerplate testing code and more on asserting the behavior of their applications. With this approach, you can confidently test your methods that have side effects and ensure your application behaves as expected.

Next time you face challenges testing void methods, remember these principles and enhance your testing strategies!