How to modify a static private field during tests?

Question

My project uses JUnit, Mockito, PowerMockito to create a unit test. The code as below:

public class FirstController {
    public void doSomething() {
        ServiceExecutor.execute();
    }
}

public class ServiceExecutor {

    private static final List<Service> services = Arrays.asList(
        new Service1(),
        new Service2(),
        ...
    );

    public static void execute() {
        for (Service s : services) {
            s.execute();
        }
    }   
}

@RunWith(PowerMockRunner.class)
@PrepareForTest({ServiceExecutor.class})
public class FirstControllerTest {

        @Before
        public void prepareForTest() {
            PowerMockito.mockStatic(ServiceExecutor.class);
            PowerMockito.doNothing().when(ServiceExecutor.class)
        }

        @Test
        public void doSomethingTest() {
            FirstController firstController = new FirstController();
            firstController.doSomething();
            PowerMockito.verifyStatic(ServiceExecutor.class, Mockito.times(1));
        }   
    }

The full source code of this issue: https://github.com/gpcodervn/Java-Tutorial/tree/master/UnitTest

I want to verify the ServiceExecutor.execute() method which was run.

I tried to mock ServiceExecutor and doNothing() when the execute() method is called. But I have a problem with the private static final List<Service> services in the ServiceExecutor. It always constructs the new instance for each Service. Each service is longer to create the new instance and I don't know how many Service they will have later if I mock each Service.

Do you have any idea to verify ServiceExecutor.execute() in FirstController without run any method in ServiceExecutor?

Answer 1

So you know how to mock ServiceExecutor.execute, but you do not want to mock it. You want to execute it in the tests, but without running all the service.execute() methods in the test. That is not a test for FirstController, but a test for ServiceExecutor. So you can reduce your question to that.

You can use Reflection to change the value of the private static fields ServiceExecutor.services in the tests as described here: Change private static final field using Java reflection

public class ServiceExecutorTest {

    @Test
    public void doSomethingTest() throws NoSuchFieldException, IllegalAccessException {
        Field field = null;
        List<Service> oldList = null;
        try {
            field = ServiceExecutor.class.getDeclaredField("services");
            field.setAccessible(true);
            Field modifiersField = Field.class.getDeclaredField("modifiers");
            modifiersField.setAccessible(true);
            modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);

            final Service serviceMock1 = mock(Service.class);
            final Service serviceMock2 = mock(Service.class);
            final List<Service> serviceMockList = Arrays.asList(serviceMock1, serviceMock2);
            oldList = (List<Service>) field.get(null);
            field.set(null, serviceMockList);
            ServiceExecutor.execute();
            // or testing the controller
            // FirstController firstController = new FirstController();
            // firstController.doSomething();
            verify(serviceMock1, times(1)).execute();
            verify(serviceMock2, times(1)).execute();
        } finally {
            // restore original value
            if (field != null && oldList != null) {
                field.set(null, oldList);
            }
        }
    }

    static class Service {
        void execute() {
            throw new RuntimeException("Should not execute");
        }
    }

    static class ServiceExecutor {

        private static final List<Service> services = Arrays.asList(
                new Service());

        public static void execute() {
            for (Service s : services) {
                s.execute();
            }
        }
    }
}

Answer 2

As expressed in comments, the "real" solution would be to change the design to maker it easier to test. But given your constraints, here is an alternative idea that might could work, too.

You see, you are filling your list using

private static final List<Service> services = Arrays.asList(...)

So, theoretically, you could use PowerMock(ito) to use Arrays.asList() as the point where you take over control. In other words: you could have asList() return whatever List you want to be used for testing!

Of course, the better approach could be to replace that static list within something that could be injected, like

private final ServicesProvider serviceProvider; 

where you have a distinct class that gives you such a list. You can test that class on its own, and then use ordinary Mockito to get a mocked service provider into your code under test.

Answer 3

I've found the solution uses the @SuppressStaticInitializationFor annotation.

Use this annotation to suppress static initializers (constructors) for one or more classes.

The reason why an annotation is needed for this is because we need to know at load-time if the static constructor execution for this class should be skipped or not. Unfortunately, we cannot pass the class as the value parameter to the annotation (and thus get type-safe values) because then the class would be loaded before PowerMock could have suppressed its constructor.

https://github.com/powermock/powermock/wiki/Suppress-Unwanted-Behavior

The final code:

@RunWith(PowerMockRunner.class)
@PrepareForTest({ ServiceExecutor.class })
@SuppressStaticInitializationFor("com.gpcoder.staticblock.ServiceExecutor")
public class FirstControllerTest {

    @Before
    public void prepareForTest() throws Exception {
        PowerMockito.mockStatic(ServiceExecutor.class);
        PowerMockito.doNothing().when(ServiceExecutor.class);
    }

    @Test
    public void doSomethingTest() {
        FirstController firstController = new FirstController();
        firstController.doSomething();
        PowerMockito.verifyStatic(ServiceExecutor.class, Mockito.times(1));
    }
}