Mocking static methods (Mockito 3.4+) in JUnit - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is mocking static methods in Mockito 3.4+?

Mocking static methods means creating fake versions of static methods to control their behavior during tests, allowing you to test code that depends on static methods without running the real ones.

beginner

How do you start mocking static methods in Mockito 3.4+?

You use the try-with-resources block with Mockito.mockStatic(ClassName.class) to create a mock scope for static methods, ensuring the mock is closed after use.

intermediate

Why should you use try-with-resources when mocking static methods?

Because it automatically closes the static mock after the test, preventing side effects on other tests and keeping tests isolated.

beginner

What is the syntax to mock a static method call to return a specific value?

Inside the mockStatic block, use mockStatic.when(() -> ClassName.staticMethod(args)).thenReturn(value) to specify the fake return value.

intermediate

Can you verify static method calls with Mockito 3.4+? How?

Yes, inside the mockStatic block, use mockStatic.verify(() -> ClassName.staticMethod(args)) to check if the static method was called as expected.

Which Mockito feature allows mocking static methods starting from version 3.4+?

A Mockito.spy()

B Mockito.mock()

C Mockito.when()

D Mockito.mockStatic()

Mockito.mockStatic() is the method introduced in Mockito 3.4+ to mock static methods.

Why is try-with-resources recommended when mocking static methods?

A To automatically close the static mock and avoid side effects

B To improve test speed

C To mock instance methods

D To create multiple mocks

Try-with-resources ensures the static mock is closed after use, preventing interference with other tests.

How do you specify a return value for a mocked static method?

A doReturn(value).when(ClassName).staticMethod(args)

B when(ClassName.staticMethod(args)).thenReturn(value)

C verify(ClassName).staticMethod(args)

D mockStatic(ClassName).thenReturn(value)

Inside the mockStatic block, use when(...).thenReturn(...) to define the return value.

Can you verify static method calls in Mockito 3.4+?

A Only with Mockito 2.x

B No, static methods cannot be verified

C Yes, using verify() inside the mockStatic block

D Yes, but only outside the mockStatic block

Mockito 3.4+ allows verification of static method calls inside the mockStatic block.

What happens if you don't close the static mock after testing?

A Other tests might be affected by the mock

B The test will fail immediately

C The static method will not be mocked

D Mockito will throw an exception

Not closing the static mock can cause side effects on other tests, breaking test isolation.

Explain how to mock a static method using Mockito 3.4+ and why it is important to use try-with-resources.

Think about resource management and test isolation.

Describe how to verify that a static method was called during a test using Mockito 3.4+.

Verification is similar to instance method verification but inside the static mock scope.

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