@InjectMocks annotation in JUnit - Cheat Sheet & Quick Revision

Recall & Review

beginner

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

<p>The <code>@InjectMocks</code> annotation is used to create an instance of the class under test and inject mock dependencies into it automatically.</p>

beginner

How does @InjectMocks differ from @Mock in JUnit tests?

@Mock creates mock objects for dependencies, while @InjectMocks creates the real object and injects those mocks into it.

intermediate

Which injection types does @InjectMocks support for injecting mocks?

@InjectMocks supports constructor injection, setter injection, and field injection to insert mocks into the tested class.

intermediate

What happens if @InjectMocks cannot find a suitable constructor or setter to inject mocks?

<p>The injection will fail silently, and the tested class may have null dependencies, causing NullPointerExceptions during test execution.</p>

beginner

Can @InjectMocks be used without initializing mocks with MockitoAnnotations.openMocks(this) or @ExtendWith(MockitoExtension.class)?

No. To enable @InjectMocks to work, mocks must be initialized either by calling MockitoAnnotations.openMocks(this) in a setup method or using the Mockito extension with JUnit 5.

What does the @InjectMocks annotation do in a JUnit test?

A Runs the test method multiple times

B Creates mock objects for dependencies

C Creates a real instance of the class and injects mocks into it

D Mocks static methods

@InjectMocks creates the real object under test and injects mocks into its dependencies automatically.

Which of the following is NOT a way @InjectMocks injects mocks?

A Constructor injection

B Setter injection

C Field injection

D Interface injection

@InjectMocks supports constructor, setter, and field injection but not interface injection.

What must you do to enable @InjectMocks to work properly in your test class?

A Initialize mocks with <code>MockitoAnnotations.openMocks(this)</code> or use <code>@ExtendWith(MockitoExtension.class)</code>

B Call <code>System.out.println()</code> in the test

C Use <code>@Test</code> annotation only

D Write a main method

Mocks must be initialized for @InjectMocks to inject them properly.

If @InjectMocks cannot find a suitable constructor or setter, what is likely to happen?

A Mocks will be injected anyway

B Dependencies will remain null, causing errors

C Test will pass without any issue

D JUnit will skip the test

Without proper injection points, dependencies remain null, leading to NullPointerExceptions.

Which annotation is used to create mock objects that @InjectMocks will inject?

A @Mock

B @Test

C @BeforeEach

D @Spy

@Mock creates mock objects for dependencies to be injected.

Explain how @InjectMocks works in a JUnit test and why it is useful.

Think about how it helps avoid writing manual code to set dependencies.

Describe the steps needed to properly use @InjectMocks in a test class.

Consider both annotations and mock initialization.

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