Why Mocking static methods (Mockito 3.4+) in JUnit? - Purpose & Use Cases

The Big Idea

What if you could stop waiting on slow static methods and test your code instantly and reliably?

The Scenario

Imagine you have a big project where some parts use static methods to get data or perform actions. You want to test your code, but these static methods always run their real code, which might call a database or a web service.

You try to test manually by running the whole program and checking results, but it takes a long time and you can't control what the static methods do.

The Problem

Testing like this is slow because every test runs the full static method code, which might be slow or unreliable.

It is also error-prone because you can't isolate your code from the static methods' side effects.

Manual testing becomes painful and hard to repeat exactly the same way.

The Solution

Mocking static methods with Mockito 3.4+ lets you replace the real static method calls with fake ones during tests.

This means you can control what the static methods return or do, making your tests fast, reliable, and easy to write.

Before vs After

✗ Before

String result = StaticUtils.getData(); // calls real method
assertEquals("expected", result);

✓ After

try (MockedStatic<StaticUtils> mock = Mockito.mockStatic(StaticUtils.class)) {
  mock.when(StaticUtils::getData).thenReturn("mocked");
  String result = StaticUtils.getData();
  assertEquals("mocked", result);
}

What It Enables

It enables writing fast, isolated tests that focus only on your code, ignoring complex static method internals.

Real Life Example

When testing a payment service that calls a static method to get exchange rates, mocking that static method lets you test payment logic without depending on live exchange rate services.

Key Takeaways

Manual testing with static methods is slow and unreliable.

Mocking static methods lets you control their behavior in tests.

This leads to faster, cleaner, and more reliable automated tests.

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