Master PowerMock: Advanced Java Unit Testing Techniques

Introduction

Complex problems should be simplified, and simple problems should be explored in depth; this principle guides the way we write unit tests by breaking down complex logic into simple, testable units.

1. Prepare Environment

PowerMock extends other mock frameworks (such as EasyMock) and can mock static methods, constructors, final classes and methods, private methods, and remove static initializers.

1.1 Add PowerMock dependencies

<dependency>
    <groupId>org.powermock</groupId>
    <artifactId>powermock-module-junit4</artifactId>
    <version>2.0.9</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.powermock</groupId>
    <artifactId>powermock-api-mockito2</artifactId>
    <version>2.0.9</version>
    <scope>test</scope>
</dependency>

1.2 Integrate with Spring MVC

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

1.3 Integrate with Spring Boot

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

1.4 Simple test case example

public class ListTest {
    @Test
    public void testSize() {
        Integer expected = 100;
        List list = PowerMockito.mock(List.class);
        PowerMockito.when(list.size()).thenReturn(expected);
        Integer actual = list.size();
        Assert.assertEquals("Returned value does not match", expected, actual);
    }
}

2. Mock Statements

2.1 Mock method

PowerMockito.mock(Class clazz);

Used to mock a specific class instance.

2.2 Mock static method

PowerMockito.mockStatic(Class clazz);

Requires @RunWith(PowerMockRunner.class) and @PrepareForTest annotations.

2.3 Mock final class or final method

public final class Circle {
    private double radius;
    public double getArea() {
        return Math.PI * Math.pow(radius, 2);
    }
}

@RunWith(PowerMockRunner.class)
@PrepareForTest({Circle.class})
public class CircleTest {
    @Test
    public void testGetArea() {
        double expected = 3.14;
        Circle circle = PowerMockito.mock(Circle.class);
        PowerMockito.when(circle.getArea()).thenReturn(expected);
        double actual = circle.getArea();
        Assert.assertEquals("Returned value does not match", expected, actual, 1E-6);
    }
}

3. Spy Statements

Use PowerMockito.spy(Class clazz) or PowerMockito.spy(object) when you want to mock only part of an object's behavior while keeping the rest unchanged.

public class Rectangle {
    private double width;
    private double height;
    public double getArea() { return width * height; }
}

public class RectangleTest {
    @Test
    public void testGetArea() {
        double expectArea = 100.0;
        Rectangle rectangle = PowerMockito.mock(Rectangle.class);
        PowerMockito.when(rectangle.getArea()).thenReturn(expectArea);
        double actualArea = rectangle.getArea();
        Assert.assertEquals("Returned value does not match", expectArea, actualArea, 1E-6);
    }
}

4. When Statements

Typical when().thenReturn() pattern:

PowerMockito.when(mockObject.someMethod(args)).thenReturn(value);
PowerMockito.when(mockObject.someMethod(args)).thenThrow(exception);
PowerMockito.when(mockObject.someMethod(args)).thenAnswer(answer);
PowerMockito.when(mockObject.someMethod(args)).thenCallRealMethod();

Use doReturn().when() when you do not want the original method to be executed (especially with spies).

PowerMockito.doReturn(expected).when(mockObject).someMethod(args);
PowerMockito.doThrow(new RuntimeException()).when(mockObject).someMethod(args);
PowerMockito.doAnswer(invocation -> { /* custom logic */ }).when(mockObject).someMethod(args);
PowerMockito.doCallRealMethod().when(mockObject).someMethod(args);

5. Parameter Matchers

Mockito provides matchers such as anyInt(), anyString(), eq(), and AdditionalMatchers for advanced comparisons.

PowerMockito.when(mockList.get(Mockito.anyInt())).thenReturn(100);
PowerMockito.when(StringUtils.startsWith(Mockito.anyString(), Mockito.eq(prefix))).thenReturn(true);
PowerMockito.when(mockList.get(AdditionalMatchers.geq(0))).thenReturn(100);
PowerMockito.when(mockList.get(AdditionalMatchers.lt(0))).thenThrow(new IndexOutOfBoundsException());

6. Verify Statements

Verify that a mocked method was called, optionally specifying call count or order.

PowerMockito.doNothing().when(mockList).clear();
mockList.clear();
Mockito.verify(mockList).clear();

Mockito.verify(mockList, Mockito.times(1)).clear();
InOrder inOrder = Mockito.inOrder(mockedList);
inOrder.verify(mockedList).add(1);
inOrder.verify(mockedList).add(2);

Argument captors can capture method arguments for further assertions.

ArgumentCaptor<Integer> captor = ArgumentCaptor.forClass(Integer.class);
Mockito.verify(mockedList, Mockito.times(3)).add(captor.capture());
Integer[] actuals = captor.getAllValues().toArray(new Integer[0]);

7. Verify Static Methods

@RunWith(PowerMockRunner.class)
@PrepareForTest({StringUtils.class})
public class StringUtilsTest {
    @Test
    public void testVerifyStatic() {
        PowerMockito.mockStatic(StringUtils.class);
        StringUtils.isEmpty("abc");
        PowerMockito.verifyStatic(StringUtils.class);
        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
        StringUtils.isEmpty(captor.capture());
        Assert.assertEquals("Parameter does not match", "abc", captor.getValue());
    }
}

8. Private Fields

Use ReflectionTestUtils.setField or PowerMock's Whitebox.setInternalState to set private fields during tests.

@RunWith(PowerMockRunner.class)
public class UserServiceTest {
    @InjectMocks
    private UserService userService;

    @Test
    public void testGetUserLimit() {
        Long expected = 1000L;
        Whitebox.setInternalState(userService, "userLimit", expected);
        Long actual = userService.getUserLimit();
        Assert.assertEquals("Returned value does not match", expected, actual);
    }
}

9. Private Methods

PowerMock can mock or invoke private methods using when with method name or stub, and verify them with verifyPrivate.

@RunWith(PowerMockRunner.class)
@PrepareForTest({UserService.class})
public class UserServiceTest {
    @Test
    public void testIsNotSuperUser() throws Exception {
        Long userId = 1L;
        boolean expected = false;
        UserService userService = PowerMockito.spy(new UserService());
        PowerMockito.when(userService, "isSuperUser", userId).thenReturn(!expected);
        boolean actual = userService.isNotSuperUser(userId);
        Assert.assertEquals("Returned value does not match", expected, actual);
    }
}

10. Main Annotations

@RunWith(PowerMockRunner.class) – Use PowerMock’s test runner.

@PrepareForTest({TargetClass.class}) – Specify classes that need byte‑code manipulation (final, static, private).

@Mock – Create a fully mocked instance.

@Spy – Create a real instance that can be partially mocked.

@InjectMocks – Create an instance and inject @Mock/@Spy fields.

@Captor – Declare an ArgumentCaptor (must be initialized with MockitoAnnotations.openMocks).

@PowerMockIgnore – Exclude classes from PowerMock’s classloader to avoid ClassLoader errors.

11. Why Use Mock?

Mocking removes external service dependencies, speeds up test execution, enables testing of edge cases and error flows, and allows unit tests to run without loading full application configurations.

12. Unit Test vs. Integration Test

Unit tests focus on isolated code units using white‑box techniques, while integration tests verify interactions between modules using black‑box approaches; unit tests run earlier and are faster.