MACRO NEPAL
Spring Boot Test Slices in Java
awiskar acharya
November 6, 2025
3:13 pm

Introduction

Spring Boot Test Slices are specialized testing annotations that load only specific parts of your application context, making tests faster and more focused. Instead of loading the entire application context, slices allow you to test specific layers (web, data, security) in isolation.

Maven Dependencies

<dependencies>
<!-- Spring Boot Test Starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!-- Testcontainers for integration tests -->
<dependency>
<groupId>org.testcontainers</groupId>
<artifactId>junit-jupiter</artifactId>
<scope>test</scope>
</dependency>
<!-- Database testing -->
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>test</scope>
</dependency>
</dependencies>

Data Layer Testing

@DataJpaTest - JPA Repository Testing

import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;
@DataJpaTest
class UserRepositoryTest {
@Autowired
private TestEntityManager entityManager;
@Autowired
private UserRepository userRepository;
@Test
void whenFindByEmail_thenReturnUser() {
// given
User user = User.builder()
.email("[email protected]")
.firstName("John")
.lastName("Doe")
.build();
entityManager.persist(user);
entityManager.flush();
// when
User found = userRepository.findByEmail("[email protected]");
// then
assertThat(found).isNotNull();
assertThat(found.getEmail()).isEqualTo("[email protected]");
}
@Test
void whenFindByNonExistentEmail_thenReturnNull() {
// when
User found = userRepository.findByEmail("[email protected]");
// then
assertThat(found).isNull();
}
@Test
void shouldPersistUserWithAuditFields() {
// given
User user = User.builder()
.email("[email protected]")
.firstName("Audit")
.lastName("User")
.build();
// when
User saved = userRepository.save(user);
// then
assertThat(saved.getId()).isNotNull();
assertThat(saved.getCreatedAt()).isNotNull();
assertThat(saved.getUpdatedAt()).isNotNull();
}
}
// Entity class
@Entity
@Table(name = "users")
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Data
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(unique = true, nullable = false)
private String email;
private String firstName;
private String lastName;
@CreationTimestamp
private LocalDateTime createdAt;
@UpdateTimestamp
private LocalDateTime updatedAt;
}
// Repository interface
public interface UserRepository extends JpaRepository<User, Long> {
User findByEmail(String email);
List<User> findByLastName(String lastName);
Optional<User> findByIdAndEmail(Long id, String email);
}

@DataJpaTest with Testcontainers

@DataJpaTest
@TestPropertySource(properties = {
"spring.test.database.replace=NONE",
"spring.datasource.url=jdbc:tc:postgresql:15-alpine:///testdb"
})
class UserRepositoryWithTestcontainersTest {
@Autowired
private UserRepository userRepository;
@Autowired
private TestEntityManager entityManager;
@Test
void shouldWorkWithRealPostgreSQL() {
User user = User.builder()
.email("[email protected]")
.firstName("Postgres")
.lastName("User")
.build();
User saved = userRepository.save(user);
assertThat(saved.getId()).isNotNull();
assertThat(userRepository.count()).isEqualTo(1);
}
}

@JdbcTest - JDBC Testing

import org.springframework.boot.test.autoconfigure.jdbc.JdbcTest;
import org.springframework.jdbc.core.JdbcTemplate;
@JdbcTest
class UserJdbcRepositoryTest {
@Autowired
private JdbcTemplate jdbcTemplate;
@Test
void shouldCountUsers() {
// given
jdbcTemplate.execute("CREATE TABLE users (id BIGINT PRIMARY KEY, email VARCHAR(255))");
jdbcTemplate.update("INSERT INTO users (id, email) VALUES (?, ?)", 1L, "[email protected]");
// when
Integer count = jdbcTemplate.queryForObject("SELECT COUNT(*) FROM users", Integer.class);
// then
assertThat(count).isEqualTo(1);
}
@Test
void shouldInsertUser() {
// given
jdbcTemplate.execute("CREATE TABLE users (id BIGINT PRIMARY KEY, email VARCHAR(255))");
// when
int affectedRows = jdbcTemplate.update(
"INSERT INTO users (id, email) VALUES (?, ?)", 
2L, "[email protected]"
);
// then
assertThat(affectedRows).isEqualTo(1);
String email = jdbcTemplate.queryForObject(
"SELECT email FROM users WHERE id = ?", 
String.class, 2L
);
assertThat(email).isEqualTo("[email protected]");
}
}

@DataMongoTest - MongoDB Testing

import org.springframework.boot.test.autoconfigure.data.mongo.DataMongoTest;
import org.springframework.data.mongodb.core.MongoTemplate;
@DataMongoTest
class UserDocumentRepositoryTest {
@Autowired
private MongoTemplate mongoTemplate;
@Autowired
private UserDocumentRepository userRepository;
@Test
void shouldSaveAndFindUser() {
// given
UserDocument user = UserDocument.builder()
.username("mongouser")
.email("[email protected]")
.build();
// when
UserDocument saved = userRepository.save(user);
// then
assertThat(saved.getId()).isNotNull();
assertThat(userRepository.findByUsername("mongouser"))
.isPresent()
.get()
.extracting(UserDocument::getEmail)
.isEqualTo("[email protected]");
}
@Test
void shouldFindByEmailUsingMongoTemplate() {
// given
UserDocument user = UserDocument.builder()
.username("templateuser")
.email("[email protected]")
.build();
mongoTemplate.save(user);
// when
UserDocument found = mongoTemplate.findOne(
Query.query(Criteria.where("email").is("[email protected]")), 
UserDocument.class
);
// then
assertThat(found).isNotNull();
assertThat(found.getUsername()).isEqualTo("templateuser");
}
}
@Document(collection = "users")
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
class UserDocument {
@Id
private String id;
private String username;
private String email;
private LocalDateTime createdAt;
}
public interface UserDocumentRepository extends MongoRepository<UserDocument, String> {
Optional<UserDocument> findByUsername(String username);
List<UserDocument> findByEmailContaining(String email);
}

Web Layer Testing

@WebMvcTest - Controller Testing

import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
@WebMvcTest(UserController.class)
class UserControllerTest {
@Autowired
private MockMvc mockMvc;
@MockBean
private UserService userService;
@Autowired
private ObjectMapper objectMapper;
@Test
void shouldReturnUser() throws Exception {
// given
UserResponse userResponse = UserResponse.builder()
.id(1L)
.email("[email protected]")
.firstName("John")
.lastName("Doe")
.build();
when(userService.getUserById(1L)).thenReturn(userResponse);
// when & then
mockMvc.perform(get("/api/users/1")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(jsonPath("$.id").value(1L))
.andExpect(jsonPath("$.email").value("[email protected]"))
.andExpect(jsonPath("$.firstName").value("John"))
.andExpect(jsonPath("$.lastName").value("Doe"));
}
@Test
void shouldCreateUser() throws Exception {
// given
CreateUserRequest request = CreateUserRequest.builder()
.email("[email protected]")
.firstName("Jane")
.lastName("Smith")
.build();
UserResponse response = UserResponse.builder()
.id(1L)
.email("[email protected]")
.firstName("Jane")
.lastName("Smith")
.build();
when(userService.createUser(any(CreateUserRequest.class))).thenReturn(response);
// when & then
mockMvc.perform(post("/api/users")
.contentType(MediaType.APPLICATION_JSON)
.content(objectMapper.writeValueAsString(request)))
.andExpect(status().isCreated())
.andExpect(jsonPath("$.id").value(1L))
.andExpect(jsonPath("$.email").value("[email protected]"));
verify(userService).createUser(any(CreateUserRequest.class));
}
@Test
void shouldReturn404WhenUserNotFound() throws Exception {
// given
when(userService.getUserById(999L))
.thenThrow(new UserNotFoundException("User not found"));
// when & then
mockMvc.perform(get("/api/users/999"))
.andExpect(status().isNotFound())
.andExpect(jsonPath("$.message").value("User not found"));
}
@Test
void shouldValidateCreateUserRequest() throws Exception {
// given - invalid request
CreateUserRequest invalidRequest = CreateUserRequest.builder()
.email("invalid-email")  // invalid email
.firstName("")  // empty first name
.build();
// when & then
mockMvc.perform(post("/api/users")
.contentType(MediaType.APPLICATION_JSON)
.content(objectMapper.writeValueAsString(invalidRequest)))
.andExpect(status().isBadRequest())
.andExpect(jsonPath("$.errors").isArray());
}
}
// Controller class
@RestController
@RequestMapping("/api/users")
@RequiredArgsConstructor
@Validated
public class UserController {
private final UserService userService;
@GetMapping("/{id}")
public UserResponse getUser(@PathVariable Long id) {
return userService.getUserById(id);
}
@PostMapping
public ResponseEntity<UserResponse> createUser(
@Valid @RequestBody CreateUserRequest request) {
UserResponse response = userService.createUser(request);
return ResponseEntity.created(URI.create("/api/users/" + response.getId()))
.body(response);
}
@PutMapping("/{id}")
public UserResponse updateUser(
@PathVariable Long id,
@Valid @RequestBody UpdateUserRequest request) {
return userService.updateUser(id, request);
}
@DeleteMapping("/{id}")
public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
userService.deleteUser(id);
return ResponseEntity.noContent().build();
}
}
// DTO classes
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
class CreateUserRequest {
@NotBlank
@Email
private String email;
@NotBlank
@Size(min = 2, max = 50)
private String firstName;
@NotBlank
@Size(min = 2, max = 50)
private String lastName;
}
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
class UserResponse {
private Long id;
private String email;
private String firstName;
private String lastName;
private LocalDateTime createdAt;
}

@WebMvcTest with Security

@WebMvcTest(UserController.class)
@WithMockUser
class UserControllerSecurityTest {
@Autowired
private MockMvc mockMvc;
@MockBean
private UserService userService;
@Test
@WithMockUser(roles = "USER")
void shouldAllowUserAccess() throws Exception {
when(userService.getUserById(1L)).thenReturn(new UserResponse());
mockMvc.perform(get("/api/users/1"))
.andExpect(status().isOk());
}
@Test
@WithMockUser(roles = "ADMIN")
void shouldAllowAdminAccess() throws Exception {
when(userService.getUserById(1L)).thenReturn(new UserResponse());
mockMvc.perform(get("/api/users/1"))
.andExpect(status().isOk());
}
@Test
void shouldDenyAccessWithoutAuthentication() throws Exception {
mockMvc.perform(get("/api/users/1"))
.andExpect(status().isUnauthorized());
}
@Test
@WithMockUser(roles = "USER")
void shouldDenyAccessForForbiddenEndpoint() throws Exception {
mockMvc.perform(delete("/api/users/1"))
.andExpect(status().isForbidden());
}
}

@WebFluxTest - Reactive Controller Testing

import org.springframework.boot.test.autoconfigure.web.reactive.WebFluxTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.test.web.reactive.server.WebTestClient;
@WebFluxTest(UserReactiveController.class)
class UserReactiveControllerTest {
@Autowired
private WebTestClient webTestClient;
@MockBean
private UserReactiveService userService;
@Test
void shouldGetUser() {
// given
UserResponse userResponse = UserResponse.builder()
.id(1L)
.email("[email protected]")
.firstName("Reactive")
.lastName("User")
.build();
when(userService.getUserById(1L)).thenReturn(Mono.just(userResponse));
// when & then
webTestClient.get().uri("/api/reactive/users/1")
.exchange()
.expectStatus().isOk()
.expectBody(UserResponse.class)
.value(response -> {
assertThat(response.getEmail()).isEqualTo("[email protected]");
assertThat(response.getFirstName()).isEqualTo("Reactive");
});
}
@Test
void shouldStreamUsers() {
// given
UserResponse user1 = UserResponse.builder().id(1L).email("[email protected]").build();
UserResponse user2 = UserResponse.builder().id(2L).email("[email protected]").build();
when(userService.getAllUsers()).thenReturn(Flux.just(user1, user2));
// when & then
webTestClient.get().uri("/api/reactive/users/stream")
.accept(MediaType.TEXT_EVENT_STREAM)
.exchange()
.expectStatus().isOk()
.expectBodyList(UserResponse.class)
.hasSize(2);
}
}
@RestController
@RequestMapping("/api/reactive/users")
@RequiredArgsConstructor
public class UserReactiveController {
private final UserReactiveService userService;
@GetMapping("/{id}")
public Mono<UserResponse> getUser(@PathVariable Long id) {
return userService.getUserById(id);
}
@GetMapping("/stream")
public Flux<UserResponse> streamUsers() {
return userService.getAllUsers().delayElements(Duration.ofMillis(100));
}
}

JSON Layer Testing

@JsonTest - JSON Serialization/Deserialization Testing

import org.springframework.boot.test.autoconfigure.json.JsonTest;
import org.springframework.boot.test.json.JacksonTester;
@JsonTest
class UserJsonTest {
@Autowired
private JacksonTester<UserResponse> json;
@Autowired
private JacksonTester<CreateUserRequest> requestJson;
@Test
void shouldSerializeUserResponse() throws Exception {
// given
UserResponse user = UserResponse.builder()
.id(1L)
.email("[email protected]")
.firstName("John")
.lastName("Doe")
.createdAt(LocalDateTime.of(2023, 1, 1, 10, 0))
.build();
// when & then
assertThat(json.write(user)).isEqualToJson("expected-user.json");
assertThat(json.write(user)).hasJsonPathStringValue("@.email");
assertThat(json.write(user)).extractingJsonPathStringValue("@.email")
.isEqualTo("[email protected]");
}
@Test
void shouldDeserializeUserResponse() throws Exception {
// given
String content = """
{
"id": 1,
"email": "[email protected]",
"firstName": "John",
"lastName": "Doe",
"createdAt": "2023-01-01T10:00:00"
}
""";
// when & then
assertThat(json.parse(content))
.isEqualTo(UserResponse.builder()
.id(1L)
.email("[email protected]")
.firstName("John")
.lastName("Doe")
.createdAt(LocalDateTime.of(2023, 1, 1, 10, 0))
.build());
assertThat(json.parseObject(content).getEmail()).isEqualTo("[email protected]");
}
@Test
void shouldDeserializeCreateUserRequest() throws Exception {
// given
String content = """
{
"email": "[email protected]",
"firstName": "Jane",
"lastName": "Smith"
}
""";
// when & then
assertThat(requestJson.parse(content))
.isEqualTo(CreateUserRequest.builder()
.email("[email protected]")
.firstName("Jane")
.lastName("Smith")
.build());
}
@Test
void shouldFailDeserializationWithInvalidEmail() throws Exception {
// given
String invalidContent = """
{
"email": "invalid-email",
"firstName": "John",
"lastName": "Doe"
}
""";
// when & then
assertThatThrownBy(() -> requestJson.parse(invalidContent))
.isInstanceOf(JsonParseException.class);
}
}
// expected-user.json
{
"id": 1,
"email": "[email protected]",
"firstName": "John",
"lastName": "Doe",
"createdAt": "2023-01-01T10:00:00"
}

Service Layer Testing

Mocking Dependencies in Service Tests

@ExtendWith(MockitoExtension.class)
class UserServiceTest {
@Mock
private UserRepository userRepository;
@Mock
private EmailService emailService;
@Mock
private PasswordEncoder passwordEncoder;
@InjectMocks
private UserService userService;
@Test
void shouldCreateUserSuccessfully() {
// given
CreateUserRequest request = CreateUserRequest.builder()
.email("[email protected]")
.firstName("John")
.lastName("Doe")
.build();
User user = User.builder()
.id(1L)
.email("[email protected]")
.firstName("John")
.lastName("Doe")
.build();
when(userRepository.save(any(User.class))).thenReturn(user);
when(passwordEncoder.encode(anyString())).thenReturn("encodedPassword");
doNothing().when(emailService).sendWelcomeEmail(anyString());
// when
UserResponse response = userService.createUser(request);
// then
assertThat(response.getId()).isEqualTo(1L);
assertThat(response.getEmail()).isEqualTo("[email protected]");
verify(userRepository).save(any(User.class));
verify(emailService).sendWelcomeEmail("[email protected]");
}
@Test
void shouldThrowExceptionWhenEmailExists() {
// given
CreateUserRequest request = CreateUserRequest.builder()
.email("[email protected]")
.firstName("John")
.lastName("Doe")
.build();
when(userRepository.findByEmail("[email protected]"))
.thenReturn(new User());
// when & then
assertThatThrownBy(() -> userService.createUser(request))
.isInstanceOf(DuplicateEmailException.class)
.hasMessage("Email already exists: [email protected]");
verify(userRepository, never()).save(any(User.class));
}
@Test
void shouldUpdateUser() {
// given
Long userId = 1L;
UpdateUserRequest request = UpdateUserRequest.builder()
.firstName("Updated")
.lastName("Name")
.build();
User existingUser = User.builder()
.id(userId)
.email("[email protected]")
.firstName("Original")
.lastName("User")
.build();
User updatedUser = User.builder()
.id(userId)
.email("[email protected]")
.firstName("Updated")
.lastName("Name")
.build();
when(userRepository.findById(userId)).thenReturn(Optional.of(existingUser));
when(userRepository.save(any(User.class))).thenReturn(updatedUser);
// when
UserResponse response = userService.updateUser(userId, request);
// then
assertThat(response.getFirstName()).isEqualTo("Updated");
assertThat(response.getLastName()).isEqualTo("Name");
verify(userRepository).save(existingUser);
}
@Test
void shouldThrowExceptionWhenUserNotFoundForUpdate() {
// given
Long userId = 999L;
UpdateUserRequest request = UpdateUserRequest.builder().build();
when(userRepository.findById(userId)).thenReturn(Optional.empty());
// when & then
assertThatThrownBy(() -> userService.updateUser(userId, request))
.isInstanceOf(UserNotFoundException.class)
.hasMessage("User not found with id: 999");
}
}

Configuration Testing

@Import and Test Configuration

@WebMvcTest(UserController.class)
@Import({UserService.class, SecurityConfig.class})
class UserControllerWithImportsTest {
@Autowired
private MockMvc mockMvc;
@MockBean
private UserRepository userRepository;
@MockBean
private EmailService emailService;
@Test
void shouldWorkWithImportedConfigurations() throws Exception {
// Test implementation
}
}
@TestConfiguration
class TestServiceConfiguration {
@Bean
@Primary
public UserService testUserService() {
return new TestUserService();
}
@Bean
public PasswordEncoder testPasswordEncoder() {
return new BCryptPasswordEncoder();
}
}
@WebMvcTest(UserController.class)
@Import(TestServiceConfiguration.class)
class UserControllerWithTestConfigurationTest {
@Autowired
private UserService userService; // Uses the test bean
@Test
void shouldUseTestConfiguration() {
// Test implementation
}
}

Custom Test Slices

Creating Custom Test Slices

// Custom annotation for service layer testing
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@BootstrapWith(SpringBootTestContextBootstrapper.class)
@OverrideAutoConfiguration(enabled = false)
@TypeExcludeFilters(ServiceTypeExcludeFilter.class)
@AutoConfigureCache
@AutoConfigureMetrics
@ServiceTest
public @interface ServiceSliceTest {
@PropertyMapping("spring.test.service.enabled")
boolean enabled() default true;
Class<?>[] services() default {};
}
// Custom type exclude filter
class ServiceTypeExcludeFilter extends TypeExcludeFilter {
private final ServiceSliceTest annotation;
ServiceTypeExcludeFilter(BeanFactory beanFactory, ServiceSliceTest annotation) {
this.annotation = annotation;
}
@Override
public boolean match(MetadataReader metadataReader, 
MetadataReaderFactory metadataReaderFactory) throws IOException {
// Custom exclusion logic for services
return !isServiceComponent(metadataReader) && 
!isConfiguration(metadataReader);
}
private boolean isServiceComponent(MetadataReader metadataReader) {
// Implementation to detect service components
return metadataReader.getClassMetadata().getClassName().contains("Service");
}
}
// Auto-configuration for service slice
@AutoConfiguration
@ConditionalOnWebApplication
@Import(ServiceSliceTestConfiguration.class)
public class ServiceSliceAutoConfiguration {
@Bean
@ConditionalOnMissingBean
public UserService userService() {
return new UserService();
}
}
// Using the custom slice
@ServiceSliceTest(services = {UserService.class, EmailService.class})
class CustomServiceSliceTest {
@Autowired
private UserService userService;
@MockBean
private UserRepository userRepository;
@Test
void shouldUseCustomSlice() {
// Test with custom slice configuration
}
}

Integration Test Slices

@SpringBootTest with Test Slices

@SpringBootTest(
webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
properties = {
"spring.datasource.url=jdbc:h2:mem:testdb",
"spring.jpa.hibernate.ddl-auto=create-drop"
}
)
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.ANY)
@TestPropertySource(locations = "classpath:application-test.properties")
class UserIntegrationTest {
@Autowired
private TestRestTemplate restTemplate;
@Autowired
private UserRepository userRepository;
@LocalServerPort
private int port;
@BeforeEach
void setUp() {
userRepository.deleteAll();
}
@Test
void shouldCreateUserThroughAllLayers() {
// given
CreateUserRequest request = CreateUserRequest.builder()
.email("[email protected]")
.firstName("Integration")
.lastName("Test")
.build();
// when
ResponseEntity<UserResponse> response = restTemplate.postForEntity(
"http://localhost:" + port + "/api/users",
request,
UserResponse.class
);
// then
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
assertThat(response.getBody()).isNotNull();
assertThat(response.getBody().getEmail()).isEqualTo("[email protected]");
// Verify database
assertThat(userRepository.count()).isEqualTo(1);
assertThat(userRepository.findByEmail("[email protected]")).isNotNull();
}
@Test
void shouldGetUserThroughAllLayers() {
// given
User user = User.builder()
.email("[email protected]")
.firstName("Get")
.lastName("User")
.build();
User saved = userRepository.save(user);
// when
ResponseEntity<UserResponse> response = restTemplate.getForEntity(
"http://localhost:" + port + "/api/users/" + saved.getId(),
UserResponse.class
);
// then
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(response.getBody()).isNotNull();
assertThat(response.getBody().getEmail()).isEqualTo("[email protected]");
}
}

Performance Testing with Slices

Benchmarking Test Slices

class TestSlicePerformanceTest {
@Test
void compareTestSliceStartupTimes() {
// Measure @DataJpaTest startup time
long startTime = System.currentTimeMillis();
try (ConfigurableApplicationContext context = 
new SpringApplicationBuilder(DataJpaTestConfig.class)
.run()) {
long dataJpaTime = System.currentTimeMillis() - startTime;
System.out.println("@DataJpaTest startup: " + dataJpaTime + "ms");
}
// Measure @WebMvcTest startup time
startTime = System.currentTimeMillis();
try (ConfigurableApplicationContext context = 
new SpringApplicationBuilder(WebMvcTestConfig.class)
.run()) {
long webMvcTime = System.currentTimeMillis() - startTime;
System.out.println("@WebMvcTest startup: " + webMvcTime + "ms");
}
// Measure @SpringBootTest startup time
startTime = System.currentTimeMillis();
try (ConfigurableApplicationContext context = 
new SpringApplicationBuilder(FullAppTestConfig.class)
.run()) {
long fullAppTime = System.currentTimeMillis() - startTime;
System.out.println("@SpringBootTest startup: " + fullAppTime + "ms");
}
}
@DataJpaTest
static class DataJpaTestConfig {}
@WebMvcTest
static class WebMvcTestConfig {}
@SpringBootTest
static class FullAppTestConfig {}
}

Best Practices

Test Organization and Structure

// Base test class for common configuration
@SpringBootTest
@Testcontainers
@ActiveProfiles("test")
@DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_CLASS)
public abstract class BaseIntegrationTest {
@Container
protected static PostgreSQLContainer<?> postgres = 
new PostgreSQLContainer<>("postgres:15-alpine")
.withDatabaseName("testdb")
.withUsername("test")
.withPassword("test");
@DynamicPropertySource
static void configureProperties(DynamicPropertyRegistry registry) {
registry.add("spring.datasource.url", postgres::getJdbcUrl);
registry.add("spring.datasource.username", postgres::getUsername);
registry.add("spring.datasource.password", postgres::getPassword);
}
@BeforeEach
void setUp() {
// Common setup logic
}
@AfterEach
void tearDown() {
// Common cleanup logic
}
}
// Repository tests
@DataJpaTest
@Import(TestConfiguration.class)
class UserRepositoryTest extends BaseIntegrationTest {
@Test
void repositorySpecificTest() {
// Test implementation
}
}
// Controller tests
@WebMvcTest(UserController.class)
@WithMockUser
class UserControllerTest {
@Test
void controllerSpecificTest() {
// Test implementation
}
}
// Service tests
@ExtendWith(MockitoExtension.class)
class UserServiceTest {
@Test
void serviceSpecificTest() {
// Test implementation
}
}

Conclusion

Spring Boot Test Slices provide a powerful way to write focused, fast, and maintainable tests:

  • @DataJpaTest: For testing JPA components with an embedded database
  • @WebMvcTest: For testing MVC controllers with mocked dependencies
  • @WebFluxTest: For testing reactive web controllers
  • @JsonTest: For testing JSON serialization/deserialization
  • @DataMongoTest: For testing MongoDB components
  • @JdbcTest: For testing JDBC components

Key Benefits:

  • Faster Tests: Load only necessary components
  • Focused Testing: Test specific layers in isolation
  • Better Maintainability: Clear separation of concerns
  • Reduced Complexity: Simplified test configuration

When to Use Which Slice:

  • Use @DataJpaTest for repository layer testing
  • Use @WebMvcTest for web layer testing
  • Use @JsonTest for serialization testing
  • Use @SpringBootTest for full integration testing
  • Use custom slices for domain-specific testing needs

By leveraging test slices appropriately, you can create a comprehensive test pyramid with fast, reliable tests at every level of your application.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper