ஒரு Spring Boot app-ஐ எவ்வாறு test செய்வது: @SpringBootTest, MockMvc, slice-கள்?

Question

IT Interview Practice · Accepted Answer

Spring Boot உங்களுக்கு ஒரு **testing pyramid**-ஐ வழங்குகிறது: Spring இல்லாத வேகமான unit test-கள், context-இன் ஒரு பகுதியை load செய்யும் focused *slice* test-கள், மற்றும் சில முழு-context integration test-கள். ஒவ்வொரு test-க்கும் சரியான நிலையைத் தேர்ந்தெடுப்பது இங்குள்ள senior திறமை.

## Unit test — Spring அறவே இல்லை

Constructor injection என்றால், பெரும்பாலான service logic-க்கு சுழிய (zero) Spring தேவை; வெறுமனே collaborator-களை mock செய்யுங்கள்:

```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

Web layer-ஐ மட்டும் load செய்கிறது (controllers, JSON, validation) — database இல்லை, mock-களைத் தாண்டி service-கள் இல்லை. வேகமானது:

```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 — persistence slice

JPA/repository-களை ஒரு in-memory (அல்லது Testcontainers) DB-க்கு எதிராக load செய்து, ஒவ்வொரு test-க்குப் பிறகும் roll back செய்கிறது:

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

உண்மையான end-to-end சோதனைகளுக்காக `@SpringBootTest`-ஐ (முழு context, `webEnvironment = RANDOM_PORT`) குறைவாகப் பயன்படுத்துங்கள் — அது மிகவும் மெதுவானது.

## இது ஏன் முக்கியம்

*எல்லாவற்றிற்கும்* `@SpringBootTest` என்ற anti-pattern-ஐ நீங்கள் தவிர்க்கிறீர்களா என்பதை interviewer-கள் பார்க்க விரும்புகிறார்கள், அது suite-களை மெதுவாகவும் உடையக்கூடியதாகவும் ஆக்குகிறது. ஒவ்வொரு concern-க்கும் சரியான slice-ஐப் பெயரிடுவது, `@MockBean`-உடன் mock செய்வது, மற்றும் H2-க்குப் பதிலாக ஒரு உண்மையான database-க்கு **Testcontainers**-ஐப் பயன்படுத்துவது, ஒரு பெரிய test suite-ஐ வேகமாகவும் நம்பகமாகவும் வைத்திருக்கும் ஒருவரைக் குறிக்கிறது.

Unit test — Spring அறவே இல்லை

Slice test — @WebMvcTest + MockMvc

@DataJpaTest — persistence slice

இது ஏன் முக்கியம்

தொடர்புடைய கேள்விகள்