Spring WebFlux控制器中集成与测试非响应式验证逻辑

@GetMapping("/mango/{id}")
public Mono<Mango> getMango(@PathVariable("id") final String id){
    validateId(id); // 同步方法调用
    return serviceLayer.someMonoData();
}

import reactor.core.publisher.Mono;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MangoController {

    private final MangoService serviceLayer;

    public MangoController(MangoService serviceLayer) {
        this.serviceLayer = serviceLayer;
    }

    @GetMapping("/mango/{id}")
    public Mono<Mango> getMango(@PathVariable("id") final String id) {
        // 使用Mono.fromRunnable将同步验证方法包装成响应式操作
        // 然后使用.then()将其与后续的响应式服务调用连接起来
        return Mono.fromRunnable(() -> validateId(id))
                   .then(serviceLayer.someMonoData());
    }

    // 假设这是一个非响应式的同步验证方法
    private void validateId(String id) {
        if (id == null || id.trim().isEmpty() || "invalid".equals(id)) {
            // 模拟抛出自定义的 BadRequest 异常
            throw new IllegalArgumentException("Invalid ID provided");
        }
        // 其他验证逻辑...
    }
}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.reactive.WebFluxTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.test.web.reactive.server.WebTestClient;
import reactor.core.publisher.Mono;

import static org.mockito.Mockito.when;
import static org.mockito.ArgumentMatchers.anyString;

@WebFluxTest(MangoController.class) // 针对 MangoController 进行 WebFlux 测试
public class MangoControllerTest {

    @Autowired
    private WebTestClient webTestClient;

    @MockBean
    private MangoService serviceLayer; // 模拟服务层

    private static final String ENDPOINT_URL = "/mango/invalid"; // 用于测试无效ID的URL
    private static final String VALID_ENDPOINT_URL = "/mango/123"; // 用于测试有效ID的URL

    @Test
    public void testGetMango_withInvalidId_shouldReturnBadRequest() {
        // 当 serviceLayer.someMonoData() 被调用时，返回一个空的 Mono (此测试中不应被调用)
        when(serviceLayer.someMonoData()).thenReturn(Mono.empty());

        // 发送一个带有无效ID的请求
        webTestClient.get()
                .uri(ENDPOINT_URL) // 使用无效ID
                .exchange()
                .expectStatus()
                .isBadRequest() // 期望状态码为 400 Bad Request
                .expectBody()
                .jsonPath("$.message") // 假设错误响应体包含一个 message 字段
                .isEqualTo("Invalid ID provided"); // 验证错误消息
    }

    @Test
    public void testGetMango_withValidId_shouldReturnOk() {
        // 模拟 serviceLayer 返回一个有效的 Mango 对象
        Mango mockMango = new Mango("123", "Sweet Mango");
        when(serviceLayer.someMonoData()).thenReturn(Mono.just(mockMango));

        // 发送一个带有有效ID的请求
        webTestClient.get()
                .uri(VALID_ENDPOINT_URL) // 使用有效ID
                .exchange()
                .expectStatus()
                .isOk() // 期望状态码为 200 OK
                .expectBody(Mango.class)
                .isEqualTo(mockMango); // 验证返回的 Mango 对象
    }

    // 假设 Mango 类如下
    static class Mango {
        private String id;
        private String name;

        public Mango(String id, String name) {
            this.id = id;
            this.name = name;
        }

        public String getId() { return id; }
        public String getName() { return name; }

        // 需要 equals 和 hashCode 方法用于 body 比较
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Mango mango = (Mango) o;
            return id.equals(mango.id) && name.equals(mango.name);
        }

        @Override
        public int hashCode() {
            return java.util.Objects.hash(id, name);
        }
    }
}