使用 Spring 和 State 机器在反应堆测试中编写阻塞操作

Question

我对反应堆编程完全陌生，自从升级到最新的 Spring Boot / State 机器后，我真的很难迁移旧的集成测试。 大多数集成测试具有相同的基本步骤：

1. 调用一个返回Mono的方法并启动一个 state 机器并返回一个 object，其中包含生成的唯一id以及与初始请求相关的一些其他信息。
2. 使用返回的 object 调用一个方法来验证数据库中的值是否已更新（使用在步骤 1 中重试的 object 的信息）
3. 以固定时间间隔轮询在数据库中检查值是否已更改的方法，直到值已更改或发生预定义的超时。
4. 查看数据库中的另一张表是否已更新另一个 object

下面是一个例子：

    @Test
    void testEndToEnd() {
      var instance = ServiceInstance.buildDefault(); 
      var updateRequest = UpdateRequest.build(instance);

      // retrieve an update Response related to the request 
      // since a unique id is generated when triggering the update request
      // before starting a stateMachine that goes through different steps        
      var updateResponse = service.updateInstance(updateRequest).block(); 

      await().alias("Check if operation was successful")
             .atMost(Duration.ofSeconds(120))
             .pollInterval(Duration.ofSeconds(2))
             .until(() -> expectOperationState(updateResponse, OperationState.SUCCESS))
                        
        // check if values are updated in secondary table
        assertValuesInTransaction(updateResponse);
}

这之前工作正常，但自从最近的更新失败后出现异常：

java.lang.IllegalStateException: block()/blockFirst()/blockLast() are blocking, which is not supported in thread parallel-6
    at reactor.core.publisher.BlockingSingleSubscriber.blockingGet(BlockingSingleSubscriber.java:83)
    at reactor.core.publisher.Mono.block(Mono.java:1710)

我看到了使用StepVerifier测试反应器方法的好习惯，但我看不到如何重现使用Awaitability完成的部分以轮询以查看数据库中的值是否已更改，因为检查数据库的方法返回Mono和不是不断发送值的流量。

关于如何完成此操作或使 spring 堆栈接受阻塞操作的任何想法？

谢谢

我目前的堆栈：

• Spring 启动 3.0.1
• Spring State 机器 3.0.1
• Spring 6
• Junit 5.9.2

Answer 1

因此，正如评论中所讨论的，这里是一个带有评论的示例。 我使用flatMap来订阅expectOperationState返回的内容。 还有Mono.fromCallable使用它检查某个方法的值，如果它在 3 秒内没有发出任何东西 - 超时异常被抛出。 我们也可以尝试从expectOperationState中删除这个boolean值，并将代码重构为只返回带有完成信号的Mono<Void> ，但这基本上显示了如何实现你想要的。

class TestStateMachine {
    @Test
    void testUntilSomeOperationCompletes() {

        final Service service = new Service();
        final UpdateRequest updateRequest = new UpdateRequest();
        StepVerifier.create(service.updateInstance(updateRequest)
                        .flatMap(updateResponse -> expectOperationState(updateResponse, OperationState.SUCCESS))
                )
                .consumeNextWith(Assertions::assertTrue)
                .verifyComplete();

    }

    private Mono<Boolean> expectOperationState(final UpdateResponse updateResponse, final OperationState success) {
        return Mono.fromCallable(() -> {
                    while (true) {
                        boolean isInDb = checkValueFromDb(updateResponse);
                        if (isInDb) {
                            return true;
                        }
                    }
                })
                .publishOn(Schedulers.single())
                //timeout if we not receive any value from callable within 3 seconds so that we do not check forever
                .timeout(Duration.ofSeconds(3));

    }

    private boolean checkValueFromDb(final UpdateResponse updateResponse) {
        return true;
    }
    
}

class Service {
    Mono<UpdateResponse> updateInstance(final UpdateRequest updateRequest) {
        return Mono.just(new UpdateResponse());
    }
}

这是一个不使用Mono<Boolean>的例子：

class TestStateMachine {
    @Test
    void test() {

        final Service service = new Service();
        final UpdateRequest updateRequest = new UpdateRequest();
        StepVerifier.create(service.updateInstance(updateRequest)
                        .flatMap(updateResponse -> expectOperationState(updateResponse, OperationState.SUCCESS).timeout(Duration.ofSeconds(3)))
                )
                .verifyComplete();
    }

    private Mono<Void> expectOperationState(final UpdateResponse updateResponse, final OperationState success) {
        return Mono.fromCallable(() -> {
                    while (true) {
                        boolean isInDb = checkValueFromDb(updateResponse);
                        if (isInDb) {
                            //return completed Mono
                            return Mono.<Void>empty();
                        }
                    }
                })
                .publishOn(Schedulers.single())
                //timeout if we not receive any value from callable within 3 seconds so that we do not check forever
                .timeout(Duration.ofSeconds(3))
                .flatMap(objectMono -> objectMono);


    }

    private boolean checkValueFromDb(final UpdateResponse updateResponse) {
        return true;
    }

}