@InjectMocks annotation in JUnit

Introduction

The @InjectMocks annotation helps automatically create and inject mock objects into the class you want to test. It saves time and makes tests cleaner.

When you want to test a class that depends on other classes or services.

When you want to avoid manually creating and injecting mock objects.

When you want to focus on testing the main class behavior without real dependencies.

When you want to keep your test code simple and easy to read.

Syntax

JUnit

@InjectMocks
private ClassToTest classToTest;

This annotation is used together with @Mock or @Spy annotations.

Mockito will create an instance of ClassToTest and inject mocks into it.

Examples

This creates a mock for Dependency and injects it into Service automatically.

JUnit

@Mock
private Dependency dependency;

@InjectMocks
private Service service;

This creates a spy for Helper and injects it into Controller.

JUnit

@Spy
private Helper helper;

@InjectMocks
private Controller controller;

Sample Program

This test uses @InjectMocks to create a Calculator instance with a mocked Adder. The test checks that the add method returns the mocked value.

JUnit

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

class Calculator {
    private Adder adder;
    public Calculator(Adder adder) {
        this.adder = adder;
    }
    public int add(int a, int b) {
        return adder.add(a, b);
    }
}

interface Adder {
    int add(int x, int y);
}

public class CalculatorTest {
    @Mock
    Adder adder;

    @InjectMocks
    Calculator calculator;

    public CalculatorTest() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    void testAdd() {
        when(adder.add(2, 3)).thenReturn(5);
        int result = calculator.add(2, 3);
        assert result == 5 : "Expected 5 but got " + result;
        System.out.println("Test passed: " + (result == 5));
    }
}

Important Notes

Always initialize mocks with MockitoAnnotations.openMocks(this) or use @ExtendWith(MockitoExtension.class) in JUnit 5.

@InjectMocks tries to inject mocks by constructor, setter, or field injection in that order.

Summary

@InjectMocks creates the class under test and injects mocks automatically.

It reduces manual setup and keeps tests clean.

Works well with @Mock and @Spy annotations.

Practice

1. What is the primary purpose of the @InjectMocks annotation in JUnit testing?

easy

A. To spy on real objects without mocking

B. To create the class under test and inject mock dependencies automatically

C. To create mock objects without injecting them

D. To run tests in parallel threads

Solution

1. Step 1: Understand the role of @InjectMocks

   @InjectMocks creates an instance of the class under test and injects mocks into it automatically.

2. Step 2: Compare with other annotations

   @Mock creates mock objects, but does not inject them. @Spy wraps real objects. @InjectMocks handles injection.

3. Final Answer:

   To create the class under test and inject mock dependencies automatically -> Option B

4. Quick Check:

   @InjectMocks = auto-inject mocks [OK]

Hint: Remember: @InjectMocks builds and injects mocks automatically [OK]

Common Mistakes:

• Confusing @InjectMocks with @Mock
• Thinking @InjectMocks creates mocks instead of injecting
• Assuming @InjectMocks runs tests or manages threads

2. Which of the following is the correct way to declare a field with @InjectMocks in a JUnit 5 test class?

easy

A. @InjectMocks private Service service;

B. @InjectMocks Service service = new Service();

C. @InjectMocks private Service service = new Service();

D. @InjectMocks Service service;

Solution

1. Step 1: Check field declaration syntax

   Fields with @InjectMocks should be private and declared without manual instantiation.

2. Step 2: Identify correct syntax

   @InjectMocks private Service service; declares a private field with @InjectMocks without manual instantiation, letting the framework create it.

3. Final Answer:

   @InjectMocks private Service service; -> Option A

4. Quick Check:

   Private field + no manual new = correct [OK]

Hint: Use private fields without 'new' for @InjectMocks [OK]

Common Mistakes:

• Manually instantiating the field defeats @InjectMocks purpose
• Using package-private or public fields without private
• Missing semicolon or incorrect syntax

3. Given the following test code snippet, what will be the output of service.process() if dependency.doWork() is mocked to return "mocked"?

class Dependency {
    String doWork() { return "real"; }
}

class Service {
    Dependency dependency;
    String process() { return dependency.doWork(); }
}

@InjectMocks
Service service;

@Mock
Dependency dependency;

@BeforeEach
void setup() {
    MockitoAnnotations.openMocks(this);
    when(dependency.doWork()).thenReturn("mocked");
}

@Test
void testProcess() {
    System.out.println(service.process());
}

medium

A. Compilation error

B. "real"

C. NullPointerException

D. "mocked"

Solution

1. Step 1: Understand @InjectMocks and @Mock interaction

   @InjectMocks creates Service and injects the mocked Dependency instance into it.

2. Step 2: Analyze method call and mock behavior

   dependency.doWork() is mocked to return "mocked", so service.process() returns "mocked".

3. Final Answer:

   "mocked" -> Option D

4. Quick Check:

   Mocked method returns "mocked" [OK]

Hint: Mocks override real methods; expect mocked return values [OK]

Common Mistakes:

• Expecting real method output instead of mocked
• Forgetting to initialize mocks with openMocks
• Assuming dependency is null causing NullPointerException

4. Consider the following test setup:

@InjectMocks
Service service;

@Mock
Dependency dependency;

@BeforeEach
void setup() {
    MockitoAnnotations.openMocks(this);
}

@Test
void test() {
    System.out.println(service.process());
}

When running the test, a NullPointerException occurs at service.process(). What is the most likely cause?

medium

A. The @InjectMocks annotation is applied to the wrong class

B. The @Mock annotation is missing

C. The dependency field in Service is not initialized or injected

D. MockitoAnnotations.openMocks(this) was not called

Solution

1. Step 1: Identify cause of NullPointerException

   NullPointerException at service.process() means dependency inside Service is null.

2. Step 2: Check injection of mocks

   @InjectMocks should inject mocks into Service fields, but if Service's dependency field is not properly declared or missing setter, injection fails.

3. Final Answer:

   The dependency field in Service is not initialized or injected -> Option C

4. Quick Check:

   NullPointerException = missing injection [OK]

Hint: NullPointerException often means mock not injected properly [OK]

Common Mistakes:

• Assuming missing @Mock causes NPE (it causes different errors)
• Thinking openMocks call is missing when it is present
• Confusing @InjectMocks placement with injection failure

5. You have a class OrderService that depends on PaymentService and InventoryService. You want to write a JUnit test using @InjectMocks to inject mocks of both dependencies. Which setup correctly uses @InjectMocks and @Mock to achieve this?

hard

A. @InjectMocks
OrderService orderService;

@Mock
PaymentService paymentService;

@Mock
InventoryService inventoryService;

B. @Mock
OrderService orderService;

@InjectMocks
PaymentService paymentService;

@InjectMocks
InventoryService inventoryService;

C. @InjectMocks
OrderService orderService = new OrderService();

@Mock
PaymentService paymentService;

@Mock
InventoryService inventoryService;

D. @Mock
OrderService orderService;

@Mock
PaymentService paymentService;

@Mock
InventoryService inventoryService;

Solution

1. Step 1: Identify the class under test

   OrderService is the class under test, so it should be annotated with @InjectMocks.

2. Step 2: Identify dependencies to mock

   PaymentService and InventoryService are dependencies, so they should be annotated with @Mock.

3. Step 3: Check for manual instantiation

   OrderService should not be manually instantiated when using @InjectMocks to allow automatic injection.

4. Final Answer:

   @InjectMocks OrderService orderService; @Mock PaymentService paymentService; @Mock InventoryService inventoryService; -> Option A

5. Quick Check:

   Class under test @InjectMocks + dependencies @Mock [OK]

Hint: InjectMocks on class under test; Mocks on dependencies [OK]

Common Mistakes:

• Annotating dependencies with @InjectMocks instead of @Mock
• Manually instantiating class under test with @InjectMocks
• Annotating class under test with @Mock instead of @InjectMocks