Spring Boot环境下Mock RestTemplate实现外部API调用单元测试的问题求助

根据你的代码和描述，我来帮你分析问题并给出两种可行的测试方案，确保不会触发实际API调用，同时能正确验证方法返回值。

为什么你的测试会触发实际调用？ #

你当前的测试思路是对的，但可能存在两个核心问题：

1. SnowFlakeServiceImpl中的配置变量（如snowFlakeClientId、snowFlakeTokenRequestUrl等）是通过@Value注入的，测试中没有初始化这些变量，可能导致请求参数异常，甚至Mockito的匹配逻辑失效。
2. 如果之前尝试MockRestServiceServer时，绑定的RestTemplate和Service实际使用的不是同一个实例，就会触发真实请求。

方案一：使用Mockito Mock RestTemplate（完善你当前的实现） #

这种方式直接Mock RestTemplate，通过构造函数注入到Service中，确保不会触发真实调用。

步骤1：完善Service的构造函数 #

给SnowFlakeServiceImpl添加包含所有配置参数的构造函数，方便测试时手动注入：

public SnowFlakeServiceImpl(RestTemplate restTemplate,
                           @Value("${snowflake.client.id}") String snowFlakeClientId,
                           @Value("${snowflake.client.secret}") String snowFlakeClientSecret,
                           @Value("${snowflake.token.request.url}") String snowFlakeTokenRequestUrl,
                           @Value("${snowflake.refresh.token.grant.type}") String snowFlakeRefreshTokenGrantType,
                           @Value("${snowflake.refresh.token}") String refreshToken,
                           @Value("${snowflake.redirect.url}") String snowFlakeRedirectUrl) {
    this.restTemplate = restTemplate;
    this.snowFlakeClientId = snowFlakeClientId;
    this.snowFlakeClientSecret = snowFlakeClientSecret;
    this.snowFlakeTokenRequestUrl = snowFlakeTokenRequestUrl;
    this.snowFlakeRefreshTokenGrantType = snowFlakeRefreshTokenGrantType;
    this.refreshToken = refreshToken;
    this.snowFlakeRedirectUrl = snowFlakeRedirectUrl;
}

步骤2：编写测试代码 #

import org.junit.jupiter.api.Test;
import org.mockito.ArgumentMatchers;
import static org.mockito.Mockito.*;
import static org.assertj.core.api.Assertions.*;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;

public class SnowFlakeServiceTest {
    // Mock RestTemplate实例
    private final RestTemplate restTemplate = mock(RestTemplate.class);
    
    // 测试用配置参数
    private final String testClientId = "test-client-id";
    private final String testClientSecret = "test-client-secret";
    private final String testTokenUrl = "https://fake-snowflake-api.com/token";
    private final String testGrantType = "refresh_token";
    private final String testRefreshToken = "fake-refresh-token";
    private final String testRedirectUrl = "https://your-app.com/redirect";
    
    // 初始化Service，传入Mock的RestTemplate和测试配置
    private final SnowFlakeServiceImpl snowFlakeService = new SnowFlakeServiceImpl(
            restTemplate,
            testClientId,
            testClientSecret,
            testTokenUrl,
            testGrantType,
            testRefreshToken,
            testRedirectUrl
    );

    @Test
    public void testGetAccessToken() {
        // 准备预期的响应数据
        SnowFlakeTokenDTO expectedToken = new SnowFlakeTokenDTO();
        expectedToken.setAccessToken("fakeAccessToken");
        expectedToken.setExpiresIn(600);
        expectedToken.setTokenType("Bearer");

        ResponseEntity<SnowFlakeTokenDTO> mockResponse = new ResponseEntity<>(expectedToken, HttpStatus.OK);

        // 精确匹配RestTemplate的exchange调用参数
        when(restTemplate.exchange(
                eq(testTokenUrl),
                eq(HttpMethod.POST),
                ArgumentMatchers.any(HttpEntity.class),
                eq(SnowFlakeTokenDTO.class)))
                .thenReturn(mockResponse);

        // 执行测试方法
        String result = snowFlakeService.getAccessToken();

        // 断言返回值符合预期
        assertThat(result).isEqualTo(expectedToken.getAccessToken());
        
        // 验证RestTemplate的exchange方法确实被调用了一次
        verify(restTemplate, times(1)).exchange(
                eq(testTokenUrl),
                eq(HttpMethod.POST),
                ArgumentMatchers.any(HttpEntity.class),
                eq(SnowFlakeTokenDTO.class));
    }
}

方案二：使用MockRestServiceServer（模拟外部API响应） #

如果你更倾向于模拟真实的HTTP请求交互，可以使用Spring提供的MockRestServiceServer，它能绑定RestTemplate并拦截所有请求，返回模拟响应。

测试代码示例 #

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.http.MediaType;
import org.springframework.test.web.client.MockRestServiceServer;
import static org.springframework.test.web.client.match.MockRestRequestMatchers.*;
import static org.springframework.test.web.client.response.MockRestResponseCreators.*;
import static org.assertj.core.api.Assertions.*;
import org.springframework.web.client.RestTemplate;
import java.util.Base64;

public class SnowFlakeServiceTest {
    private RestTemplate restTemplate;
    private MockRestServiceServer mockServer;
    private SnowFlakeServiceImpl snowFlakeService;
    
    // 测试用配置参数
    private final String testClientId = "test-client-id";
    private final String testClientSecret = "test-client-secret";
    private final String testTokenUrl = "https://fake-snowflake-api.com/token";
    private final String testGrantType = "refresh_token";
    private final String testRefreshToken = "fake-refresh-token";
    private final String testRedirectUrl = "https://your-app.com/redirect";

    @BeforeEach
    void setUp() {
        restTemplate = new RestTemplate();
        // 绑定RestTemplate和MockServer，拦截所有请求
        mockServer = MockRestServiceServer.createServer(restTemplate);
        
        // 初始化Service
        snowFlakeService = new SnowFlakeServiceImpl(
                restTemplate,
                testClientId,
                testClientSecret,
                testTokenUrl,
                testGrantType,
                testRefreshToken,
                testRedirectUrl
        );
    }

    @Test
    public void testGetAccessToken() {
        // 生成Basic Auth的Header值
        String basicAuth = "Basic " + Base64.getEncoder().encodeToString((testClientId + ":" + testClientSecret).getBytes());
        
        // 模拟外部API的响应：匹配请求条件，返回预期的JSON数据
        mockServer.expect(requestTo(testTokenUrl))
                .andExpect(method(HttpMethod.POST))
                .andExpect(content().contentType(MediaType.APPLICATION_FORM_URLENCODED))
                .andExpect(header("Authorization", basicAuth))
                .andExpect(requestBody().formData("grant_type", testGrantType))
                .andExpect(requestBody().formData("refresh_token", testRefreshToken))
                .andExpect(requestBody().formData("redirect_uri", testRedirectUrl))
                .andRespond(withSuccess()
                        .contentType(MediaType.APPLICATION_JSON)
                        .body("{\"access_token\":\"fakeAccessToken\",\"expires_in\":600,\"token_type\":\"Bearer\"}"));

        // 执行测试方法
        String result = snowFlakeService.getAccessToken();

        // 断言返回值符合预期
        assertThat(result).isEqualTo("fakeAccessToken");
        
        // 验证所有预期的请求都被触发
        mockServer.verify();
    }
}

注意事项 #

• MockRestServiceServer必须和Service使用的同一个RestTemplate实例绑定，否则模拟不会生效，会触发真实请求。
• 通过requestTo、method、header等方法精确匹配请求，确保模拟响应只针对目标请求触发。

内容的提问来源于stack exchange，提问作者anonymous