Untestable code with Mockito and PowerMock

With the new release of PowerMock 1.3 we've focused a lot on getting the Mockito support up to par with the EasyMock support allowing mocking of e.g. final classes, static methods and new object construction using a Mockito-like syntax. Below you'll find some examples of how to use the Mockito extension API, aka PowerMockito. Hopefully those of you used to Mockito will find PowerMock(ito) simple to use as well.

As always you need to add @RunWith(PowerMockRunner.class) at the class-level of your test in order to bootstrap PowerMock itself. The classes that are normally not mockable needs to be prepared for testability by using the @PrepareForTest annotation.

Example #1 - Static methods

 
public void methodToTest() {
   ..
   final long id = IdGenerator.generateNewId();
   ..
}
 

Let's say that in our test we want to mock the static call to the IdGenerator.generateNewId() and have it return 2 using the Mockito extension API. This can be achieved the following way:

 
@RunWith(PowerMockRunner.class)
// We prepare the IdGenerator for test because the static method is normally not mockable
@PrepareForTest(IdGenerator.class)
public class MyTestClass {
    @Test
    public void demoStaticMethodMocking() throws Exception {
	mockStatic(IdGenerator.class);
       /*
        * Setup the expectation using the standard Mockito syntax,
        * generateNewId() will now return 2 everytime it's invoked
        * in this test.
        */
	when(IdGenerator.generateNewId()).thenReturn(2L);		
 
	new ClassUnderTest().methodToTest();
 
	// Optionally verify that the static method was actually called
	verifyStatic();
	IdGenerator.generateNewId();
    }
}
 

Example #2 - Mock private methods (partial mocking)

Partial mocking of both static and instance methods works in PowerMock regardless if the method or class is final or private. Let's say we'd like to test the "methodToTest" in isolation from the private "methodToMock" method in the example below:

 
public final class PrivatePartialMockingExample {
    public String methodToTest() {
        return methodToMock("input");
    }
 
    private String methodToMock(String input) {
        return "REAL VALUE = " + input;
    }
}
 

To achieve this we can do:

 
@RunWith(PowerMockRunner.class)
@PrepareForTest(PrivatePartialMockingExample.class)
public class PrivatePartialMockingExampleTest {
    @Test
    public void demoPrivateMethodMocking() throws Exception {
	final String expected = "TEST VALUE";
	final String nameOfMethodToMock = "methodToMock";
	final String input = "input";
 
	PrivatePartialMockingExample underTest = spy(new PrivatePartialMockingExample());
 
	/*
	 * Setup the expectation to the private method using the method name
	 */
	when(underTest, nameOfMethodToMock, input).thenReturn(expected);
 
	assertEquals(expected, underTest.methodToTest());
 
	// Optionally verify that the private method was actually called
	verifyPrivate(underTest).invoke(nameOfMethodToMock, input);
    }
}
 

It's also possible to do the same thing without having to specify the method name using an overridden version of when:

 
@RunWith(PowerMockRunner.class)
@PrepareForTest(PrivatePartialMockingExample.class)
public class PrivatePartialMockingExampleTest {
    @Test
    public void demoPrivateMethodMocking() throws Exception {
        final String expected = "TEST VALUE";
        final String input = "input";
 
        /*
         * We get the method to mock by specifying the class where the
         * method is defined as well as its parameter types.
         */
        final Method methodToMock = method(PrivatePartialMockingExample.class, String.class);
 
        PrivatePartialMockingExample underTest = spy(new PrivatePartialMockingExample());
 
	// Notice how we pass the actual method instead of the name
        when(underTest, methodToMock).withArguments(input).thenReturn(expected);
 
        assertEquals(expected, underTest.methodToTest());
 
	// Optionally verify that the private method was actually called
        verifyPrivate(underTest).invoke(methodToMock).withArguments(input);
    }
}
 

This approach allows for more a refactor friendly code since you can change the method name of the private method without having to change your test.

Example #3 - Mock construction of new objects

Sometimes it might be good to mock construction of new objects. Consider the following example:

 
public class DirectoryStructure {
	public boolean create(String directoryPath) {
		File directory = new File(directoryPath);
 
		if (directory.exists()) {
			throw new IllegalArgumentException("\"" + directoryPath + "\" already exists.");
		}
 
		return directory.mkdirs();
	}
}
 

To test the create method in isolation from the file system we'd like to mock the construction of the new File instance in order to specify our expectations. To do this in PowerMock you need to prepare the class that creates the new object (since we don't want the new object to be created in our test, we'd like to return a mock object instead). Thus we prepare DirectoryStructure.class instead of File.class. The test may look like this when we expect that the directory doesn't exists:

 
@RunWith(PowerMockRunner.class)
@PrepareForTest(DirectoryStructure.class)
public class DirectoryStructureTest {
    @Test
    public void createDirectoryStructureWhenPathDoesntExist() throws Exception {
        final String directoryPath = "mocked path";
 
        File directoryMock = mock(File.class);
 
	// This is how you tell PowerMockito to mock construction of a new File.
        whenNew(File.class).withArguments(directoryPath).thenReturn(directoryMock);
 
	// Standard expectations
        when(directoryMock.exists()).thenReturn(false);
        when(directoryMock.mkdirs()).thenReturn(true);
 
        assertTrue(new NewFileExample().createDirectoryStructure(directoryPath));
 
        // Optionally verify that a new File was "created".
        verifyNew(File.class).withArguments(directoryPath);
    }
}
 

Example #4 - Modify code structure or change invocations

A new noteworthy feature of the 1.3 release is the new "member modification" API. Using this API you can suppress methods, fields or constructors as well stubbing and replacing methods and fields.
Below you can see some examples of how to suppress members in a class:

 
// Suppress a constructor in class ClassWithConstructor
suppress(constructor(ClassWithConstructor.class));
// Suppress method "myMethod" in class MyClass
suppress(method(MyClass.class, "myMethod"));
// Suppress all methods in class MyClass
suppress(methodsDeclaredIn(MyClass.class));
// Suppress field with name "myField" in class MyClass
suppress(field(MyClass.class, "myField"));
 

You can also stub methods:

 
//Stub the "getObject" method in class SuppressMethod to always return expectedValue
stub(method(SuppressMethod.class, "getObject")).andReturn(expectedValue);
 

And replace method invocations:

 
// Duck-typing of static methods
replace(method(MyClass.class, "getData")).with(method(MyClass2.class, "getTestData"));
// Replace method invocation with an invocation handler to allow for proxy-based AOP
replace(method(MyClass.class, "getData")).with(new MyInvocationHandler());
 

All methods can be statically imported from org.powermock.api.support.membermodification.MemberModifier and org.powermock.api.support.membermodification.MemberMatcher. For real examples refer to MemberModificationExampleTest.java in subversion.

Note that this also works for the EasyMock extension API.

Round up

We've just seen some examples of how to use PowerMock's extension API for Mockito to allow to mock things normally not possible. For more information please visit our web page at www.powermock.org.

Johan Haleby
Consultant at Jayway