Junit5 mock a static method

Question

I want to mock a static method in JUnit 5. But unfortunately, JUnit 5 doesn’t support Mockito. Is there another method to achieve the same other than reverting back to JUnit 4?

Answer 1

From Mockito 3.4.0 (2020-07-10), it is possible to mock static methods out of the box even in JUnit 5, without any extension.

In the documentation, you can find an example: 48. Mocking static methods (since 3.4.0)

Important note: You need to use inline mock maker. So the dependency to use is not the core one:

        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-inline</artifactId>
            <version>3.4.6</version>
            <scope>test</scope>
        </dependency>

Example: Class under test:

package teststatics;

public class FooWithStatics {
    public static Long noParameters() {
        return System.currentTimeMillis();
    }
    public static String oneParameter(String param1) {
        return param1.toUpperCase();
    }
}

Test class:

package teststatics;

import org.junit.jupiter.api.Test;
import org.mockito.MockedStatic;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;

public class FooWithStaticsTest {

    @Test
    void testStatic() {
        // Before mock scope, usual behavior.
        assertNotEquals(0L, FooWithStatics.noParameters());
        assertNotEquals("yyy", FooWithStatics.oneParameter("xxx"));

        // Mock scope
        try (MockedStatic mocked = mockStatic(FooWithStatics.class)) {

            // Mocking
            mocked.when(FooWithStatics::noParameters).thenReturn(0L);
            mocked.when(() -> FooWithStatics.oneParameter("xxx")).thenReturn("yyy");

            // Mocked behavior
            assertEquals(0L, FooWithStatics.noParameters());
            assertEquals("yyy", FooWithStatics.oneParameter("xxx"));

            // Verifying mocks.
            mocked.verify(times(1), FooWithStatics::noParameters);
            mocked.verify(times(1), () -> FooWithStatics.oneParameter("xxx"));
        }

        // After mock scope returns to usual behavior.
        assertNotEquals(0L, FooWithStatics.noParameters());
        assertNotEquals("yyy", FooWithStatics.oneParameter("xxx"));
    }
}

Answer 2

The short answer is no, as the Mockito team is done with their work and is waiting for the JUnit team for an extension and are discussing here a lot.

With some overhead you can: As JUnit 5 provides support for running legacy JUnit 4, and there you can use Mockito. So you can create tests in Junit4 for these cases:

A sample project for migration setup with gradle and with mvn. From there I am using PowerMock 2.0 beta with Mockito 2.

Answer 3

The reason why Mockito doesn't provide static methods mocking at the moment is because of the common belief that static method shouldn't need to be mocked.

However, there is an open item for Mockito here that discusses the issue.

While this doesn't answer your question, in general it tells you why you shouldn't need the feature at all or will allow you to join the conversation with your ideas.

Answer 4

1. Make sure to have mockito-inline dependency in your POM file

   <dependency>
       <groupId>org.mockito</groupId>
       <artifactId>mockito-inline</artifactId>
       <version>3.6.28</version>
       <scope>test</scope>
   </dependency>
   

2. In my case I had to test scenario where exception thrown static method encode() of URLEncoder Class, so for that

   try (MockedStatic theMock  = mockStatic(URLEncoder.class)) {
       theMock.when(() -> URLEncoder.encode("Test/11", StandardCharsets.UTF_8.toString()))
       .thenThrow(UnsupportedEncodingException.class);
       when(restClient.retrieveByName("Test%2F11")).thenReturn(null);
       Assertions.assertThrows(ResponseStatusException.class, ()->service.retrieveByName("Test/11"));
   }
   

Answer 5

You can achieve the Mocking of static methods using mockito-inline artifact.

1. Add the maven dependency.

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-inline</artifactId>
    <version>5.2.0</version>
    <scope>test</scope>
</dependency>

2. OPTIONAL: If facing issues, exclude the mockito-core as this is included in the mockito-inline already.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
    <exclusions>
        <exclusion>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-core</artifactId>
        </exclusion>
        <exclusion>
            <artifactId>mockito-junit-jupiter</artifactId>
            <groupId>org.mockito</groupId>
        </exclusion>
    </exclusions>
</dependency>

3. Example to illustrate:

class FilesUtility{
    public static boolean something(String x , String y){
        return true;
    }
}

4. Test case:

@Test
void testStaticMethod() {
    try (MockedStatic<? extends FilesUtility> mocked = 
       mockStatic(FilesUtility.class, CALLS_REAL_METHODS)) {

    mocked
        when(() -> FilesUtility.something(any(), any()))
        .thenReturn(false);
    }
}

IMPORTANT: The default behavior is to do nothing, but it's also possible to provide an Answer when creating the mock by explicitly specifying the CALLS_REAL_METHODS.

mockStatic(FilesUtility.class, CALLS_REAL_METHODS)

So, if your mocked static method internally calls any other method in that mocked class, you don't have to mock their behaviour as well - you can keep their behaviour default by specifying CALLS_REAL_METHODS argument. It is equivalent to Spying on that class.

Answer 6

We can mock a static method by JMockit.

JMockit is used for mocking the external dependencies outside the test boundary, similar to Mockito and other such mocking libraries. The most important feature of JMockit is that it lets us mock anything, even the things that are hard to mock with other libraries such as constructors, static and final methods. It even allows mocking the member fields and initialization blocks as well.

Follow the below steps to enable JMockit:

1. The JMockit artifact is located in the central Maven repository, add the JMockit dependency in pom.xml

    <!-- https://mvnrepository.com/artifact/org.jmockit/jmockit -->
    <dependency>
        <groupId>org.jmockit</groupId>
        <artifactId>jmockit</artifactId>
        <version>1.49</version>
        <scope>test</scope>
    </dependency>

2. Mock the Class method in TestClass:

    public class TestClass{
    @Test
    public void testMethod() {
        new MockUp<ClassName>(){
            @Mock
            //mock  the method here
        };
    }
   

   }

Follow the tutorial to know more about how to use the JMockit.