@InjectMocks annotation in JUnit - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a mock object for the dependency.

JUnit

@Mock
private Service [1];

Drag options to blanks, or click blank then click option'

Aservice

BService

CmockService

DserviceMock

Attempts:

3 left

💡 Hint

Common Mistakes

Using the class name instead of a variable name.

Adding prefixes like 'mock' unnecessarily.

The field name 'service' is used to declare the mock object for the Service class.

2fill in blank

medium

Complete the code to inject mocks into the tested class.

JUnit

@InjectMocks
private [1] controller;

Drag options to blanks, or click blank then click option'

Aservice

Bcontroller

CService

DController

Attempts:

3 left

💡 Hint

Common Mistakes

Using the variable name instead of the class type.

Confusing the service class with the controller class.

The tested class type is 'Controller', and the variable name is 'controller'.

3fill in blank

hard

Fix the error in the test setup method to initialize mocks.

JUnit

@BeforeEach
void setUp() {
    MockitoAnnotations.[1](this);
}

Drag options to blanks, or click blank then click option'

AopenMocks

BinitMocks

CmockStatic

Dmock

Attempts:

3 left

💡 Hint

Common Mistakes

Using deprecated initMocks method.

Calling mockStatic instead of initializing instance mocks.

Since Mockito 3.4.0, MockitoAnnotations.openMocks(this) is the recommended way to initialize mocks.

4fill in blank

hard

Fill both blanks to correctly declare and inject mocks for dependencies.

JUnit

@Mock
private [1] repository;

@InjectMocks
private [2] service;

Drag options to blanks, or click blank then click option'

ARepository

BService

Crepository

Dservice

Attempts:

3 left

💡 Hint

Common Mistakes

Using variable names instead of class types for mocks.

Mixing up the order of mock and injectMocks declarations.

The mock is declared with the class type 'Repository' and injected into the 'Service' class.

5fill in blank

hard

Fill all three blanks to complete the test class setup with mocks and injection.

JUnit

class UserServiceTest {

    @Mock
    private [1] userRepository;

    @InjectMocks
    private [2] userService;

    @BeforeEach
    void init() {
        MockitoAnnotations.[3](this);
    }
}

Drag options to blanks, or click blank then click option'

AUserRepository

BUserService

CopenMocks

DinitMocks

Attempts:

3 left

💡 Hint

Common Mistakes

Using deprecated initMocks instead of openMocks.

Mixing variable names with class types in annotations.

Mocks are declared with UserRepository, injected into UserService, and initialized with MockitoAnnotations.openMocks(this).

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