Spring Boot 微服务控制器测试：处理外部服务依赖与JWT认证的策略

// 原始的 getJWTTokenForRoleUser 方法片段
MvcResult result = mockMvc.perform(MockMvcRequestBuilders.post("/authenticate/login")
                        .contentType(MediaType.APPLICATION_JSON)
                        .content(asJsonString(loginRequest)))
                .andDo(MockMvcResultHandlers.print())
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andReturn();

// 假设订单服务中存在一个AuthServiceProxy类
@Service
public class AuthServiceProxy {
    private final RestTemplate restTemplate;
    // ... 其他依赖

    public AuthServiceProxy(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    public JWTResponse login(LoginRequest loginRequest) {
        // 实际调用认证服务的逻辑
        return restTemplate.postForObject("http://AUTH-SERVICE/authenticate/login", loginRequest, JWTResponse.class);
    }
}

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
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.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@WebMvcTest(OrderController.class) // 假设测试OrderController
public class OrderControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean // 模拟AuthServiceProxy
    private AuthServiceProxy authServiceProxy;

    // ... 其他依赖和工具方法

    @Test
    void test_When_placeOrder_DoPayment_Success_WithMockedAuthService() throws Exception {
        // 1. 模拟AuthServiceProxy的行为
        JWTResponse mockJwtResponse = new JWTResponse("mocked_jwt_token_for_user", "User", List.of("ROLE_USER"));
        Mockito.when(authServiceProxy.login(Mockito.any(LoginRequest.class)))
               .thenReturn(mockJwtResponse);

        // 2. 使用模拟的JWT令牌进行订单放置请求
        OrderRequest orderRequest = getMockOrderRequest();
        String jwt = mockJwtResponse.getToken(); // 从模拟响应中获取令牌

        mockMvc.perform(post("/order/placeorder")
                        .contentType(MediaType.APPLICATION_JSON_VALUE)
                        .header("Authorization", "Bearer " + jwt)
                        .content(objectMapper.writeValueAsString(orderRequest)))
                .andExpect(status().isOk());

        // ... 后续断言
    }

    // 辅助方法，如果仍需要生成LoginRequest
    private LoginRequest getMockLoginRequest() {
        return new LoginRequest("User", "User");
    }
}

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.security.Keys; // 导入Keys用于生成安全的密钥
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
import javax.crypto.SecretKey; // 使用javax.crypto.SecretKey

// 假设在OrderControllerTest中
public class OrderControllerTest {

    // 注入或定义JWT密钥和过期时间，确保与Auth Service一致
    // 注意：在实际项目中，测试密钥应与生产密钥隔离，或通过测试配置提供
    @Value("${application.jwt.secret}") // 从application-test.properties加载
    private String jwtSecret;

    @Value("${application.jwt.expiration-ms}") // 从application-test.properties加载
    private long jwtExpirationMs;

    // ... 其他注入和测试方法

    /**
     * 为测试目的生成一个有效的JWT令牌
     * @param username 用户名
     * @param roles 用户的角色列表
     * @return 生成的JWT字符串
     */
    private String generateTestJwtToken(String username, List<String> roles) {
        // 将字符串密钥转换为SecretKey
        SecretKey key = Keys.hmacShaKeyFor(jwtSecret.getBytes());

        List<GrantedAuthority> authorities = roles.stream()
                .map(SimpleGrantedAuthority::new)
                .collect(Collectors.toList());

        return Jwts.builder()
                .setSubject(username)
                .claim("roles", authorities) // 根据你的Auth Service如何存储角色信息来调整
                .setIssuedAt(new Date())
                .setExpiration(new Date((new Date()).getTime() + jwtExpirationMs))
                .signWith(key, SignatureAlgorithm.HS512) // 使用HS512算法
                .compact();
    }

    // 重构后的 getJWTTokenForRoleUser 方法
    private String getJWTTokenForRoleUser() {
        // 直接生成一个带有"User"角色和用户名的JWT
        return generateTestJwtToken("User", Collections.singletonList("ROLE_USER"));
    }

    @Test
    @DisplayName("Place Order -- Success Scenario")
    @WithMockUser(username = "User", authorities = { "ROLE_USER" }) // 此注解模拟了SecurityContext，但JWT仍需手动添加到Header
    void test_When_placeOrder_DoPayment_Success() throws Exception {

        OrderRequest orderRequest = getMockOrderRequest();
        String jwt = getJWTTokenForRoleUser(); // 现在这里直接生成JWT

        mockMvc.perform(MockMvcRequestBuilders.post("/order/placeorder")
                        .contentType(MediaType.APPLICATION_JSON_VALUE)
                        .header("Authorization", "Bearer " + jwt) // 使用生成的JWT
                        .content(objectMapper.writeValueAsString(orderRequest)))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andReturn();

        // ... 后续断言
    }
}

# src/test/resources/application-test.properties
application.jwt.secret=yourVerySecureTestSecretKeyForJWTGenerationThatIsAtLeast256BitsLong
application.jwt.expiration-ms=3600000 # 1小时，或根据需要设置