在Spring WebFlux控制器中集成并测试非响应式校验逻辑

@GetMapping("/mango/{id}")
public Mono<Mango> getMango(@PathVariable("id") final String id){
    validateId(id); // 非响应式校验方法
    return serviceLayer.someMonoData();
}

@Test
public void testInvalidIdThrowsBadRequest() {
    // 假设serviceLayer.someMonoData()在正常情况下会返回一个Mono<Mango>
    // 但在这个测试中，我们关注的是校验失败
    when(serviceLayer.someMonoData()).thenReturn(Mono.just(new Mango("valid-id")));

    webTestClient.get()
            .uri("/mango/invalid-id") // 传入一个预期会触发validateId()异常的ID
            .exchange()
            .expectStatus()
            .isBadRequest(); // 期望得到400错误
}

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;
    }

    // 假设validateId是一个私有方法，用于抛出自定义异常
    private void validateId(String id) {
        if ("invalid-id".equals(id)) {
            throw new CustomBadRequestException("ID is invalid: " + id);
        }
        // 更多校验逻辑...
    }

    @GetMapping("/mango/{id}")
    public Mono<Mango> getMango(@PathVariable("id") final String id) {
        // 使用Mono.fromRunnable将validateId集成到响应式流中
        return Mono.fromRunnable(() -> validateId(id))
                   .then(serviceLayer.someMonoData()); // 在校验完成后，执行服务层调用
    }
}

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.Mockito.never;
import static org.mockito.Mockito.verify;

// 假设MangoService和CustomBadRequestException已经定义
class Mango {
    String id;
    public Mango(String id) { this.id = id; }
}
class MangoService {
    public Mono<Mango> someMonoData() { return Mono.just(new Mango("default")); }
}
class CustomBadRequestException extends RuntimeException {
    public CustomBadRequestException(String message) { super(message); }
}

@WebFluxTest(MangoController.class) // 指定测试的控制器
public class MangoControllerTest {

    @Autowired
    private WebTestClient webTestClient;

    @MockBean // 模拟服务层，因为我们不测试服务层逻辑
    private MangoService serviceLayer;

    @Test
    public void testGetMango_withInvalidId_shouldReturnBadRequest() {
        // 对于无效ID的测试，serviceLayer.someMonoData() 不应该被调用
        // 因此这里不需要when().thenReturn()来模拟成功响应，
        // 但可以模拟以防万一在其他路径被调用，或者明确地不调用
        when(serviceLayer.someMonoData()).thenReturn(Mono.just(new Mango("valid-response")));

        webTestClient.get()
                .uri("/mango/invalid-id") // 传入一个会触发validateId()异常的ID
                .exchange()
                .expectStatus()
                .isBadRequest() // 期望得到400错误
                .expectBody()
                .jsonPath("$.message").isEqualTo("ID is invalid: invalid-id"); // 假设错误响应体包含message字段

        // 验证serviceLayer.someMonoData()在校验失败时确实没有被调用
        verify(serviceLayer, never()).someMonoData();
    }

    @Test
    public void testGetMango_withValidId_shouldReturnOk() {
        Mango expectedMango = new Mango("valid-id");
        when(serviceLayer.someMonoData()).thenReturn(Mono.just(expectedMango));

        webTestClient.get()
                .uri("/mango/valid-id") // 传入一个有效ID
                .exchange()
                .expectStatus()
                .isOk() // 期望得到200 OK
                .expectBody(Mango.class)
                .isEqualTo(expectedMango);

        // 验证serviceLayer.someMonoData()在校验成功时被调用
        verify(serviceLayer).someMonoData();
    }
}