@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.

Practice

1. What is the main purpose of the @Mock annotation in JUnit testing?

easy

A. To create fake objects that simulate real dependencies for testing

B. To run tests in parallel threads

C. To generate test reports automatically

D. To connect to a real database during tests

Solution

1. Step 1: Understand the role of @Mock

   The @Mock annotation is used to create fake objects that imitate real dependencies in tests.

2. Step 2: Identify the purpose in testing context

   This helps isolate the code being tested from external systems or complex objects.

3. Final Answer:

   To create fake objects that simulate real dependencies for testing -> Option A

4. Quick Check:

   @Mock creates fake objects [OK]

Hint: Mocks create fake objects to isolate tests [OK]

Common Mistakes:

• Thinking @Mock runs tests in parallel
• Confusing @Mock with test report generation
• Assuming @Mock connects to real databases

2. Which of the following is the correct way to declare a mock object using @Mock in a JUnit 5 test class?

easy

A. @Mock private MyService service;

B. @Mock MyService service = new MyService();

C. @Mock public void service();

D. @Mock MyService service = null;

Solution

1. Step 1: Check correct syntax for @Mock field declaration

   The mock object should be declared as a private field with the @Mock annotation and no initialization.

2. Step 2: Identify the correct option

   @Mock private MyService service; correctly declares: @Mock private MyService service; without initializing it.

3. Final Answer:

   @Mock private MyService service; -> Option A

4. Quick Check:

   Declare mock as private field without initialization [OK]

Hint: Declare mocks as private fields without new keyword [OK]

Common Mistakes:

• Initializing mock objects manually
• Using @Mock on methods instead of fields
• Declaring mocks as public or with invalid syntax

3. Given the following JUnit 5 test code snippet, what will be the output of service.getData() when called inside the test?

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

class MyServiceTest {
  @Mock
  MyService service;

  @Test
  void testGetData() {
    MockitoAnnotations.openMocks(this);
    when(service.getData()).thenReturn("mocked data");
    System.out.println(service.getData());
  }
}

medium

A. Original data from MyService

B. null

C. Throws NullPointerException

D. mocked data

Solution

1. Step 1: Understand mock initialization

   The call to MockitoAnnotations.openMocks(this) initializes the @Mock annotated fields.

2. Step 2: Analyze the stubbed method behavior

   The line when(service.getData()).thenReturn("mocked data") sets the mock to return "mocked data" when getData() is called.

3. Final Answer:

   mocked data -> Option D

4. Quick Check:

   Stubbed mock method returns set value [OK]

Hint: Initialize mocks and stub methods to control output [OK]

Common Mistakes:

• Forgetting to initialize mocks before use
• Expecting real method output instead of stubbed
• Confusing null return with stubbed return

4. Identify the error in the following JUnit 5 test code using @Mock:

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

class UserServiceTest {
  @Mock
  UserRepository repo;

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

medium

A. The test method is missing the @Mock annotation

B. The when method is used incorrectly

C. Mocks are not initialized before use

D. UserService constructor cannot accept mocks

Solution

1. Step 1: Check mock initialization

   The code declares @Mock UserRepository repo; but never initializes mocks with MockitoAnnotations.openMocks(this) or similar.

2. Step 2: Understand consequence of missing initialization

   Without initialization, repo is null, so calling when(repo.findUserById(1)) causes a NullPointerException.

3. Final Answer:

   Mocks are not initialized before use -> Option C

4. Quick Check:

   Always initialize mocks before using them [OK]

Hint: Always initialize mocks before calling methods on them [OK]

Common Mistakes:

• Forgetting MockitoAnnotations.openMocks(this)
• Assuming @Mock auto-initializes mocks
• Misusing when() without initialized mocks

5. You want to test a service method that depends on two different collaborators. You use @Mock to create fake objects for both. Which of the following is the best practice to ensure your mocks work correctly in the test?

hard

A. Declare mocks as local variables inside test methods

B. Initialize mocks with MockitoAnnotations.openMocks(this) in a setup method

C. Use real instances instead of mocks for better accuracy

D. Manually instantiate mocks with new keyword

Solution

1. Step 1: Understand mock initialization best practice

   Mocks annotated with @Mock must be initialized before use, typically by calling MockitoAnnotations.openMocks(this) in a setup method.

2. Step 2: Evaluate other options

   Manually creating mocks with new is incorrect; real instances break isolation; local variables lose scope and initialization benefits.

3. Final Answer:

   Initialize mocks with MockitoAnnotations.openMocks(this) in a setup method -> Option B

4. Quick Check:

   Initialize mocks in setup for reliable tests [OK]

Hint: Initialize all @Mock fields in setup method [OK]

Common Mistakes:

• Creating mocks manually with new keyword
• Using real objects instead of mocks
• Declaring mocks inside test methods without initialization