@RunWith(PowerMockRunner.class) – Tell Junit that run this test using PowerMockRunner
@PrepareForTest(A.class) – This is needed when we need to test static methods of A class
AService mock = PowerMockito.mock(A.class) – Creating a mock for A class
PowerMockito.when(mock.mockedMethod()).thenReturn(value) – When mockedMethod is called in the code, then return the value specified here.
PowerMockito.doNothing().when(mock).method() – do nothing when method() is called on mock object
Mockito.verify(mock).someMethod() – Verify that someMethod was called on mock once.
Mockito.verify(mock, times(n)).someMethod() – someMethod called n number of times
Mockito.verify(mock, never()).someMethod() – someMethod called n number of times
Mockito.verify(mock, atLeastOnce()).someMethod() – self explanatory
Mockito.verify(mock, atLeast(n)).someMethod() – self explanatory
Mockito.verify(mock, atMost(n)).someMethod() – self explanatory
Static
PowerMockito.mockStatic(A.class) – mock all static methods of class A
PowerMockito.doNothing().when(A.class)
A.staticMethod(value); – Nothing to be done when staticMethod(value) is called on class A
PowerMockito.doNothing().doThrow(new IllegalStateException()).when(A.class)
A.staticMethod(value); – Throw IllegalStateException when staticMethod(value) is called on class A
//We first have to inform PowerMock that we will now verify
//the invocation of a static method by calling verifyStatic.
PowerMockito.verifyStatic();
//Then we need to inform PowerMock about the method we want to verify.
//This is done by actually invoking the static
A.staticMethod();
@Before – annotation for a method that does the set up before starting the test.
InOrder verification
//First we have to let PowerMock know that the verification order is
//going to be important. This is done by calling Mockito.inOrder and passing
//it the mocked object.
InOrder inOrder = Mockito.inOrder(mock);
//Next, we can continue our verification using the inOrder instance
//using the same technique as seen earlier.
inOrder.verify(mock).isNew();
inOrder.verify(mock).update();
inOrder.verify(mock, Mockito.never()).create();
Constructor
PowerMockito.whenNew(A.class).withArguments(mock, “msg”).thenReturn(object)
PowerMockito.verifyNew(A.class).withArguments(mock, “msg”)
PowerMockito.verifyNew(A.class, times(n)).withArguments(mock, “msg”)
The class creating an object of A will be needed to be in @PrepareForTest
Matchers
PowerMockito.when(mock.method(Mockito.startsWith(“somestring”))).thenReturn(objValue);
Assert.assertSame(objValue, mock.method(“somestring123”));
Assert.assertSame(objValue, mock.method(“somestring456”));
PowerMockito.when(mock.method(Mockito.argThat(new ArgumentMatcher){public void matches(Object obj)….}).thenReturn(value); – Use the custom matcher to match the argument and return the value specified.
Mockito.eq(value)
Mockito.matches(regex)
Mockito.anyString, anyFloat, anyDouble, anyList, and so on
Mockito.isNull
Mockito.isNotNull
Mockito.isA
Mockito.endsWith
Answer Interface
When thenReturn() is not practical, use Answer interface
PowerMockito.when(mock.method()).then(new Answer<T>() {
public T answer(InvocationOnMock invocation) {
…invocation.getArguments()….
}
});
PowerMockito.mock(A.class, Answer obj) – This will act as default answer for all the invocation on this mock object.
Spy – Partial Mocking (some methods) of classes
//Following is the syntax to create a spy using the PowerMockito.spy method.
//Notice that we have to pass an actual instance of the EmployeeService class.
//This is necessary since a spy will only mock few methods of a class and
//invoke the real methods for all methods that are not mocked.
final EmployeeService spy = PowerMockito.spy(new EmployeeService());
//Notice that we have to use the PowerMockito.doNothing().when(spy).createEmployee()
//syntax to create the spy. This is required because if we use the
//PowerMockito.when(spy.createEmployee()) syntax will result in calling
//the actual method on the spy.
//Hence, remember when we are using spies,
//always use the doNothing(), doReturn() or the //doThrow() syntax only. PowerMockito.doNothing().when(spy)
.createEmployee(employeeMock);
Mocking private methods
PowerMockito.doNothing().when(spy,
“createEmployee”, employeeMock);
PowerMockito.verifyPrivate(spy)
.invoke(“createEmployee”, employeeMock);
==========================================================
https://github.com/powermock/powermock/wiki/MockPrivate
