How to Use @ExtendWith MockitoExtension in JUnit Tests

Use @ExtendWith(MockitoExtension.class) on your JUnit 5 test class to enable Mockito support like @Mock and @InjectMocks. This extension initializes mocks automatically before each test, so you don't need to call MockitoAnnotations.openMocks(this) manually.

Syntax

The @ExtendWith(MockitoExtension.class) annotation tells JUnit 5 to use Mockito's extension to handle mock initialization.

• @ExtendWith: JUnit 5 annotation to register extensions.
• MockitoExtension.class: The Mockito extension class that initializes mocks.

Place this annotation on your test class to enable automatic mock creation and injection.

java

@ExtendWith(MockitoExtension.class)
public class MyServiceTest {

    @Mock
    private Dependency dependency;

    @InjectMocks
    private MyService myService;

    // test methods
}

Example

This example shows a simple JUnit 5 test class using @ExtendWith(MockitoExtension.class) to mock a dependency and verify behavior.

java

import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

@ExtendWith(MockitoExtension.class)
public class CalculatorServiceTest {

    @Mock
    private Calculator calculator;

    @InjectMocks
    private CalculatorService service;

    @Test
    void testAdd() {
        when(calculator.add(2, 3)).thenReturn(5);

        int result = service.addNumbers(2, 3);

        assertEquals(5, result);
        verify(calculator).add(2, 3);
    }
}

class Calculator {
    int add(int a, int b) { return a + b; }
}

class CalculatorService {
    private final Calculator calculator;

    CalculatorService(Calculator calculator) {
        this.calculator = calculator;
    }

    int addNumbers(int a, int b) {
        return calculator.add(a, b);
    }
}

Output

Test passed successfully with no errors.

Common Pitfalls

Common mistakes when using @ExtendWith(MockitoExtension.class) include:

• Forgetting to add the annotation on the test class, so mocks are not initialized.
• Using @Mock without @ExtendWith(MockitoExtension.class) or manual initialization.
• Mixing JUnit 4 @RunWith(MockitoJUnitRunner.class) with JUnit 5 tests.

Always use @ExtendWith(MockitoExtension.class) for JUnit 5 to avoid manual mock setup.

java

/* Wrong way: Missing @ExtendWith annotation */
public class WrongTest {
    @Mock
    private Dependency dep;

    @Test
    void test() {
        // dep is null, test fails
    }
}

/* Right way: Add @ExtendWith(MockitoExtension.class) */
@ExtendWith(MockitoExtension.class)
public class RightTest {
    @Mock
    private Dependency dep;

    @Test
    void test() {
        // dep is initialized
    }
}

Quick Reference

Summary tips for using @ExtendWith(MockitoExtension.class):

• Use on JUnit 5 test classes to enable Mockito annotations.
• Supports @Mock, @Spy, @InjectMocks automatically.
• No need to call MockitoAnnotations.openMocks(this) manually.
• Do not mix with JUnit 4 runners like @RunWith(MockitoJUnitRunner.class).

Key Takeaways

Add @ExtendWith(MockitoExtension.class) on your JUnit 5 test class to enable Mockito support.

This extension automatically initializes mocks annotated with @Mock and injects them.

Do not forget the annotation or mocks will be null and tests will fail.

Avoid mixing JUnit 4 Mockito runners with JUnit 5 extensions.

Use this to write clean, simple tests without manual mock setup.