Mocking static methods (Mockito 3.4+) in JUnit

Introduction

Sometimes, you need to test code that calls static methods. Mocking static methods lets you replace their behavior during tests to control results and avoid side effects.

When your code calls utility methods that are static and you want to simulate different return values.

When static methods access external resources like databases or files and you want to avoid those during tests.

When you want to isolate the unit under test from static dependencies to test it independently.

When you want to verify that a static method was called with specific arguments.

When refactoring legacy code that uses static methods and you want to add tests without changing the code.

Syntax

JUnit

try (MockedStatic<ClassName> mockedStatic = Mockito.mockStatic(ClassName.class)) {
    mockedStatic.when(() -> ClassName.staticMethod(args)).thenReturn(mockedValue);
    // test code that calls ClassName.staticMethod
}

Use try-with-resources to automatically close the static mock after the test.

Inside the try block, you define what the static method should return or do.

Examples

This mocks Math.max(1, 2) to return 10 instead of 2.

JUnit

try (MockedStatic<Math> mathMock = Mockito.mockStatic(Math.class)) {
    mathMock.when(() -> Math.max(1, 2)).thenReturn(10);
    int result = Math.max(1, 2);
    assertEquals(10, result);
}

This mocks a static method getConfig() to return a custom string.

JUnit

try (MockedStatic<Utils> utilsMock = Mockito.mockStatic(Utils.class)) {
    utilsMock.when(() -> Utils.getConfig()).thenReturn("mockedConfig");
    String config = Utils.getConfig();
    assertEquals("mockedConfig", config);
}

Sample Program

This test mocks the static method Calculator.add(2, 3) to return 100 instead of 5. The assertion checks that the mocked value is returned.

JUnit

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

class StaticMethodTest {

    static class Calculator {
        static int add(int a, int b) {
            return a + b;
        }
    }

    @Test
    void testMockStaticAdd() {
        try (MockedStatic<Calculator> mocked = Mockito.mockStatic(Calculator.class)) {
            mocked.when(() -> Calculator.add(2, 3)).thenReturn(100);
            int result = Calculator.add(2, 3);
            assertEquals(100, result);
        }
    }
}

Important Notes

Mockito static mocking requires Mockito 3.4 or higher and JUnit 5 for best integration.

Always use try-with-resources to avoid static mocks leaking between tests.

Mocking static methods can make tests harder to read; use it only when necessary.

Summary

Mocking static methods lets you control static method behavior during tests.

Use try-with-resources and Mockito.mockStatic to create static mocks.

This helps isolate code and test units that depend on static methods.

Practice

1. What is the main purpose of mocking static methods using Mockito 3.4+ in JUnit tests?

easy

A. To control and simulate the behavior of static methods during testing

B. To improve the performance of static methods in production

C. To replace instance methods with static methods

D. To automatically generate test data for static methods

Solution

1. Step 1: Understand mocking purpose

   Mocking allows us to simulate or control method behavior during tests to isolate code.

2. Step 2: Apply to static methods

   Mockito 3.4+ supports mocking static methods to control their output in tests.

3. Final Answer:

   To control and simulate the behavior of static methods during testing -> Option A

4. Quick Check:

   Mocking static methods = control behavior [OK]

Hint: Mocking controls method behavior in tests, not production code [OK]

Common Mistakes:

• Thinking mocking improves production performance
• Confusing static with instance methods
• Assuming mocking generates test data automatically

2. Which of the following is the correct syntax to mock a static method Utility.calculate() using Mockito 3.4+ in a JUnit test?

easy

A. try (MockedStatic<Utility> mocked = Mockito.mockStatic(Utility.class)) { mocked.when(Utility::calculate).thenReturn(10); }

B. MockedStatic<Utility> mocked = Mockito.mockStatic(Utility.class); mocked.when(() -> Utility.calculate()).thenReturn(10);

C. Mockito.mockStatic(Utility.calculate()).thenReturn(10);

D. try (MockedStatic mocked = Mockito.mockStatic(Utility.calculate())) { mocked.when(() -> Utility.calculate()).thenReturn(10); }

Solution

1. Step 1: Use try-with-resources for static mocking

   Mockito.mockStatic requires try-with-resources to auto-close the mock.

2. Step 2: Use method reference in when()

   Correct syntax uses mocked.when(Utility::calculate) to mock static method.

3. Final Answer:

   try (MockedStatic<Utility> mocked = Mockito.mockStatic(Utility.class)) { mocked.when(Utility::calculate).thenReturn(10); } -> Option A

4. Quick Check:

   try-with-resources + method ref = correct syntax [OK]

Hint: Use try-with-resources and method reference for static mocks [OK]

Common Mistakes:

• Omitting try-with-resources block
• Calling mockStatic on method instead of class
• Using wrong lambda syntax in when()

3. Given the following code snippet, what will be the output printed?

try (MockedStatic<Math> mathMock = Mockito.mockStatic(Math.class)) {
    mathMock.when(() -> Math.max(5, 10)).thenReturn(100);
    System.out.println(Math.max(5, 10));
}
System.out.println(Math.max(5, 10));

medium

A. 10
10

B. 100
10

C. 100
100

D. 10
100

Solution

1. Step 1: Inside try block, static method is mocked

   Math.max(5, 10) returns 100 because of mocked behavior.

2. Step 2: Outside try block, mock is closed

   Math.max(5, 10) returns normal value 10 after mock is closed.

3. Final Answer:

   100 10 -> Option B

4. Quick Check:

   Mock active = 100, mock closed = 10 [OK]

Hint: Mock active inside try block only; outside returns real value [OK]

Common Mistakes:

• Assuming mock affects calls outside try block
• Expecting mock to persist after try block
• Confusing return values of Math.max

4. Identify the error in the following JUnit test code that mocks a static method using Mockito 3.4+:

@Test
void testStaticMock() {
    MockedStatic<Config> configMock = Mockito.mockStatic(Config.class);
    configMock.when(() -> Config.getValue()).thenReturn("mocked");
    assertEquals("mocked", Config.getValue());
}

medium

A. assertEquals arguments are in wrong order

B. Incorrect method reference syntax in when()

C. Missing try-with-resources block to close the static mock

D. Static method cannot be mocked in Mockito 3.4+

Solution

1. Step 1: Check static mock resource management

   Static mocks must be closed; try-with-resources ensures this automatically.

2. Step 2: Identify missing try block

   Code creates mock but does not close it, risking side effects.

3. Final Answer:

   Missing try-with-resources block to close the static mock -> Option C

4. Quick Check:

   Always use try-with-resources for static mocks [OK]

Hint: Always wrap static mocks in try-with-resources to auto-close [OK]

Common Mistakes:

• Not closing static mocks causing test interference
• Using wrong lambda syntax in when()
• Mixing up assertEquals argument order

5. You want to test a method that calls Logger.log(), a static method, but you want to verify it was called exactly twice during the test. Which Mockito 3.4+ approach correctly achieves this?

hard

A. try (MockedStatic<Logger> loggerMock = Mockito.mockStatic(Logger.class)) { loggerMock.verify(() -> Logger.log(), Mockito.times(2)); }

B. MockedStatic<Logger> loggerMock = Mockito.mockStatic(Logger.class); loggerMock.verify(() -> Logger.log(), Mockito.times(2));

C. Mockito.verifyStatic(Logger.class, Mockito.times(2)); Logger.log();

D. try (MockedStatic<Logger> loggerMock = Mockito.mockStatic(Logger.class)) { Logger.log(); Logger.log(); loggerMock.verify(() -> Logger.log(), Mockito.times(2)); }

Solution

1. Step 1: Use try-with-resources to mock static Logger

   Static mock must be created and closed properly.

2. Step 2: Call Logger.log() twice inside try block

   To verify calls, method must be invoked during mock lifetime.

3. Step 3: Verify Logger.log() called exactly twice

   Use loggerMock.verify with times(2) after calls.

4. Final Answer:

   try (MockedStatic<Logger> loggerMock = Mockito.mockStatic(Logger.class)) { Logger.log(); Logger.log(); loggerMock.verify(() -> Logger.log(), Mockito.times(2)); } -> Option D

5. Quick Check:

   Call methods inside try, then verify calls [OK]

Hint: Call static method inside try block before verifying calls [OK]

Common Mistakes:

• Verifying calls without invoking method
• Not using try-with-resources for static mocks
• Using Mockito.verifyStatic without proper context