解决RestTemplate.exchange方法模拟时的类型不匹配错误

public <T> ResponseEntity<T> exchange(
    String url,
    HttpMethod method,
    @Nullable HttpEntity<?> requestEntity,
    Class<T> responseType,
    Object... uriVariables
) throws RestClientException

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import org.springframework.http.*; // 确保导入正确的Spring HTTP相关类
import org.springframework.web.client.RestTemplate; // 确保导入正确的RestTemplate

import java.util.Collections;
import java.util.Map;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.*; // 导入Mockito的参数匹配器
import static org.mockito.Mockito.when;

public class RestTemplateExchangeMockingGuide {

    private RestTemplate restTemplate;

    @BeforeEach
    void setUp() {
        // 在每个测试方法执行前，创建一个RestTemplate的Mock对象
        restTemplate = Mockito.mock(RestTemplate.class);
    }

    @Test
    void testExchangeMethodWithSpecificArguments() {
        String expectedResponseBody = "Hello from Mocked Server!";
        String url = "http://api.example.com/data/123";
        HttpMethod method = HttpMethod.GET;

        // 构建请求头
        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "Bearer token123");
        // 构建请求实体，这里没有请求体，所以传入null作为body
        HttpEntity<String> requestEntity = new HttpEntity<>(headers); 

        Class<String> responseType = String.class;
        Object[] uriVariables = {}; // 如果URL中没有路径变量，可以为空数组

        // 1. 设置Mock行为：当restTemplate.exchange被调用时，返回一个预期的ResponseEntity
        // 注意：这里我们使用Mockito的eq()匹配器来精确匹配参数，
        // 对于HttpEntity，如果其内部状态（如请求头）很重要，也应该精确匹配。
        // 如果requestEntity的内容不重要，可以使用any(HttpEntity.class)。
        when(restTemplate.exchange(
                eq(url),
                eq(method),
                any(HttpEntity.class), // 使用any()来匹配任何HttpEntity对象，简化匹配
                eq(responseType),
                anyVararg() // 匹配任何可变参数列表
        )).thenReturn(new ResponseEntity<>(expectedResponseBody, HttpStatus.OK));

        // 2. 调用实际使用restTemplate的方法（或直接调用mock对象来验证）
        // 这里的调用参数需要与when()中设置的匹配器兼容
        ResponseEntity<String> actualResponse = restTemplate.exchange(
                url,
                method,
                requestEntity, // 这里可以传入实际的requestEntity，any(HttpEntity.class)会匹配它
                responseType,
                uriVariables
        );

        // 3. 验证结果
        assertEquals(HttpStatus.OK, actualResponse.getStatusCode());
        assertEquals(expectedResponseBody, actualResponse.getBody());
    }

    @Test
    void testExchangeMethodWithMoreGenericMatchers() {
        String genericResponseBody = "Generic Mocked Response";

        // 当您不关心exchange方法调用的具体参数时，可以使用更通用的匹配器
        when(restTemplate.exchange(
                anyString(), // 匹配任何String类型的URL
                any(HttpMethod.class), // 匹配任何HttpMethod
                any(HttpEntity.class), // 匹配任何HttpEntity
                ArgumentMatchers.<Class<String>>any(), // 匹配任何Class<String>类型
                anyVararg() // 匹配任何可变参数
        )).thenReturn(new ResponseEntity<>(genericResponseBody, HttpStatus.CREATED));

        // 模拟一个不同的调用，验证通用匹配器是否生效
        ResponseEntity<String> actualResponse = restTemplate.exchange(
                "http://another.api.com/users",
                HttpMethod.POST,
                new HttpEntity<>("{\"name\":\"test\"}", new HttpHeaders()),
                String.class,
                "user" // 即使有uriVariables，anyVararg()也能匹配
        );

        assertEquals(HttpStatus.CREATED, actualResponse.getStatusCode());
        assertEquals(genericResponseBody, actualResponse.getBody());
    }
}