@Mock annotation in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Purpose of @Mock Annotation in JUnit Tests

What is the main purpose of using the @Mock annotation in JUnit testing with Mockito?

A To create a fake object that simulates the behavior of a real dependency for isolated testing.

B To automatically generate test data for parameterized tests.

C To mark a test method that should be ignored during test execution.

D To inject real implementations of dependencies into the test class.

💡 Hint

Think about how you isolate the class under test from its dependencies.

The @Mock annotation creates a mock object that simulates a real dependency. This allows testing the class in isolation without relying on actual implementations.

❓ Predict Output

intermediate

Output of a Test Using @Mock Without Initialization

Consider this JUnit 5 test class using Mockito. What will happen when the test runs?

JUnit

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

class ServiceTest {
    @Mock
    Repository repo;

    @Test
    void testService() {
        when(repo.getData()).thenReturn("mocked data");
        System.out.println(repo.getData());
    }
}

A Prints 'mocked data' to the console.

B Prints 'null' to the console.

C Throws a NullPointerException at runtime.

D Compilation error due to missing import.

💡 Hint

Think about whether the @Mock annotation is activated automatically.

The @Mock annotation alone does not create the mock instance unless Mockito is initialized (e.g., with @ExtendWith(MockitoExtension.class) or MockitoAnnotations.openMocks). Without initialization, the repo field is null, causing a NullPointerException when used.

❓ assertion

advanced

Correct Assertion to Verify Mock Interaction

Given a mock object mockList of type List, which assertion correctly verifies that the add("item") method was called exactly once?

A verify(mockList).add("item"); assertTrue(true);

B verify(mockList, times(1)).add("item");

C assertEquals(1, mockList.add("item"));

D assertThat(mockList).contains("item");

💡 Hint

Mockito provides a special method to check how many times a method was called.

The verify(mockList, times(1)).add("item") assertion checks that the add method was called exactly once on the mock. Other options either misuse assertions or do not verify call counts.

🔧 Debug

advanced

Why Does This Mockito Test Fail?

This test fails with a NullPointerException. What is the most likely cause?

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

class UserServiceTest {
    @Mock
    UserRepository userRepository;

    @Test
    void testGetUser() {
        when(userRepository.findUserById(1)).thenReturn(new User(1, "Alice"));
        UserService service = new UserService(userRepository);
        User user = service.getUser(1);
        assertEquals("Alice", user.getName());
    }
}

A Mockito was not initialized, so userRepository is null causing NullPointerException.

B The User class does not have a constructor with parameters.

C The when() method is called after the service is created, causing timing issues.

D The assertEquals method is used incorrectly with parameters reversed.

💡 Hint

Check if the mock object is properly created before use.

The test fails because the @Mock annotation requires Mockito initialization (e.g., with MockitoExtension or MockitoAnnotations.openMocks). Without it, userRepository is null, causing NullPointerException when calling when().

❓ framework

expert

Best Way to Enable @Mock Annotation in JUnit 5 Tests

Which approach correctly enables the use of @Mock annotations in a JUnit 5 test class using Mockito?

A Add <code>@MockBean</code> annotations instead of <code>@Mock</code>.

B Call <code>Mockito.mock()</code> manually for each mock field in every test method.

C Use <code>@RunWith(MockitoJUnitRunner.class)</code> on the test class.

D Annotate the test class with <code>@ExtendWith(MockitoExtension.class)</code>.

💡 Hint

JUnit 5 uses extensions instead of runners.

In JUnit 5, the recommended way to activate Mockito annotations like @Mock is to annotate the test class with @ExtendWith(MockitoExtension.class). This initializes mocks automatically before each test.