Testing with @SpringBootTest

Introduction

A Spring Boot application is only as trustworthy as its tests. Boot ships with the spring-boot-starter-test dependency, which bundles JUnit 5, Mockito, AssertJ, and Spring's own testing support in a single starter. In this lesson you will write a plain unit test for a service, then an integration test with @SpringBootTest that loads the real application context, and finally a controller test with MockMvc that exercises the web layer without starting an actual HTTP server.

Testing Levels in Spring Boot

Spring Boot tests generally fall into three levels, each trading off speed against realism. Unit tests are the fastest and should make up the bulk of your test suite; full integration tests are the slowest and should be used more sparingly, for the flows that matter most.

Unit Testing a Service

A pure unit test does not involve Spring at all. Because TaskService uses constructor injection, you can create it directly with new and pass in a mocked repository.

@ExtendWith(MockitoExtension.class)
class TaskServiceTest {

    @Mock
    private TaskRepository taskRepository;

    private TaskService taskService;

    @BeforeEach
    void setUp() {
        taskService = new TaskService(taskRepository);
    }

    @Test
    void findAll_returnsTasksFromRepository() {
        Task task = new Task(1L, "Write lesson", false);
        when(taskRepository.findAll()).thenReturn(List.of(task));

        List<Task> result = taskService.findAll();

        assertThat(result).hasSize(1);
        assertThat(result.get(0).getTitle()).isEqualTo("Write lesson");
    }
}

@SpringBootTest

@SpringBootTest boots the entire Spring application context, exactly as it would start in production, and lets you inject real beans into the test. It is the closest a test gets to running the whole application, which makes it slower but valuable for verifying that everything wires together correctly.

@SpringBootTest
class TaskApplicationTests {

    @Autowired
    private TaskService taskService;

    @Test
    void contextLoads() {
        assertThat(taskService).isNotNull();
    }
}

Testing Controllers with MockMvc

MockMvc lets you send simulated HTTP requests directly to your controllers without starting a real servlet container, which makes controller tests fast while still exercising request mapping, validation, and JSON serialization.

@SpringBootTest
@AutoConfigureMockMvc
class TaskControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private TaskService taskService;

    @Test
    void getAllTasks_returnsJsonArray() throws Exception {
        when(taskService.findAll())
                .thenReturn(List.of(new Task(1L, "Write lesson", false)));

        mockMvc.perform(get("/api/tasks"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$[0].title").value("Write lesson"));
    }
}

@MockBean replaces the real TaskService bean in the application context with a Mockito mock, so the test exercises the actual controller and its request mapping while stubbing out the business logic underneath.

Using a Test Profile

Tests often need different configuration than production - an in-memory database instead of a real one, for example. Create an application-test.properties file and activate it with @ActiveProfiles so tests never touch real infrastructure.

# src/test/resources/application-test.properties
spring.datasource.url=jdbc:h2:mem:testdb
spring.jpa.hibernate.ddl-auto=create-drop

@SpringBootTest
@ActiveProfiles("test")
class TaskRepositoryIntegrationTest {

    @Autowired
    private TaskRepository taskRepository;

    @Test
    void save_persistsTask() {
        Task saved = taskRepository.save(new Task(null, "Integration test", false));
        assertThat(saved.getId()).isNotNull();
    }
}

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Spring Boot gives you everything needed to test at every level: fast unit tests for isolated logic, MockMvc for the web layer, and @SpringBootTest for full integration coverage. A healthy test suite leans heavily on the fast layers and uses full context tests sparingly, for the paths that matter most.