Mockito – Using Spies

Credits: by Eugen Paraschiv https://www.baeldung.com/mockito-spy

Simple Spy Example

Let’s start with a simple example of how to use a spy.

Simply put, the API is Mockito.spy() to spy on a real object.

This will allow us to call all the normal methods of the object while still tracking every interaction, just as we would with a mock.

Now let’s do a quick example where we’ll spy on an existing ArrayList object:

@Test
public void whenSpyingOnList_thenCorrect() {
    List<String> list = new ArrayList<String>();
    List<String> spyList = Mockito.spy(list);

    spyList.add("one");
    spyList.add("two");

    Mockito.verify(spyList).add("one");
    Mockito.verify(spyList).add("two");

    assertThat(spyList).hasSize(2);
}Copy

Note how the real method add() is actually called and how the size of spyList becomes 2.

The @Spy Annotation

Next, let’s see how to use the @Spy annotation. We can use the @Spy annotation instead of spy():

@Spy
List<String> spyList = new ArrayList<String>();

@Test
public void whenUsingTheSpyAnnotation_thenObjectIsSpied() {
    spyList.add("one");
    spyList.add("two");

    Mockito.verify(spyList).add("one");
    Mockito.verify(spyList).add("two");

    assertThat(aSpyList).hasSize(2);
}Copy

To enable Mockito annotations (such as @Spy, @Mock, … ), we need to do one of the following:

• Call the method MockitoAnnotations.initMocks(this) to initialize annotated fields
• Use the built-in runner @RunWith(MockitoJUnitRunner.class)

Stubbing a Spy

Now let’s see how to stub a Spy. We can configure/override the behavior of a method using the same syntax we would use with a mock.

Here we’ll use doReturn() to override the size() method:

@Test
public void whenStubASpy_thenStubbed() {
    List<String> list = new ArrayList<String>();
    List<String> spyList = Mockito.spy(list);

    assertEquals(0, spyList.size());

    Mockito.doReturn(100).when(spyList).size();
    assertThat(spyList).hasSize(100);
}Copy

 Mock vs Spy in Mockito 

Let’s discuss the difference between Mock and Spy in Mockito. We won’t examine the theoretical differences between the two concepts, just how they differ within Mockito itself.

When Mockito creates a mock, it does so from the Class of a Type, not from an actual instance. The mock simply creates a bare-bones shell instance of the Class, entirely instrumented to track interactions with it.

On the other hand, the spy will wrap an existing instance. It will still behave in the same way as the normal instance; the only difference is that it will also be instrumented to track all the interactions with it.

Here we’ll create a mock of the ArrayList class:

@Test
public void whenCreateMock_thenCreated() {
    List mockedList = Mockito.mock(ArrayList.class);

    mockedList.add("one");
    Mockito.verify(mockedList).add("one");

    assertThat(mockedList).hasSize(0);
}Copy

As we can see, adding an element into the mocked list doesn’t actually add anything; it just calls the method with no other side effects.

A spy, on the other hand, will behave differently; it will actually call the real implementation of the add method and add the element to the underlying list:

@Test
public void whenCreateSpy_thenCreate() {
    List spyList = Mockito.spy(new ArrayList());

    spyList.add("one");
    Mockito.verify(spyList).add("one");

    assertThat(spyList).hasSize(1);
}Copy

Understanding the Mockito NotAMockException

In this final section, we’ll learn about the Mockito NotAMockException. This exception is one of the common exceptions we will likely encounter when misusing mocks or spies.

Let’s start by understanding the circumstances in which this exception can occur:

List<String> list = new ArrayList<String>();
Mockito.doReturn(100).when(list).size();Copy

When we run this code snippet, we’ll get the following error:

org.mockito.exceptions.misusing.NotAMockException: 
Argument passed to when() is not a mock!
Example of correct stubbing:
    doThrow(new RuntimeException()).when(mock).someMethod();
Copy

Thankfully, it is quite clear from the Mockito error message what the problem is here. In our example, the list object is not a mock. The Mockito when() method expects a mock or spy object as the argument.

As we can also see, the Exception message even describes what a correct invocation should look like. Now that we have a better understanding of what the problem is, let’s fix it by following the recommendation:

final List<String> spyList = Mockito.spy(new ArrayList<>());
assertThatNoException().isThrownBy(() -> Mockito.doReturn(100).when(spyList).size());Copy

Our example now behaves as expected, and we no longer see the Mockito NotAMockException.

Conclusion

In this brief article, we discussed the most useful examples of using Mockito spies.

We learned how to create a spy, use the @Spy annotation, stub a spy, and finally, the difference between Mock and Spy.

The implementation of all of these examples can be found over on GitHub.

This is a Maven project, so it should be easy to import and run as it is.

Finally, for more Mockito goodness, have a look at the series here.