@WebMvcTest and @DataJpaTest in Java

Table of Contents

Introduction to Spring Boot Test Slices

Spring Boot provides test slicing annotations that allow you to test specific layers of your application in isolation. @WebMvcTest and @DataJpaTest are two essential annotations for testing web and data layers separately.

@WebMvcTest - Testing Web Layer

Basic @WebMvcTest Setup

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
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;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
@WebMvcTest(UserController.class) // Focus only on web layer for UserController
class UserControllerWebMvcTest {
@Autowired
private MockMvc mockMvc; // Injected automatically by @WebMvcTest
@MockBean
private UserService userService; // Mock the service layer
@Test
void shouldReturnUserWhenValidId() throws Exception {
// Given
User user = new User(1L, "john.doe", "[email protected]", "John", "Doe");
when(userService.getUserById(1L)).thenReturn(user);
// When & Then
mockMvc.perform(get("/api/users/1"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.id").value(1))
.andExpect(jsonPath("$.username").value("john.doe"))
.andExpect(jsonPath("$.email").value("[email protected]"))
.andExpect(jsonPath("$.firstName").value("John"))
.andExpect(jsonPath("$.lastName").value("Doe"));
}
@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"));
}
}

Controller Class

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/api/users")
public class UserController {
private final UserService userService;
public UserController(UserService userService) {
this.userService = userService;
}
@GetMapping("/{id}")
public ResponseEntity<User> getUserById(@PathVariable Long id) {
User user = userService.getUserById(id);
return ResponseEntity.ok(user);
}
@PostMapping
public ResponseEntity<User> createUser(@RequestBody User user) {
User createdUser = userService.createUser(user);
return ResponseEntity.status(201).body(createdUser);
}
@PutMapping("/{id}")
public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User user) {
User updatedUser = userService.updateUser(id, user);
return ResponseEntity.ok(updatedUser);
}
@DeleteMapping("/{id}")
public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
userService.deleteUser(id);
return ResponseEntity.noContent().build();
}
@GetMapping
public ResponseEntity<List<User>> getAllUsers(
@RequestParam(defaultValue = "0") int page,
@RequestParam(defaultValue = "10") int size) {
List<User> users = userService.getAllUsers(page, size);
return ResponseEntity.ok(users);
}
}

Comprehensive @WebMvcTest Examples

import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.test.web.servlet.MockMvc;
import java.util.Arrays;
import java.util.List;
import static org.hamcrest.Matchers.*;
import static org.mockito.ArgumentMatchers.*;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.*;
@WebMvcTest(UserController.class)
class UserControllerComprehensiveTest {
@Autowired
private MockMvc mockMvc;
@Autowired
private ObjectMapper objectMapper; // Automatically available for JSON serialization
@MockBean
private UserService userService;
private User user1;
private User user2;
private List<User> users;
@BeforeEach
void setUp() {
user1 = new User(1L, "john.doe", "[email protected]", "John", "Doe");
user2 = new User(2L, "jane.smith", "[email protected]", "Jane", "Smith");
users = Arrays.asList(user1, user2);
}
@Nested
@DisplayName("GET /api/users")
class GetUsersTests {
@Test
@DisplayName("Should return all users with pagination")
void shouldReturnAllUsersWithPagination() throws Exception {
// Given
when(userService.getAllUsers(0, 10)).thenReturn(users);
// When & Then
mockMvc.perform(get("/api/users")
.param("page", "0")
.param("size", "10"))
.andDo(print()) // Useful for debugging
.andExpect(status().isOk())
.andExpect(jsonPath("$", hasSize(2)))
.andExpect(jsonPath("$[0].username").value("john.doe"))
.andExpect(jsonPath("$[1].username").value("jane.smith"));
}
@Test
@DisplayName("Should return empty list when no users")
void shouldReturnEmptyListWhenNoUsers() throws Exception {
// Given
when(userService.getAllUsers(0, 10)).thenReturn(List.of());
// When & Then
mockMvc.perform(get("/api/users"))
.andExpect(status().isOk())
.andExpect(jsonPath("$", empty()));
}
}
@Nested
@DisplayName("POST /api/users")
class CreateUserTests {
@Test
@DisplayName("Should create user with valid data")
void shouldCreateUserWithValidData() throws Exception {
// Given
User newUser = new User(null, "new.user", "[email protected]", "New", "User");
User createdUser = new User(3L, "new.user", "[email protected]", "New", "User");
when(userService.createUser(any(User.class))).thenReturn(createdUser);
// When & Then
mockMvc.perform(post("/api/users")
.contentType(MediaType.APPLICATION_JSON)
.content(objectMapper.writeValueAsString(newUser)))
.andExpect(status().isCreated())
.andExpect(jsonPath("$.id").value(3))
.andExpect(jsonPath("$.username").value("new.user"))
.andExpect(header().string("Location", "/api/users/3"));
}
@Test
@DisplayName("Should return 400 for invalid user data")
void shouldReturn400ForInvalidUserData() throws Exception {
// Given - User with invalid email
User invalidUser = new User(null, "user", "invalid-email", "First", "Last");
// When & Then
mockMvc.perform(post("/api/users")
.contentType(MediaType.APPLICATION_JSON)
.content(objectMapper.writeValueAsString(invalidUser)))
.andExpect(status().isBadRequest());
}
@Test
@DisplayName("Should return 409 for duplicate username")
void shouldReturn409ForDuplicateUsername() throws Exception {
// Given
User duplicateUser = new User(null, "john.doe", "[email protected]", "New", "User");
when(userService.createUser(any(User.class)))
.thenThrow(new DuplicateUsernameException("Username already exists"));
// When & Then
mockMvc.perform(post("/api/users")
.contentType(MediaType.APPLICATION_JSON)
.content(objectMapper.writeValueAsString(duplicateUser)))
.andExpect(status().isConflict())
.andExpect(jsonPath("$.message").value("Username already exists"));
}
}
@Nested
@DisplayName("PUT /api/users/{id}")
class UpdateUserTests {
@Test
@DisplayName("Should update user successfully")
void shouldUpdateUserSuccessfully() throws Exception {
// Given
User updateData = new User(null, "john.updated", "[email protected]", "John", "Updated");
User updatedUser = new User(1L, "john.updated", "[email protected]", "John", "Updated");
when(userService.updateUser(eq(1L), any(User.class))).thenReturn(updatedUser);
// When & Then
mockMvc.perform(put("/api/users/1")
.contentType(MediaType.APPLICATION_JSON)
.content(objectMapper.writeValueAsString(updateData)))
.andExpect(status().isOk())
.andExpect(jsonPath("$.lastName").value("Updated"));
}
}
@Nested
@DisplayName("DELETE /api/users/{id}")
class DeleteUserTests {
@Test
@DisplayName("Should delete user successfully")
void shouldDeleteUserSuccessfully() throws Exception {
// Given
doNothing().when(userService).deleteUser(1L);
// When & Then
mockMvc.perform(delete("/api/users/1"))
.andExpect(status().isNoContent());
}
@Test
@DisplayName("Should return 404 when deleting non-existent user")
void shouldReturn404WhenDeletingNonExistentUser() throws Exception {
// Given
doThrow(new UserNotFoundException("User not found"))
.when(userService).deleteUser(999L);
// When & Then
mockMvc.perform(delete("/api/users/999"))
.andExpect(status().isNotFound());
}
}
}

Testing Security with @WebMvcTest

import org.springframework.security.test.context.support.WithMockUser;
import org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors;
@WebMvcTest(SecuredUserController.class)
class SecuredUserControllerTest {
@Autowired
private MockMvc mockMvc;
@MockBean
private UserService userService;
@Test
@WithMockUser(roles = "USER")
@DisplayName("Should return user for authenticated user")
void shouldReturnUserForAuthenticatedUser() throws Exception {
// Given
User user = new User(1L, "john.doe", "[email protected]", "John", "Doe");
when(userService.getUserById(1L)).thenReturn(user);
// When & Then
mockMvc.perform(get("/api/secured/users/1"))
.andExpect(status().isOk());
}
@Test
@DisplayName("Should return 401 for unauthenticated request")
void shouldReturn401ForUnauthenticatedRequest() throws Exception {
mockMvc.perform(get("/api/secured/users/1"))
.andExpect(status().isUnauthorized());
}
@Test
@WithMockUser(roles = "USER")
@DisplayName("Should return 403 for unauthorized role")
void shouldReturn403ForUnauthorizedRole() throws Exception {
mockMvc.perform(get("/api/secured/users/1"))
.andExpect(status().isForbidden());
}
@Test
@WithMockUser(username = "admin", roles = "ADMIN")
@DisplayName("Should allow access for admin role")
void shouldAllowAccessForAdminRole() throws Exception {
// Given
User user = new User(1L, "john.doe", "[email protected]", "John", "Doe");
when(userService.getUserById(1L)).thenReturn(user);
// When & Then
mockMvc.perform(get("/api/secured/users/1"))
.andExpect(status().isOk());
}
@Test
@WithMockUser(username = "user", roles = "USER")
@DisplayName("Should create user with CSRF token")
void shouldCreateUserWithCsrfToken() throws Exception {
// Given
User newUser = new User(null, "new.user", "[email protected]", "New", "User");
User createdUser = new User(1L, "new.user", "[email protected]", "New", "User");
when(userService.createUser(any(User.class))).thenReturn(createdUser);
// When & Then
mockMvc.perform(post("/api/secured/users")
.with(csrf()) // Include CSRF token
.contentType(MediaType.APPLICATION_JSON)
.content(objectMapper.writeValueAsString(newUser)))
.andExpect(status().isCreated());
}
}

@DataJpaTest - Testing Data Layer

Basic @DataJpaTest Setup

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;
import java.util.List;
import java.util.Optional;
import static org.assertj.core.api.Assertions.assertThat;
@DataJpaTest
class UserRepositoryTest {
@Autowired
private TestEntityManager testEntityManager; // Alternative to EntityManager for tests
@Autowired
private UserRepository userRepository;
@Test
void shouldSaveUser() {
// Given
User user = new User("john.doe", "[email protected]", "John", "Doe");
// When
User savedUser = userRepository.save(user);
// Then
assertThat(savedUser).isNotNull();
assertThat(savedUser.getId()).isNotNull();
assertThat(savedUser.getUsername()).isEqualTo("john.doe");
assertThat(savedUser.getEmail()).isEqualTo("[email protected]");
}
@Test
void shouldFindUserById() {
// Given
User user = new User("john.doe", "[email protected]", "John", "Doe");
User savedUser = testEntityManager.persistAndFlush(user);
// When
Optional<User> foundUser = userRepository.findById(savedUser.getId());
// Then
assertThat(foundUser).isPresent();
assertThat(foundUser.get().getUsername()).isEqualTo("john.doe");
}
@Test
void shouldReturnEmptyWhenUserNotFound() {
// When
Optional<User> foundUser = userRepository.findById(999L);
// Then
assertThat(foundUser).isEmpty();
}
@Test
void shouldFindUserByUsername() {
// Given
User user = new User("john.doe", "[email protected]", "John", "Doe");
testEntityManager.persistAndFlush(user);
// When
Optional<User> foundUser = userRepository.findByUsername("john.doe");
// Then
assertThat(foundUser).isPresent();
assertThat(foundUser.get().getEmail()).isEqualTo("[email protected]");
}
@Test
void shouldFindUsersByLastName() {
// Given
User user1 = new User("john.doe", "[email protected]", "John", "Doe");
User user2 = new User("jane.doe", "[email protected]", "Jane", "Doe");
User user3 = new User("bob.smith", "[email protected]", "Bob", "Smith");
testEntityManager.persist(user1);
testEntityManager.persist(user2);
testEntityManager.persist(user3);
testEntityManager.flush();
// When
List<User> doeUsers = userRepository.findByLastName("Doe");
// Then
assertThat(doeUsers).hasSize(2);
assertThat(doeUsers).extracting(User::getUsername)
.containsExactlyInAnyOrder("john.doe", "jane.doe");
}
@Test
void shouldUpdateUser() {
// Given
User user = new User("john.doe", "[email protected]", "John", "Doe");
User savedUser = testEntityManager.persistAndFlush(user);
// When
savedUser.setEmail("[email protected]");
User updatedUser = userRepository.save(savedUser);
// Then
assertThat(updatedUser.getEmail()).isEqualTo("[email protected]");
// Verify in database
User userFromDb = testEntityManager.find(User.class, savedUser.getId());
assertThat(userFromDb.getEmail()).isEqualTo("[email protected]");
}
@Test
void shouldDeleteUser() {
// Given
User user = new User("john.doe", "[email protected]", "John", "Doe");
User savedUser = testEntityManager.persistAndFlush(user);
// When
userRepository.delete(savedUser);
testEntityManager.flush();
// Then
User deletedUser = testEntityManager.find(User.class, savedUser.getId());
assertThat(deletedUser).isNull();
}
}

Entity and Repository Classes

import javax.persistence.*;
import javax.validation.constraints.Email;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Size;
@Entity
@Table(name = "users")
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@NotBlank
@Size(min = 3, max = 50)
@Column(unique = true, nullable = false)
private String username;
@Email
@NotBlank
@Column(unique = true, nullable = false)
private String email;
@NotBlank
@Size(max = 50)
@Column(name = "first_name", nullable = false)
private String firstName;
@NotBlank
@Size(max = 50)
@Column(name = "last_name", nullable = false)
private String lastName;
@Column(name = "created_at")
private java.time.LocalDateTime createdAt;
// Constructors
public User() {}
public User(String username, String email, String firstName, String lastName) {
this.username = username;
this.email = email;
this.firstName = firstName;
this.lastName = lastName;
this.createdAt = java.time.LocalDateTime.now();
}
// Getters and Setters
public Long getId() { return id; }
public void setId(Long id) { this.id = id; }
public String getUsername() { return username; }
public void setUsername(String username) { this.username = username; }
public String getEmail() { return email; }
public void setEmail(String email) { this.email = email; }
public String getFirstName() { return firstName; }
public void setFirstName(String firstName) { this.firstName = firstName; }
public String getLastName() { return lastName; }
public void setLastName(String lastName) { this.lastName = lastName; }
public java.time.LocalDateTime getCreatedAt() { return createdAt; }
public void setCreatedAt(java.time.LocalDateTime createdAt) { this.createdAt = createdAt; }
}

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import java.util.List;
import java.util.Optional;
public interface UserRepository extends JpaRepository<User, Long> {
Optional<User> findByUsername(String username);
Optional<User> findByEmail(String email);
List<User> findByLastName(String lastName);
List<User> findByFirstNameContainingIgnoreCase(String firstName);
@Query("SELECT u FROM User u WHERE u.email LIKE %:domain")
List<User> findByEmailDomain(@Param("domain") String domain);
@Query("SELECT u FROM User u WHERE u.createdAt >= :startDate AND u.createdAt <= :endDate")
List<User> findUsersCreatedBetween(@Param("startDate") java.time.LocalDateTime startDate,
@Param("endDate") java.time.LocalDateTime endDate);
boolean existsByUsername(String username);
boolean existsByEmail(String email);
long countByLastName(String lastName);
@Query("SELECT COUNT(u) FROM User u WHERE u.lastName = :lastName")
long countUsersByLastName(@Param("lastName") String lastName);
}

Comprehensive @DataJpaTest Examples

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;
import org.springframework.dao.DataIntegrityViolationException;
import java.time.LocalDateTime;
import java.util.List;
import static org.assertj.core.api.Assertions.*;
@DataJpaTest
class UserRepositoryComprehensiveTest {
@Autowired
private TestEntityManager testEntityManager;
@Autowired
private UserRepository userRepository;
private User user1;
private User user2;
@BeforeEach
void setUp() {
user1 = new User("john.doe", "[email protected]", "John", "Doe");
user2 = new User("jane.smith", "[email protected]", "Jane", "Smith");
}
@Nested
@DisplayName("CRUD Operations")
class CrudOperations {
@Test
@DisplayName("Should persist user with all fields")
void shouldPersistUserWithAllFields() {
// When
User savedUser = userRepository.save(user1);
// Then
assertThat(savedUser.getId()).isNotNull();
assertThat(savedUser.getCreatedAt()).isNotNull();
// Verify in database
User userFromDb = testEntityManager.find(User.class, savedUser.getId());
assertThat(userFromDb.getUsername()).isEqualTo("john.doe");
assertThat(userFromDb.getEmail()).isEqualTo("[email protected]");
}
@Test
@DisplayName("Should update user successfully")
void shouldUpdateUserSuccessfully() {
// Given
User savedUser = testEntityManager.persistFlushFind(user1);
// When
savedUser.setEmail("[email protected]");
User updatedUser = userRepository.save(savedUser);
// Then
assertThat(updatedUser.getEmail()).isEqualTo("[email protected]");
// Verify changes are persisted
testEntityManager.clear(); // Clear persistence context to force database read
User userFromDb = testEntityManager.find(User.class, savedUser.getId());
assertThat(userFromDb.getEmail()).isEqualTo("[email protected]");
}
@Test
@DisplayName("Should delete user successfully")
void shouldDeleteUserSuccessfully() {
// Given
User savedUser = testEntityManager.persistFlushFind(user1);
// When
userRepository.delete(savedUser);
testEntityManager.flush();
// Then
User deletedUser = testEntityManager.find(User.class, savedUser.getId());
assertThat(deletedUser).isNull();
}
}
@Nested
@DisplayName("Query Methods")
class QueryMethods {
@Test
@DisplayName("Should find user by username")
void shouldFindUserByUsername() {
// Given
testEntityManager.persistAndFlush(user1);
// When
Optional<User> foundUser = userRepository.findByUsername("john.doe");
// Then
assertThat(foundUser).isPresent();
assertThat(foundUser.get().getEmail()).isEqualTo("[email protected]");
}
@Test
@DisplayName("Should find users by last name")
void shouldFindUsersByLastName() {
// Given
User user3 = new User("bob.doe", "[email protected]", "Bob", "Doe");
testEntityManager.persist(user1);
testEntityManager.persist(user2);
testEntityManager.persist(user3);
testEntityManager.flush();
// When
List<User> doeUsers = userRepository.findByLastName("Doe");
// Then
assertThat(doeUsers).hasSize(2);
assertThat(doeUsers).extracting(User::getUsername)
.containsExactlyInAnyOrder("john.doe", "bob.doe");
}
@Test
@DisplayName("Should find users with email domain")
void shouldFindUsersWithEmailDomain() {
// Given
User user3 = new User("[email protected]", "[email protected]", "Bob", "Johnson");
testEntityManager.persist(user1);
testEntityManager.persist(user2);
testEntityManager.persist(user3);
testEntityManager.flush();
// When
List<User> gmailUsers = userRepository.findByEmailDomain("gmail.com");
// Then
assertThat(gmailUsers).hasSize(1);
assertThat(gmailUsers.get(0).getUsername()).isEqualTo("[email protected]");
}
@Test
@DisplayName("Should find users created in date range")
void shouldFindUsersCreatedInDateRange() {
// Given
User user3 = new User("old.user", "[email protected]", "Old", "User");
user3.setCreatedAt(LocalDateTime.now().minusDays(10));
testEntityManager.persist(user1);
testEntityManager.persist(user2);
testEntityManager.persist(user3);
testEntityManager.flush();
LocalDateTime startDate = LocalDateTime.now().minusDays(1);
LocalDateTime endDate = LocalDateTime.now().plusDays(1);
// When
List<User> recentUsers = userRepository.findUsersCreatedBetween(startDate, endDate);
// Then
assertThat(recentUsers).hasSize(2);
assertThat(recentUsers).extracting(User::getUsername)
.containsExactlyInAnyOrder("john.doe", "jane.smith");
}
}
@Nested
@DisplayName("Validation and Constraints")
class ValidationAndConstraints {
@Test
@DisplayName("Should enforce unique username constraint")
void shouldEnforceUniqueUsernameConstraint() {
// Given
testEntityManager.persistAndFlush(user1);
// When & Then
User duplicateUser = new User("john.doe", "[email protected]", "Different", "User");
assertThatThrownBy(() -> userRepository.save(duplicateUser))
.isInstanceOf(DataIntegrityViolationException.class);
}
@Test
@DisplayName("Should enforce unique email constraint")
void shouldEnforceUniqueEmailConstraint() {
// Given
testEntityManager.persistAndFlush(user1);
// When & Then
User duplicateEmailUser = new User("different.user", "[email protected]", "Different", "User");
assertThatThrownBy(() -> userRepository.save(duplicateEmailUser))
.isInstanceOf(DataIntegrityViolationException.class);
}
@Test
@DisplayName("Should check if username exists")
void shouldCheckIfUsernameExists() {
// Given
testEntityManager.persistAndFlush(user1);
// When & Then
assertThat(userRepository.existsByUsername("john.doe")).isTrue();
assertThat(userRepository.existsByUsername("nonexistent")).isFalse();
}
@Test
@DisplayName("Should count users by last name")
void shouldCountUsersByLastName() {
// Given
User user3 = new User("bob.doe", "[email protected]", "Bob", "Doe");
testEntityManager.persist(user1);
testEntityManager.persist(user2);
testEntityManager.persist(user3);
testEntityManager.flush();
// When & Then
assertThat(userRepository.countByLastName("Doe")).isEqualTo(2);
assertThat(userRepository.countByLastName("Smith")).isEqualTo(1);
assertThat(userRepository.countByLastName("Nonexistent")).isEqualTo(0);
}
}
@Nested
@DisplayName("Pagination and Sorting")
class PaginationAndSorting {
@BeforeEach
void setUpPaginationData() {
for (int i = 1; i <= 15; i++) {
User user = new User("user" + i, "user" + i + "@example.com", "User" + i, "Test");
testEntityManager.persist(user);
}
testEntityManager.flush();
}
@Test
@DisplayName("Should return paginated results")
void shouldReturnPaginatedResults() {
// When
org.springframework.data.domain.Page<User> page1 = userRepository.findAll(
org.springframework.data.domain.PageRequest.of(0, 5));
org.springframework.data.domain.Page<User> page2 = userRepository.findAll(
org.springframework.data.domain.PageRequest.of(1, 5));
// Then
assertThat(page1.getContent()).hasSize(5);
assertThat(page2.getContent()).hasSize(5);
assertThat(page1.getTotalElements()).isEqualTo(15);
assertThat(page1.getTotalPages()).isEqualTo(3);
}
@Test
@DisplayName("Should return sorted results")
void shouldReturnSortedResults() {
// When
List<User> users = userRepository.findAll(
org.springframework.data.domain.Sort.by("username").descending());
// Then
assertThat(users).hasSize(15);
assertThat(users.get(0).getUsername()).isEqualTo("user9");
assertThat(users.get(1).getUsername()).isEqualTo("user8");
}
}
}

Testing with Different Databases

import org.springframework.test.context.ActiveProfiles;
@DataJpaTest
@ActiveProfiles("test") // Use test profile with H2 database
class UserRepositoryH2Test {
// Tests using H2 in-memory database
}
@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@ActiveProfiles("integration-test") // Use real database for integration tests
class UserRepositoryIntegrationTest {
// Tests using real database configuration
}

Advanced Configuration and Customization

Custom @WebMvcTest Configuration

import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.context.annotation.Import;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
@WebMvcTest(
value = UserController.class,
includeFilters = @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = SecurityConfig.class),
excludeFilters = @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = CacheConfig.class)
)
@Import({SecurityConfig.class, MapperConfig.class}) // Import specific configurations
@WithUserDetails("testuser") // Default user for all tests
class UserControllerCustomConfigTest {
@Autowired
private MockMvc mockMvc;
@MockBean
private UserService userService;
@MockBean
private CacheManager cacheManager; // Excluded from main app but needed for test
@Test
void shouldWorkWithCustomConfiguration() throws Exception {
// Test implementation
}
}

Custom @DataJpaTest Configuration

import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.context.annotation.Import;
import org.springframework.data.auditing.DateTimeProvider;
import org.springframework.data.domain.AuditorAware;
import java.time.LocalDateTime;
import java.util.Optional;
@DataJpaTest
@Import({JpaConfig.class, AuditingConfig.class}) // Import additional configurations
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
class UserRepositoryWithAuditingTest {
@Autowired
private UserRepository userRepository;
@Autowired
private TestEntityManager testEntityManager;
@Test
void shouldAuditCreatedAndModifiedDates() {
// Given
User user = new User("audit.user", "[email protected]", "Audit", "User");
// When
User savedUser = userRepository.save(user);
// Then
assertThat(savedUser.getCreatedAt()).isNotNull();
assertThat(savedUser.getCreatedBy()).isEqualTo("system");
}
}
// Configuration for auditing
@Configuration
@EnableJpaAuditing(auditorAwareRef = "auditorProvider", dateTimeProviderRef = "dateTimeProvider")
class AuditingConfig {
@Bean
public AuditorAware<String> auditorProvider() {
return () -> Optional.of("system");
}
@Bean
public DateTimeProvider dateTimeProvider() {
return () -> Optional.of(LocalDateTime.now());
}
}

Best Practices

1. Test Organization

// Good practice: Use nested tests for better organization
@WebMvcTest(UserController.class)
class UserControllerTest {
@Nested
@DisplayName("GET /api/users")
class GetUsers {
// Tests for GET endpoint
}
@Nested
@DisplayName("POST /api/users")
class CreateUser {
// Tests for POST endpoint
}
}

2. Test Data Management

@DataJpaTest
@TestInstance(TestInstance.Lifecycle.PER_CLASS) // Share test instance between methods
class UserRepositoryDataTest {
@BeforeAll
void setUpTestData() {
// Set up test data once for all tests
}
@AfterEach
void cleanUp() {
// Clean up after each test
userRepository.deleteAll();
}
}

3. Assertion Best Practices

class AssertionBestPractices {
@Test
void goodAssertions() {
// Use AssertJ for fluent assertions
assertThat(result).isNotNull();
assertThat(result.getUsername()).isEqualTo("john.doe");
assertThat(result.getEmail()).contains("@");
assertThat(usersList).hasSize(3).extracting(User::getLastName).contains("Doe");
}
@Test
void goodMockVerification() {
// Verify interactions with mocks
verify(userService, times(1)).getUserById(1L);
verify(userService, never()).deleteUser(any());
verifyNoMoreInteractions(userService);
}
}

These comprehensive examples demonstrate how to effectively use @WebMvcTest for testing web controllers in isolation and @DataJpaTest for testing JPA repositories and entities. The key benefits include faster test execution, focused testing of specific layers, and easier debugging of issues in isolated components.