Como testar um app Spring Boot: @SpringBootTest, MockMvc, slices?

Question

IT Interview Practice · Accepted Answer

O Spring Boot te dá uma **pirâmide de testes**: testes unitários rápidos sem Spring, testes de *slice* focados que carregam parte do contexto, e alguns poucos testes de integração de contexto completo. Escolher o nível certo por teste é a habilidade sênior aqui.

## Teste unitário — sem Spring nenhum

A injeção por construtor faz com que a maior parte da lógica de serviço não precise de Spring; basta mockar os colaboradores:

```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");
}
```

## Teste de slice — @WebMvcTest + MockMvc

Carrega apenas a camada web (controllers, JSON, validação) — sem banco, sem serviços além de mocks. Rápido:

```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 — o slice de persistência

Carrega o JPA/repositórios contra um banco em memória (ou Testcontainers) e faz rollback depois de cada teste:

```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` (contexto completo, `webEnvironment = RANDOM_PORT`) com parcimônia para verificações realmente ponta a ponta — é o mais lento.

## Por que isso importa

Os entrevistadores querem ver você evitar o antipadrão de usar `@SpringBootTest` para *tudo*, o que deixa as suítes lentas e frágeis. Nomear o slice certo por preocupação, mockar com `@MockBean` e usar **Testcontainers** para um banco real em vez do H2 sinaliza alguém que mantém uma grande suíte de testes rápida e confiável.

Teste unitário — sem Spring nenhum

Teste de slice — @WebMvcTest + MockMvc

@DataJpaTest — o slice de persistência

Por que isso importa

Perguntas relacionadas