I just announced the new Spring Boot 2 material, coming in REST With Spring:

>> CHECK OUT THE COURSE

1. Overview

In this tutorial, we’ll illustrate how to make the most out of spies in Mockito.

We will talk about the @Spy annotation, how to stub a spy and, finally – we will go into the difference between Mock and Spy.

And of course, for more Mockito goodness, have a look at the series here.

Further reading:

Mockito Verify Cookbook

Mockito Verify examples, usage and best practices.

Read more

Injecting Mockito Mocks into Spring Beans

This article will show how to use dependency injection to insert Mockito mocks into Spring Beans for unit testing.

Read more

Mockito’s Mock Methods

This tutorial illustrates various uses of the standard static mock methods of the Mockito API.

Read more

2. 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 you would with a mock.

OK, 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");

    assertEquals(2, spyList.size());
}

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

3. The @Spy Annotation

Next – let’s see how to use the @Spy annotation. We can use @Spy annotation instead of spy() as in the following example:

@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");

    assertEquals(2, spyList.size());
}

In order to enable Mockito annotation (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)

4. 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.

In the following example – we 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();
    assertEquals(100, spyList.size());
}

5. Mock vs. Spy in Mockito

Finally – let’s discuss the difference between Mock and Spy in Mockito – not 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 an 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.

In the following example – we 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");

    assertEquals(0, mockedList.size());
}

As you can see – adding an element into the mocked list doesn’t actually add anything – it just calls the method with no other side-effect.

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");

    assertEquals(1, spyList.size());
}

6. Conclusion

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

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

The implementation of all 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.

And of course, for more Mockito goodness, have a look at the series here.

I just announced the new Spring Boot 2 material, coming in REST With Spring:

>> CHECK OUT THE LESSONS

newest oldest most voted
Notify of
beahhc
Guest
beahhc

Thanks very much for this article! I just searched all the internet for an article like this, simple and easy to understand!

Eugen Paraschiv
Guest

Cool beans, glad you like it. Cheers,
Eugen.

Alexandre Gama
Guest

Great article! Simple and intuitive.

Actually you can update it using MockitoJUnitRunner instead MockitoJUnit4Runner that is deprecated.

I think this call is not necessary to work: MockitoAnnotations.initMocks(this)

Thanks Eugen!

Eugen Paraschiv
Guest

Hey Alex,
First off – thanks for the feedback.
I was looking for where the MockitoJUnit4Runner is used by I can’t seem to find it.
Also – the initMocks calls isn’t necessary if you’re using the runner, but if you’re not – then the call is required.
Hope that helps. Cheers,
Eugen.

jagnya datta Panigrahi
Guest
jagnya datta Panigrahi

Really Nice article .

Thanks Eugen.

rahul sharma
Guest
rahul sharma

Awesome !!! Explained in very easy language.

sudoz
Guest

Good examples to explain differences between spy() and mock()