Testing Spring Boot Applications

Spring Boot applications benefit from testing at different levels of the stack — a full integration test that boots the entire application context is thorough but slow, while a narrowly focused slice test loads only what's needed for one layer and runs much faster. Spring Boot Test provides annotations for exactly this range of granularity, built on JUnit Jupiter, Mockito, and AssertJ (bundled in spring-boot-starter-test; Spring Boot 4 also provides per-technology test starters such as spring-boot-starter-webmvc-test and spring-boot-starter-data-jpa-test). The lessons in this module cover each level in depth.

@SpringBootTest — Full Integration Tests

@SpringBootTest boots the entire Spring ApplicationContext, exactly like the real running application, making it suitable for true end-to-end integration tests. It's the slowest test type since it wires up every bean, so it should be used deliberately rather than for every test class — typically for a handful of tests that verify the whole system works together, often combined with webEnvironment = RANDOM_PORT and a real HTTP client for true black-box testing.

@WebMvcTest — Controller Slice Tests

@WebMvcTest(ControllerClass.class) loads only the Spring MVC infrastructure and the specified controller, without starting the full context (no real database, no service beans unless mocked). Combined with MockMvc, it lets you send simulated HTTP requests and assert on status codes, headers, and JSON response bodies quickly, while service dependencies are supplied as @MockitoBean (Spring Boot 4 removed the older @MockBean).

@DataJpaTest — Repository Slice Tests

@DataJpaTest configures only the JPA-related components — an in-memory embedded database (by default), your repository interfaces, and Hibernate — without loading controllers or unrelated services. Each test method runs inside a transaction that's rolled back afterward, keeping tests isolated from each other without manual cleanup.

Example

@WebMvcTest(ProductController.class)
class ProductControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockitoBean
    private ProductService productService;

    @Test
    void getById_returnsProduct_whenFound() throws Exception {
        when(productService.findById(5L))
                .thenReturn(Optional.of(new Product(5L, "Wireless Mouse", new BigDecimal("19.99"))));

        mockMvc.perform(get("/api/products/5"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.name").value("Wireless Mouse"));
    }
}

@DataJpaTest
class ProductRepositoryTest {

    @Autowired
    private ProductRepository repository;

    @Test
    void findByCategory_returnsMatchingProducts() {
        repository.save(new Product(null, "Keyboard", "Electronics", new BigDecimal("45.00")));
        repository.save(new Product(null, "Desk Lamp", "Home", new BigDecimal("22.00")));

        List<Product> results = repository.findByCategory("Electronics");

        assertThat(results).hasSize(1);
        assertThat(results.get(0).getName()).isEqualTo("Keyboard");
    }
}

ProductControllerTest > getById_returnsProduct_whenFound() PASSED
ProductRepositoryTest > findByCategory_returnsMatchingProducts() PASSED

Tests run: 2, Failures: 0, Errors: 0, Skipped: 0

Exercise

A teammate is about to make this mistake: Using @SpringBootTest for every test class, causing the full application context to boot repeatedly and slowing the test suite dramatically as the project grows. Use @SpringBootTest — Full Integration Tests to review the decision. Write a corrected implementation or design sketch that follows @SpringBootTest boots the full application context — thorough but slow, best used for true integration tests., then name one edge case you would check.

Quick quiz

Interview questions