使用JMockit模拟静态方法

1. Overview

Some popular mocking libraries such as Mockito and Easymock generate mock-ups by taking advantage of Java’s inheritance-based class model. EasyMock implements an interface at runtime, whereas Mockito inherits from the target class to create a mocking stub.

Neither approach works well for static methods since static methods are associated with a class and cannot be overridden. However, JMockit does provide a static method mocking features.

In this tutorial, we’ll explore some of these features.

For an introduction to JMockit, please see our previous article.

2. Maven Dependency

Let’s start with Maven dependency:

<dependency>
    <groupId>org.jmockit</groupId>
    <artifactId>jmockit</artifactId>
    <version>1.49</version>
    <scope>test</scope>
</dependency>

You can find the latest version of jmockit library on Maven Central.

3. Static Method Called from Non-Static Method

First, let’s consider a case when we have a class with a non-static method that internally depends upon a static method:

public class AppManager {

    public boolean managerResponse(String question) {
        return AppManager.isResponsePositive(question);
    }

    public static boolean isResponsePositive(String value) {
        if (value == null) {
            return false;
        }
        int length = value.length();
        int randomNumber = randomNumber();
        return length == randomNumber ? true : false;
    }

    private static int randomNumber() {
        return new Random().nextInt(7);
    }
}

Now, we want to test the method managerResponse(). Since its return value depends on another method we need to mock the isResponsePositive() method.

We can mock this static method using JMockit’s anonymous class mockit.MockUp.MockUp (where T will be the class name) and @Mock annotation:

@Test
public void givenAppManager_whenStaticMethodCalled_thenValidateExpectedResponse() {
    new MockUp<AppManager>() {
        @Mock
        public boolean isResponsePositive(String value) {
            return false;
        }
    };

    assertFalse(appManager.managerResponse("Some string..."));
}

Here, we are mocking the isResponsePositive() with a return value that we would like to use for the test. Therefore, verifying the expected result using the Assertions utility available in Junit-5.

4. Conclusion

In this article, we have seen how static methods can be mocked using JMockit. For a more in-depth look at some of the advanced features of JMockit, take a look at our JMockit Advanced Usage article.

As usual, the full source code for this tutorial is available over on GitHub.