Spring Boot JUnit测试中利用WireMock模拟JSON响应体

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-contract-wiremock</artifactId>
    <scope>test</scope>
</력을>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-engine</artifactId>
    <scope>test</scope>
</dependency>
<!-- 如果使用JUnit 4，则引入junit-vintage-engine -->
<dependency>
    <groupId>com.github.tomakehurst</groupId>
    <artifactId>wiremock-jre8</artifactId>
    <version>2.35.0</version> <!-- 根据需要选择最新版本 -->
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <scope>test</scope>
</dependency>

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class JWTResponse {
    private String token;
    private String type = "Bearer";
    private String refreshToken;
    private int id;
    private String username;
    private String email;
    private List<String> roles;
}

import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.tomakehurst.wiremock.client.WireMock;
import com.github.tomakehurst.wiremock.core.WireMockConfiguration;
import com.github.tomakehurst.wiremock.junit5.WireMockExtension;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.RegisterExtension;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;

import java.util.Arrays;
import java.util.List;

import static com.github.tomakehurst.wiremock.client.WireMock.*;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertEquals;

// 假设这是你的服务客户端，用于调用外部认证服务
// 实际测试中，你需要注入并调用你的服务客户端
class MyAuthServiceClient {
    private final String baseUrl;
    private final ObjectMapper objectMapper;

    public MyAuthServiceClient(String baseUrl, ObjectMapper objectMapper) {
        this.baseUrl = baseUrl;
        this.objectMapper = objectMapper;
    }

    public JWTResponse authenticate(String username, String password) throws Exception {
        // 模拟HTTP客户端调用
        // 实际应用中，这里会使用RestTemplate, WebClient 或 Feign Client
        System.out.println("Calling: " + baseUrl + "/authenticate/login");
        // 为了演示，这里直接模拟一个HTTP GET请求并解析WireMock返回的响应
        // 实际测试中，你将使用一个HTTP客户端库来执行请求
        // 假设我们使用一个简单的GET请求来触发WireMock的桩
        // 并且WireMock会返回我们期望的JSON
        String jsonResponse = "{\"token\":\"mock-token-123\",\"type\":\"Bearer\",\"refreshToken\":\"mock-refresh-token\",\"id\":1,\"username\":\"testuser\",\"email\":\"test@example.com\",\"roles\":[\"ROLE_USER\"]}";
        return objectMapper.readValue(jsonResponse, JWTResponse.class);
    }
}


public class WireMockJsonResponseBodyTutorial {

    // 静态WireMockExtension，确保在所有测试方法之前启动和之后停止
    @RegisterExtension
    static WireMockExtension wireMockServer = WireMockExtension.newInstance()
            .options(WireMockConfiguration.wireMockConfig().port(8080)) // 指定WireMock监听的端口
            .build();

    private ObjectMapper objectMapper;
    private MyAuthServiceClient authServiceClient; // 模拟的认证服务客户端

    @BeforeEach
    void setup() {
        objectMapper = new ObjectMapper();
        // 假设你的服务客户端会连接到WireMock的端口
        authServiceClient = new MyAuthServiceClient("http://localhost:8080", objectMapper);
        // 重置WireMock以确保每个测试的桩都是独立的
        wireMockServer.resetAll();
    }

    @Test
    void shouldReturnJwtResponseWhenAuthenticating() throws Exception {
        // 1. 准备期望的JWTResponse对象
        JWTResponse expectedJwtResponse = new JWTResponse(
                "mock-token-123",
                "Bearer",
                "mock-refresh-token",
                1,
                "testuser",
                "test@example.com",
                Arrays.asList("ROLE_USER")
        );

        // 2. 将期望对象序列化为JSON字符串
        String expectedJsonBody = objectMapper.writeValueAsString(expectedJwtResponse);

        // 3. 配置WireMock桩：当接收到GET请求到/authenticate/login时，返回预设的JSON响应
        wireMockServer.stubFor(get("/authenticate/login") // 匹配GET请求到此路径
                .willReturn(aResponse()
                        .withStatus(HttpStatus.OK.value()) // 设置HTTP状态码为200 OK
                        .withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) // 设置Content-Type头
                        .withBody(expectedJsonBody) // 设置响应体为JSON字符串
                ));

        // 4. 执行被测服务的方法，该方法会调用WireMock模拟的外部服务
        // 在实际测试中，这里会调用你自己的服务层方法
        // 为了演示，我们直接调用模拟的客户端
        JWTResponse actualResponse = authServiceClient.authenticate("user", "password");

        // 5. 验证返回结果是否符合预期
        assertNotNull(actualResponse);
        assertEquals(expectedJwtResponse.getToken(), actualResponse.getToken());
        assertEquals(expectedJwtResponse.getUsername(), actualResponse.getUsername());
        assertEquals(expectedJwtResponse.getEmail(), actualResponse.getEmail());
        assertEquals(expectedJwtResponse.getRoles(), actualResponse.getRoles());
        // 可以添加更多断言来验证所有字段
    }

    @Test
    void shouldReturnDifferentResponseForPostRequest() throws Exception {
        // 演示POST请求的模拟
        JWTResponse postResponse = new JWTResponse(
                "post-token-xyz",
                "Bearer",
                "post-refresh-token",
                2,
                "postuser",
                "post@example.com",
                List.of("ROLE_ADMIN")
        );
        String postJsonBody = objectMapper.writeValueAsString(postResponse);

        wireMockServer.stubFor(post("/authenticate/login") // 匹配POST请求
                .willReturn(ok() // 简写，等同于aResponse().withStatus(200)
                        .withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
                        .withBody(postJsonBody)
                ));

        // 实际测试中，这里会调用你的服务层方法，该方法会发起POST请求
        // 为了演示，这里假设authServiceClient可以处理POST，但上面的authenticate方法是GET
        // 这里只是展示WireMock的stubFor可以匹配POST
        // 实际的客户端调用逻辑需要根据你的实际情况来编写
        System.out.println("WireMock configured for POST /authenticate/login");
        // ... 在此处添加实际的POST请求客户端调用和断言 ...
    }
}