Comment tester une application Spring Boot : @SpringBootTest, MockMvc, slices ?

Question

IT Interview Practice · Accepted Answer

Spring Boot vous offre une **pyramide de tests** : des tests unitaires rapides sans Spring, des tests *slice* ciblés qui chargent une partie du contexte, et quelques tests d'intégration à contexte complet. Choisir le bon niveau pour chaque test est la compétence senior ici.

## Test unitaire — pas de Spring du tout

L'injection par constructeur fait que la plupart de la logique de service ne nécessite aucun Spring ; il suffit de mocker les collaborateurs :

```java
@Test
void appliesDiscount() {
    var repo = mock(PriceRepository.class);
    when(repo.base("A")).thenReturn(BigDecimal.TEN);
    var svc = new PricingService(repo);          // simple constructeur, pas de contexte
    assertThat(svc.priceOf("A")).isEqualByComparingTo("9.00");
}
```

## Test slice — @WebMvcTest + MockMvc

Charge uniquement la couche web (contrôleurs, JSON, validation) — pas de base de données, pas de services au-delà des mocks. Rapide :

```java
@WebMvcTest(UserController.class)
class UserControllerTest {
    @Autowired MockMvc mvc;
    @MockBean UserService service; // le service est mocké, pas réel

@Test
    void returns404WhenMissing() throws Exception {
        when(service.findById(9L)).thenThrow(new EntityNotFoundException());
        mvc.perform(get("/api/users/9"))
           .andExpect(status().isNotFound()); // vérifie le câblage contrôleur + advice
    }
}
```

## @DataJpaTest — le slice de persistance

Charge JPA/les repositories contre une DB en mémoire (ou Testcontainers) et effectue un rollback après chaque 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();
    }
}
```

Utilisez `@SpringBootTest` (contexte complet, `webEnvironment = RANDOM_PORT`) avec parcimonie pour de vraies vérifications de bout en bout — c'est le plus lent.

## Pourquoi c'est important

Les recruteurs veulent vous voir éviter l'anti-pattern du `@SpringBootTest` pour *tout*, qui rend les suites lentes et fragiles. Nommer le bon slice pour chaque préoccupation, mocker avec `@MockBean`, et utiliser **Testcontainers** pour une vraie base de données plutôt que H2 signale quelqu'un qui garde une grande suite de tests rapide et digne de confiance.

Test unitaire — pas de Spring du tout

Test slice — @WebMvcTest + MockMvc

@DataJpaTest — le slice de persistance

Pourquoi c'est important

Questions connexes