How do I use Mockito with JUnit?

To use Mockito with JUnit, you add Mockito to your test dependencies, enable Mockito in your JUnit test class, then create mocks and define their behavior.

Below is a simple JUnit 5 + Mockito example.

1. Add Dependencies

Maven

<dependencies>
    <!-- JUnit 5 -->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>5.11.4</version>
        <scope>test</scope>
    </dependency>

    <!-- Mockito Core -->
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-core</artifactId>
        <version>5.14.2</version>
        <scope>test</scope>
    </dependency>

    <!-- Mockito integration for JUnit 5 -->
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-junit-jupiter</artifactId>
        <version>5.14.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Make sure your Maven Surefire plugin supports JUnit 5:

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>3.5.2</version>
        </plugin>
    </plugins>
</build>

Gradle

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter:5.11.4'
    testImplementation 'org.mockito:mockito-core:5.14.2'
    testImplementation 'org.mockito:mockito-junit-jupiter:5.14.2'
}

test {
    useJUnitPlatform()
}

---

2. Example Class to Test

Suppose you have a service that depends on a repository.

public class User {
    private final Long id;
    private final String name;

    public User(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

import java.util.Optional;

public interface UserRepository {
    Optional<User> findById(Long id);
}

public class UserService {
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public String getUserName(Long id) {
        return userRepository.findById(id)
                .map(User::getName)
                .orElse("Unknown User");
    }
}

---

3. Write a Mockito Test with JUnit 5

Use @ExtendWith(MockitoExtension.class) to enable Mockito support.

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;

import java.util.Optional;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

    @Test
    void shouldReturnUserNameWhenUserExists() {
        User user = new User(1L, "Alice");

        when(userRepository.findById(1L))
                .thenReturn(Optional.of(user));

        String result = userService.getUserName(1L);

        assertEquals("Alice", result);
        verify(userRepository).findById(1L);
    }

    @Test
    void shouldReturnUnknownUserWhenUserDoesNotExist() {
        when(userRepository.findById(99L))
                .thenReturn(Optional.empty());

        String result = userService.getUserName(99L);

        assertEquals("Unknown User", result);
        verify(userRepository).findById(99L);
    }
}

---

4. What the Mockito Annotations Mean

Annotation	Purpose
@Mock	Creates a mock object
@InjectMocks	Creates the class under test and injects mocks into it
@ExtendWith(MockitoExtension.class)	Enables Mockito support in JUnit 5

---

5. Common Mockito Methods

when(...).thenReturn(...)

Used to define mock behavior.

when(userRepository.findById(1L))
        .thenReturn(Optional.of(new User(1L, "Alice")));

verify(...)

Used to check whether a method was called.

verify(userRepository).findById(1L);

verify(..., times(...))

Used to check how many times a method was called.

verify(userRepository, times(1)).findById(1L);

You need this static import:

import static org.mockito.Mockito.times;

---

6. Mockito Without Annotations

You can also create mocks manually.

import org.junit.jupiter.api.Test;

import java.util.Optional;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

class UserServiceManualMockTest {

    @Test
    void shouldReturnUserName() {
        UserRepository userRepository = mock(UserRepository.class);
        UserService userService = new UserService(userRepository);

        when(userRepository.findById(1L))
                .thenReturn(Optional.of(new User(1L, "Alice")));

        String result = userService.getUserName(1L);

        assertEquals("Alice", result);
    }
}

---

7. Typical Mockito Test Structure

A clean Mockito test usually follows the Arrange, Act, Assert pattern:

@Test
void shouldReturnUserName() {
    // Arrange
    User user = new User(1L, "Alice");
    when(userRepository.findById(1L)).thenReturn(Optional.of(user));

    // Act
    String result = userService.getUserName(1L);

    // Assert
    assertEquals("Alice", result);
    verify(userRepository).findById(1L);
}

---

Summary

To use Mockito with JUnit 5:

1. Add mockito-core and mockito-junit-jupiter.
2. Add @ExtendWith(MockitoExtension.class) to your test class.
3. Use @Mock for dependencies.
4. Use @InjectMocks for the class being tested.
5. Use when(...).thenReturn(...) to define behavior.
6. Use verify(...) to check interactions.