Mocks & Spies

Mocks & Spies

We all know how JUnit is important for making sure that our code is doing what it is supposed to be doing. Mocks are integral part of JUnit. When you test a class you usually want to isolate that class from the rest of the world and concentrate on that class. To do that you need to use Mocks. Mocks let you mimic the components that your tested class deals with, without really needing to make sure they are really there. You can ‘teach’ a mock to act in ways you need and by doing so test your class to make sure it actually doing the right stuff based on the input data and the mocks behavior.

There are a few Mock frameworks in Java. In this post I will describe the way to work with PowerMock. PowerMock lets you work with mocks and spies.

Mock

When we deal with mocks, we can either mock an instance for its non-static public/protected/private methods or mock the static methods of a class.

Mocking an instance

Mocks are created when you need to completely replace an instance.

Guidelines:

1.     There’s no instance of the mocked class, rather there is an instance of a proxy mock that represents it.

2.     The mock can mock a concrete class or an interface.

3.     When a method that is not mocked is called:

a.  If the called method returns a value, then the returned value will be the return type’s default value.

b.  In case of a ‘void’ method nothing is done.

4.     To mock a method you should do the following
The preferred syntax is:

a.   To mock a method with a return value: PowerMockito.doReturn(value).when(mock).method(arguments);

b.   To mock a void method

PowerMockito.doNothing().when(mock).method(arguments);

Example:

Spy

Spying (partial mock) after an instance  

Spy is created when you need to have a ‘partial mock’. That means when you have a real instance and you need to call at least one of its real methods and to mock other(s).

1.     A Spy, unlike mock, works on a real instance.

2.     By default a method that is called will activate the real method.

3.     To mock a method you must do the following:

a.   To mock a method with a return value: PowerMockito.doReturn(value).when(spy).method(arguments);

b.   To mock a void method

PowerMockito.doNothing().when(spy).method(arguments);

Note that you first need to declare the return value and then the method, otherwise the method will be activated.

Spy: Mocking Private Methods

Mocking private methods is done a bit differently and for that we need to do the following:

1.     Add the PrepareForTest annotation with the class/classes that we need to mock their private method(s), for example:

2.     Use the following syntax, for example:

Note, you will need to add ‘throws Exception’ to your test declaration.

3.   Verification

Example 1: 
Verify that the method “privateMethod” was called for ‘spy’

Example 2: 
Verify that the method “privateMethodOther” was never called for ‘spy’

Mock: Mocking Static Methods

Mocking private methods is done a bit differently and for that we need to do the following:

1.     Add the PrepareForTest annotation with the class/classes that we need to mock their static methods, for example:

2.     Use the following syntax, for example:

Note, when you need to mock static methods, you are mocking ALL the static methods of the class.

3.     Mocking a static method:

4.     Verification, you can only check that static methods were called once like that:

Note that verification on static methods is usually not needed.

Spy: Mocking Static Methods

Mocking private methods is done a bit differently and for that we need to do the following:

Add the PrepareForTest annotation with the class/classes that we need to mock their static methods, for example:

      Use the following syntax, for example:

Note, when you need to mock static methods, you are mocking ALL the static methods of the class.

3   Mocking a static method:

     Calls to a non-mocked static method will activate that method.

     Verification, you can only check that static methods were called once like that:

Note that verification on static methods is usually not needed.

Examples

Suppose we have the following ‘TestedClass’ that we wish to test. The class has public and private methods (static and non-static):

 

Test declaration

Mock- Mocking a public non-static method

By default the mock would return null since that is the default value for the returned type ‘String’. We override that by ‘teaching’ the mock to return ‘testPublic’:

Mock - Mocking a private non-static method

Mock - Mocking a public static method

Spy – mocking a public non-static method

Note:

1.   The spy works on a real instance of ‘TestedClass’.

2.   You need to declare the ‘doReturn’ first, otherwise the real method ‘publicMethod’ will be activated.

3.   When a non-mocked method is called (‘publicMethodOther’) the real method is invoked.

Spy – Mocking a private non-static method

Note

1.   The syntax is the same for mocks and spies.

2.   The syntax that is using the method’s name.

3.   The test might throw exception.

Spy – Mocking static methods

We spy over the class ‘TestedClass’ since we want to mock only ‘testPublicStatic’ but not the other static method ‘publicStaticMethod1’:

Spy – mocking private static method

In this case we have a spy, ‘spy’, that spies on an instance of ‘TestedClass’ and we also spy on the static methods of ‘TestedClass’.  We use spy for the static methods since we want only to mock the private static method ‘privateStaticMethod’ while other static methods should behave as usual.

Spy – combination

A spy, mock on all static methods and mocking a private method of the spy: