Mockito and Testing Spring Applications

A unit test for a service class shouldn't also need a real database, a real HTTP call to another service, or a fully started Spring application — any of those turns a fast, focused unit test into a slow, brittle integration test. Mockito is the standard Java mocking framework: it creates fake ("mock") implementations of a class's dependencies, so you can test one class's logic completely in isolation.

Why it matters

A service that calls a database or another API cannot be unit-tested as it stands: the test would be slow and would fail whenever the dependency was unavailable. A mock stands in for the dependency and returns what the test tells it to. Mockito is the standard tool for this in Java and is assumed knowledge in Spring projects.

Mock vs. Stub vs. Spy

• Stub — an object that returns pre-programmed, canned answers; a test doesn't verify how it was called, only that it supplied the data needed.
• Mock — a fake object whose interactions you explicitly verify: how many times a method was called, and with what arguments.
• Spy — wraps a real object, letting its real methods run by default, with the option to override specific method calls — useful when you want mostly-real behavior with one method faked.

The Core Mockito API

@Mock creates a fake instance of a dependency's type. @InjectMocks creates a real instance of the class under test and automatically injects the @Mock-annotated fields into it (via constructor or setter injection, whichever the class supports). when(...).thenReturn(...) programs a mock's canned response. verify(mock, times(n)).method(...) asserts a method was actually called the expected number of times with the expected arguments.

Testing a Spring Boot Application at Different Levels

Spring Boot Test offers focused testing slices instead of forcing every test to load the entire application context. @ExtendWith(MockitoExtension.class) (no Spring context at all) is the fastest option for pure business-logic unit tests. @WebMvcTest(SomeController.class) loads only the web layer, letting you test a controller's request/response handling with MockMvc while mocking out its service dependencies with @MockBean. @SpringBootTest loads the full application context and is reserved for true integration tests, since it's significantly slower to start than the more targeted slices.

Example

// Pure unit test — no Spring context, fastest to run
@ExtendWith(MockitoExtension.class)
class StudentServiceTest {

    @Mock private StudentRepository repo;
    @InjectMocks private StudentService service;

    @Test
    void toppersReturnsOnlyStudentsAboveNinety() {
        when(repo.findByMarksGreaterThan(90))
            .thenReturn(List.of(new Student(1, "Vansh", 95)));

        List<Student> result = service.toppers();

        assertEquals(1, result.size());
        assertEquals("Vansh", result.get(0).getName());
        verify(repo, times(1)).findByMarksGreaterThan(90);
    }
}

// Web-layer slice test — loads only Spring MVC infrastructure, mocks the service
@WebMvcTest(StudentController.class)
class StudentControllerTest {

    @Autowired private MockMvc mvc;
    @MockBean private StudentService service;

    @Test
    void getByIdReturns200WithJsonBody() throws Exception {
        when(service.findById(1)).thenReturn(Optional.of(new Student(1, "Vansh", 95)));

        mvc.perform(get("/api/students/1"))
           .andExpect(status().isOk())
           .andExpect(jsonPath("$.name").value("Vansh"));
    }

    @Test
    void getByIdReturns404WhenMissing() throws Exception {
        when(service.findById(99)).thenReturn(Optional.empty());

        mvc.perform(get("/api/students/99"))
           .andExpect(status().isNotFound());
    }
}

StudentServiceTest > toppersReturnsOnlyStudentsAboveNinety() PASSED
StudentControllerTest > getByIdReturns200WithJsonBody() PASSED
StudentControllerTest > getByIdReturns404WhenMissing() PASSED

Exercise

This exercise needs JUnit 5 and Mockito on the classpath, so it does not run in the playground. UserService.displayName looks a user up in UserRepository and returns the name in upper case, or UNKNOWN when there is no such user. Write a test that mocks the repository, stubs findName(1L) to return asha, checks the result, and verifies that the repository was called.

Expected result: the test passes without any database.

import java.util.Optional;

interface UserRepository {
    Optional<String> findName(long id);
}

class UserService {
    private final UserRepository repository;

    UserService(UserRepository repository) {
        this.repository = repository;
    }

    String displayName(long id) {
        return repository.findName(id).map(String::toUpperCase).orElse("UNKNOWN");
    }
}

// UserServiceTest.java
// TODO: a test class using MockitoExtension, a mocked repository and the service under test

import java.util.Optional;

interface UserRepository {
    Optional<String> findName(long id);
}

class UserService {
    private final UserRepository repository;

    UserService(UserRepository repository) {
        this.repository = repository;
    }

    String displayName(long id) {
        return repository.findName(id).map(String::toUpperCase).orElse("UNKNOWN");
    }
}

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

import java.util.Optional;
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)
class UserServiceTest {

    @Mock
    private UserRepository repository;

    @InjectMocks
    private UserService service;

    @Test
    void returnsTheNameInUpperCase() {
        when(repository.findName(1L)).thenReturn(Optional.of("asha"));

        assertEquals("ASHA", service.displayName(1L));

        verify(repository).findName(1L);
    }
}

Quick quiz

Interview questions