How do you handle stubbing methods with spies in Mockito

Creating a Spy

To create a spy, you need to call Mockito's `spy()` method and pass it an instance of the object you want to spy on. This instance can be created manually or automatically if you use annotations like `@Spy` in your test class.

java
// Manual creation
List list = new ArrayList();
List spy = Mockito.spy(list);

// Using @Spy annotation
@Spy
List spyList = new ArrayList();

Stubbing Methods on a Spy

When stubbing methods on a spy, it's crucial to use the `doReturn()`, `doThrow()`, or `doAnswer()` methods instead of `thenReturn()` or `when()` alone. This is because `when()` can cause the real method to be called, potentially leading to unwanted side effects or exceptions.

Here's how you can stub a method using `doReturn()`:

java
doReturn("stubbedValue").when(spy).get(0);

This approach ensures that the stubbed method is called without invoking the real method, which might throw an exception if the list is empty.

Why Use `doReturn()` Instead of `thenReturn()`?

Using `thenReturn()` with spies can lead to issues because it requires calling the method on the spy to set up the stubbing. This can cause the real method to be executed, which might not be desirable. For example, if you try to stub a method like `get(0)` on an empty list using `when(spy.get(0)).thenReturn("stubbedValue")`, it will throw an `IndexOutOfBoundsException` because the real `get(0)` method is called during stubbing.

In contrast, `doReturn()` avoids this problem by setting up the stub without calling the real method:

java
// Incorrect way that calls the real method
when(spy.get(0)).thenReturn("stubbedValue"); // Throws IndexOutOfBoundsException

// Correct way using doReturn()
doReturn("stubbedValue").when(spy).get(0); // Does not call the real method

Best Practices

- Use Spies Judiciously: Spies are useful when you need to test a class that has dependencies on other classes but you want to keep most of the original behavior intact. Use them sparingly, as they can make tests harder to understand if overused.
- Track Interactions: One of the benefits of spies is that you can verify interactions with the object, similar to mocks. Use `verify()` to check if methods were called as expected.
- Avoid Over-Stubbing: Only stub methods that are necessary for your test. This helps maintain clarity and ensures that your tests are robust against changes in the underlying code.

By following these guidelines, you can effectively use spies in Mockito to create more flexible and targeted unit tests.