How do you test a Spring Boot app: @SpringBootTest, MockMvc, slices?

Question

IT Interview Practice · Accepted Answer

Spring Boot gives you a **testing pyramid**: fast unit tests with no Spring, focused *slice* tests that load part of the context, and a few full-context integration tests. Picking the right level per test is the senior skill here.

## Unit test — no Spring at all

Constructor injection means most service logic needs zero Spring; just mock collaborators:

```java
@Test
void appliesDiscount() {
    var repo = mock(PriceRepository.class);
    when(repo.base("A")).thenReturn(BigDecimal.TEN);
    var svc = new PricingService(repo);          // plain constructor, no context
    assertThat(svc.priceOf("A")).isEqualByComparingTo("9.00");
}
```

## Slice test — @WebMvcTest + MockMvc

Loads only the web layer (controllers, JSON, validation) — no database, no services beyond mocks. Fast:

```java
@WebMvcTest(UserController.class)
class UserControllerTest {
    @Autowired MockMvc mvc;
    @MockBean UserService service; // service is mocked, not real

@Test
    void returns404WhenMissing() throws Exception {
        when(service.findById(9L)).thenThrow(new EntityNotFoundException());
        mvc.perform(get("/api/users/9"))
           .andExpect(status().isNotFound()); // verifies controller + advice wiring
    }
}
```

## @DataJpaTest — the persistence slice

Loads JPA/repositories against an in-memory (or Testcontainers) DB and rolls back after each test:

```java
@DataJpaTest
class UserRepositoryTest {
    @Autowired UserRepository repo;
    @Test void findsByEmail() {
        repo.save(new User("a@x.com"));
        assertThat(repo.findByEmail("a@x.com")).isPresent();
    }
}
```

Use `@SpringBootTest` (full context, `webEnvironment = RANDOM_PORT`) sparingly for true end-to-end checks — it is the slowest.

## Why it matters

Interviewers want to see you avoid the anti-pattern of `@SpringBootTest` for *everything*, which makes suites slow and brittle. Naming the right slice per concern, mocking with `@MockBean`, and using **Testcontainers** for a real database instead of H2 signals someone who keeps a large test suite fast and trustworthy.

Unit test — no Spring at all

Slice test — @WebMvcTest + MockMvc

@DataJpaTest — the persistence slice

Why it matters

Related questions