1# Testing - Spring Boot Test
2 
3## Unit Testing with JUnit 5
4 
5```java
6@ExtendWith(MockitoExtension.class)
7class UserServiceTest {
8 
9    @Mock
10    private UserRepository userRepository;
11 
12    @Mock
13    private PasswordEncoder passwordEncoder;
14 
15    @InjectMocks
16    private UserService userService;
17 
18    @Test
19    @DisplayName("Should create user successfully")
20    void shouldCreateUser() {
21        // Given
22        UserCreateRequest request = new UserCreateRequest(
23            "[email protected]",
24            "Password123",
25            "testuser",
26            25
27        );
28 
29        User user = User.builder()
30            .id(1L)
31            .email(request.email())
32            .username(request.username())
33            .build();
34 
35        when(userRepository.existsByEmail(request.email())).thenReturn(false);
36        when(passwordEncoder.encode(request.password())).thenReturn("encodedPassword");
37        when(userRepository.save(any(User.class))).thenReturn(user);
38 
39        // When
40        UserResponse response = userService.create(request);
41 
42        // Then
43        assertThat(response).isNotNull();
44        assertThat(response.email()).isEqualTo(request.email());
45 
46        verify(userRepository).existsByEmail(request.email());
47        verify(passwordEncoder).encode(request.password());
48        verify(userRepository).save(any(User.class));
49    }
50 
51    @Test
52    @DisplayName("Should throw exception when email already exists")
53    void shouldThrowExceptionWhenEmailExists() {
54        // Given
55        UserCreateRequest request = new UserCreateRequest(
56            "[email protected]",
57            "Password123",
58            "testuser",
59            25
60        );
61 
62        when(userRepository.existsByEmail(request.email())).thenReturn(true);
63 
64        // When & Then
65        assertThatThrownBy(() -> userService.create(request))
66            .isInstanceOf(DuplicateResourceException.class)
67            .hasMessageContaining("Email already registered");
68 
69        verify(userRepository, never()).save(any(User.class));
70    }
71}
72```
73 
74## Integration Testing with @SpringBootTest
75 
76```java
77@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
78@ActiveProfiles("test")
79@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
80class UserIntegrationTest {
81 
82    @Autowired
83    private TestRestTemplate restTemplate;
84 
85    @Autowired
86    private UserRepository userRepository;
87 
88    @BeforeEach
89    void setUp() {
90        userRepository.deleteAll();
91    }
92 
93    @Test
94    @Order(1)
95    @DisplayName("Should create user via API")
96    void shouldCreateUserViaApi() {
97        // Given
98        UserCreateRequest request = new UserCreateRequest(
99            "[email protected]",
100            "Password123",
101            "testuser",
102            25
103        );
104 
105        // When
106        ResponseEntity<UserResponse> response = restTemplate.postForEntity(
107            "/api/v1/users",
108            request,
109            UserResponse.class
110        );
111 
112        // Then
113        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
114        assertThat(response.getBody()).isNotNull();
115        assertThat(response.getBody().email()).isEqualTo(request.email());
116        assertThat(response.getHeaders().getLocation()).isNotNull();
117    }
118 
119    @Test
120    @Order(2)
121    @DisplayName("Should return validation error for invalid request")
122    void shouldReturnValidationError() {
123        // Given
124        UserCreateRequest request = new UserCreateRequest(
125            "invalid-email",
126            "short",
127            "u",
128            15
129        );
130 
131        // When
132        ResponseEntity<ValidationErrorResponse> response = restTemplate.postForEntity(
133            "/api/v1/users",
134            request,
135            ValidationErrorResponse.class
136        );
137 
138        // Then
139        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
140        assertThat(response.getBody()).isNotNull();
141        assertThat(response.getBody().errors()).isNotEmpty();
142    }
143}
144```
145 
146## Web Layer Testing with MockMvc
147 
148```java
149@WebMvcTest(UserController.class)
150@Import(SecurityConfig.class)
151class UserControllerTest {
152 
153    @Autowired
154    private MockMvc mockMvc;
155 
156    @MockBean
157    private UserService userService;
158 
159    @Autowired
160    private ObjectMapper objectMapper;
161 
162    @Test
163    @WithMockUser(roles = "ADMIN")
164    @DisplayName("Should get all users")
165    void shouldGetAllUsers() throws Exception {
166        // Given
167        Page<UserResponse> users = new PageImpl<>(List.of(
168            new UserResponse(1L, "[email protected]", "user1", 25, true, null, null),
169            new UserResponse(2L, "[email protected]", "user2", 30, true, null, null)
170        ));
171 
172        when(userService.findAll(any(Pageable.class))).thenReturn(users);
173 
174        // When & Then
175        mockMvc.perform(get("/api/v1/users")
176                .contentType(MediaType.APPLICATION_JSON))
177            .andExpect(status().isOk())
178            .andExpect(jsonPath("$.content").isArray())
179            .andExpect(jsonPath("$.content.length()").value(2))
180            .andExpect(jsonPath("$.content[0].email").value("[email protected]"))
181            .andDo(print());
182    }
183 
184    @Test
185    @WithMockUser(roles = "ADMIN")
186    @DisplayName("Should create user")
187    void shouldCreateUser() throws Exception {
188        // Given
189        UserCreateRequest request = new UserCreateRequest(
190            "[email protected]",
191            "Password123",
192            "testuser",
193            25
194        );
195 
196        UserResponse response = new UserResponse(
197            1L,
198            request.email(),
199            request.username(),
200            request.age(),
201            true,
202            LocalDateTime.now(),
203            LocalDateTime.now()
204        );
205 
206        when(userService.create(any(UserCreateRequest.class))).thenReturn(response);
207 
208        // When & Then
209        mockMvc.perform(post("/api/v1/users")
210                .contentType(MediaType.APPLICATION_JSON)
211                .content(objectMapper.writeValueAsString(request)))
212            .andExpect(status().isCreated())
213            .andExpect(header().exists("Location"))
214            .andExpect(jsonPath("$.email").value(request.email()))
215            .andExpect(jsonPath("$.username").value(request.username()))
216            .andDo(print());
217    }
218 
219    @Test
220    @WithMockUser(roles = "USER")
221    @DisplayName("Should return 403 for non-admin user")
222    void shouldReturn403ForNonAdmin() throws Exception {
223        mockMvc.perform(get("/api/v1/users")
224                .contentType(MediaType.APPLICATION_JSON))
225            .andExpect(status().isForbidden());
226    }
227}
228```
229 
230## Data JPA Testing
231 
232```java
233@DataJpaTest
234@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
235@ActiveProfiles("test")
236class UserRepositoryTest {
237 
238    @Autowired
239    private UserRepository userRepository;
240 
241    @Autowired
242    private TestEntityManager entityManager;
243 
244    @Test
245    @DisplayName("Should find user by email")
246    void shouldFindUserByEmail() {
247        // Given
248        User user = User.builder()
249            .email("[email protected]")
250            .password("password")
251            .username("testuser")
252            .active(true)
253            .build();
254 
255        entityManager.persistAndFlush(user);
256 
257        // When
258        Optional<User> found = userRepository.findByEmail("[email protected]");
259 
260        // Then
261        assertThat(found).isPresent();
262        assertThat(found.get().getEmail()).isEqualTo("[email protected]");
263    }
264 
265    @Test
266    @DisplayName("Should check if email exists")
267    void shouldCheckIfEmailExists() {
268        // Given
269        User user = User.builder()
270            .email("[email protected]")
271            .password("password")
272            .username("testuser")
273            .active(true)
274            .build();
275 
276        entityManager.persistAndFlush(user);
277 
278        // When
279        boolean exists = userRepository.existsByEmail("[email protected]");
280 
281        // Then
282        assertThat(exists).isTrue();
283    }
284 
285    @Test
286    @DisplayName("Should fetch user with roles")
287    void shouldFetchUserWithRoles() {
288        // Given
289        Role adminRole = Role.builder().name("ADMIN").build();
290        entityManager.persist(adminRole);
291 
292        User user = User.builder()
293            .email("[email protected]")
294            .password("password")
295            .username("admin")
296            .active(true)
297            .roles(Set.of(adminRole))
298            .build();
299 
300        entityManager.persistAndFlush(user);
301        entityManager.clear();
302 
303        // When
304        Optional<User> found = userRepository.findByEmailWithRoles("[email protected]");
305 
306        // Then
307        assertThat(found).isPresent();
308        assertThat(found.get().getRoles()).hasSize(1);
309        assertThat(found.get().getRoles()).extracting(Role::getName).contains("ADMIN");
310    }
311}
312```
313 
314## Testcontainers for Database
315 
316```java
317@SpringBootTest
318@Testcontainers
319@ActiveProfiles("test")
320class UserServiceIntegrationTest {
321 
322    @Container
323    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15-alpine")
324        .withDatabaseName("testdb")
325        .withUsername("test")
326        .withPassword("test");
327 
328    @DynamicPropertySource
329    static void configureProperties(DynamicPropertyRegistry registry) {
330        registry.add("spring.datasource.url", postgres::getJdbcUrl);
331        registry.add("spring.datasource.username", postgres::getUsername);
332        registry.add("spring.datasource.password", postgres::getPassword);
333    }
334 
335    @Autowired
336    private UserService userService;
337 
338    @Autowired
339    private UserRepository userRepository;
340 
341    @BeforeEach
342    void setUp() {
343        userRepository.deleteAll();
344    }
345 
346    @Test
347    @DisplayName("Should create and find user in real database")
348    void shouldCreateAndFindUser() {
349        // Given
350        UserCreateRequest request = new UserCreateRequest(
351            "[email protected]",
352            "Password123",
353            "testuser",
354            25
355        );
356 
357        // When
358        UserResponse created = userService.create(request);
359        UserResponse found = userService.findById(created.id());
360 
361        // Then
362        assertThat(found).isNotNull();
363        assertThat(found.email()).isEqualTo(request.email());
364    }
365}
366```
367 
368## Testing Reactive Endpoints with WebTestClient
369 
370```java
371@WebFluxTest(UserReactiveController.class)
372class UserReactiveControllerTest {
373 
374    @Autowired
375    private WebTestClient webTestClient;
376 
377    @MockBean
378    private UserReactiveService userService;
379 
380    @Test
381    @DisplayName("Should get user reactively")
382    void shouldGetUserReactively() {
383        // Given
384        UserResponse user = new UserResponse(
385            1L,
386            "[email protected]",
387            "testuser",
388            25,
389            true,
390            LocalDateTime.now(),
391            LocalDateTime.now()
392        );
393 
394        when(userService.findById(1L)).thenReturn(Mono.just(user));
395 
396        // When & Then
397        webTestClient.get()
398            .uri("/api/v1/users/{id}", 1L)
399            .accept(MediaType.APPLICATION_JSON)
400            .exchange()
401            .expectStatus().isOk()
402            .expectBody(UserResponse.class)
403            .value(response -> {
404                assertThat(response.id()).isEqualTo(1L);
405                assertThat(response.email()).isEqualTo("[email protected]");
406            });
407    }
408 
409    @Test
410    @DisplayName("Should create user reactively")
411    void shouldCreateUserReactively() {
412        // Given
413        UserCreateRequest request = new UserCreateRequest(
414            "[email protected]",
415            "Password123",
416            "testuser",
417            25
418        );
419 
420        UserResponse response = new UserResponse(
421            1L,
422            request.email(),
423            request.username(),
424            request.age(),
425            true,
426            LocalDateTime.now(),
427            LocalDateTime.now()
428        );
429 
430        when(userService.create(any(UserCreateRequest.class))).thenReturn(Mono.just(response));
431 
432        // When & Then
433        webTestClient.post()
434            .uri("/api/v1/users")
435            .contentType(MediaType.APPLICATION_JSON)
436            .body(Mono.just(request), UserCreateRequest.class)
437            .exchange()
438            .expectStatus().isCreated()
439            .expectHeader().exists("Location")
440            .expectBody(UserResponse.class)
441            .value(user -> {
442                assertThat(user.email()).isEqualTo(request.email());
443            });
444    }
445}
446```
447 
448## Testing Configuration
449 
450```java
451// application-test.yml
452spring:
453  datasource:
454    url: jdbc:h2:mem:testdb
455    driver-class-name: org.h2.Driver
456  jpa:
457    hibernate:
458      ddl-auto: create-drop
459    show-sql: true
460    properties:
461      hibernate:
462        format_sql: true
463  security:
464    user:
465      name: test
466      password: test
467 
468logging:
469  level:
470    org.hibernate.SQL: DEBUG
471    org.hibernate.type.descriptor.sql.BasicBinder: TRACE
472 
473// Test Configuration Class
474@TestConfiguration
475public class TestConfig {
476 
477    @Bean
478    @Primary
479    public PasswordEncoder passwordEncoder() {
480        return new BCryptPasswordEncoder(4); // Faster for tests
481    }
482 
483    @Bean
484    public Clock fixedClock() {
485        return Clock.fixed(
486            Instant.parse("2024-01-01T00:00:00Z"),
487            ZoneId.of("UTC")
488        );
489    }
490}
491```
492 
493## Test Fixtures with @DataJpaTest
494 
495```java
496@Component
497public class TestDataFactory {
498 
499    public static User createUser(String email, String username) {
500        return User.builder()
501            .email(email)
502            .password("encodedPassword")
503            .username(username)
504            .active(true)
505            .createdAt(LocalDateTime.now())
506            .updatedAt(LocalDateTime.now())
507            .build();
508    }
509 
510    public static UserCreateRequest createUserRequest() {
511        return new UserCreateRequest(
512            "[email protected]",
513            "Password123",
514            "testuser",
515            25
516        );
517    }
518}
519```
520 
521## Quick Reference
522 
523| Annotation | Purpose |
524|------------|---------|
525| `@SpringBootTest` | Full application context integration test |
526| `@WebMvcTest` | Test MVC controllers with mocked services |
527| `@WebFluxTest` | Test reactive controllers |
528| `@DataJpaTest` | Test JPA repositories with in-memory database |
529| `@MockBean` | Add mock bean to Spring context |
530| `@WithMockUser` | Mock authenticated user for security tests |
531| `@Testcontainers` | Enable Testcontainers support |
532| `@ActiveProfiles` | Activate specific Spring profiles for test |
533 
534## Testing Best Practices
535 
536- Write tests following AAA pattern (Arrange, Act, Assert)
537- Use descriptive test names with @DisplayName
538- Mock external dependencies, use real DB with Testcontainers
539- Achieve 85%+ code coverage
540- Test happy path and edge cases
541- Use @Transactional for test data cleanup
542- Separate unit tests from integration tests
543- Use parameterized tests for multiple scenarios
544- Test security rules and validation
545- Keep tests fast and independent
546