Spring Boot集成测试中事务隔离与mockMvc的交互问题及解决方案

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.HttpHeaders;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.support.TransactionTemplate;

import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest
@AutoConfigureMockMvc
// 移除 @Transactional 注解，以便我们可以手动控制事务提交
class UserIntegrationTest {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private MockMvc mockMvc;

    @Autowired
    private PlatformTransactionManager transactionManager; // 注入事务管理器

    @Test
    void testSecurityFilterWithChangedUser() throws Exception {
        // 创建 TransactionTemplate 实例
        TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);

        final String oldUniqueName = "oldUniqueName";
        final String newUniqueName = "newUniqueName";
        final String endpointUrl = "/api/secure-endpoint"; // 假设的受保护接口

        // 1. 初始化一个用户并保存，确保其在数据库中存在
        transactionTemplate.execute(status -> {
            User initialUser = new User();
            initialUser.setUniqueName(oldUniqueName);
            // 假设User实体有其他必要的字段，这里省略
            userRepository.save(initialUser);
            return null;
        });

        // 2. 在一个独立的事务中修改用户并提交
        transactionTemplate.execute(status -> {
            User user = userRepository.findUserByUniqueName(oldUniqueName)
                                      .orElseThrow(() -> new IllegalStateException("User not found after initial save."));
            assertThat(user).isNotNull();

            user.setUniqueName(newUniqueName);
            userRepository.saveAndFlush(user); // saveAndFlush 将更改同步到数据库
            // TransactionTemplate 会在 execute 方法返回后自动提交事务
            return null;
        });

        // 此时，数据库中已提交的用户记录的 uniqueName 应该是 "newUniqueName"
        // 根据 oldUniqueName 查询应该返回 Optional.empty()

        // 3. 构建 mockMvc 请求，使用旧的 uniqueName
        HttpHeaders headers = new HttpHeaders();
        headers.add("X-Unique-Name", oldUniqueName); // 假设安全过滤器从这个Header获取

        // 4. 执行 mockMvc 请求，期望由于 oldUniqueName 不存在而导致未授权
        mockMvc.perform(get(endpointUrl).headers(headers))
               .andExpect(status().isUnauthorized()); // 期望未授权状态

        // 5. (可选) 验证数据库状态，确保测试没有留下脏数据
        // 可以再次使用 TransactionTemplate 清理或在 @AfterEach 中处理
        transactionTemplate.execute(status -> {
            userRepository.findUserByUniqueName(newUniqueName)
                          .ifPresent(userRepository::delete); // 清理测试数据
            return null;
        });
    }
}

@Override
@Transactional // 过滤器内部通常也需要事务
protected void doFilterInternal(
      HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
      throws ServletException, IOException {

    String uniqueNameFromHeader = extractUniqueNameFromRequest(request);
    try {
        // 这里会查询数据库中已提交的数据
        User user = userRepository.findUserByUniqueName(uniqueNameFromHeader)
                                  .orElseThrow(() -> new Exception("User not found for header unique name"));
        // update security context
        filterChain.doFilter(request, response); // 继续请求链
    }
    catch(Exception e) {
        // handle exception (e.g., set HTTP status to UNAUTHORIZED)
        response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
    }
}