使用Spring WebClient with retry时使用StepVerifier块进行测试

Question

编辑：这里https://github.com/wujek-srujek/reactor-retry-test是一个包含所有代码的存储库。

我有以下SpringWebClient代码要发布到远程服务器（为了简洁起见，没有导入Kotlin代码）：

private val logger = KotlinLogging.logger {}

@Component
class Client(private val webClient: WebClient) {

    companion object {
        const val maxRetries = 2L
        val firstBackOff = Duration.ofSeconds(5L)
        val maxBackOff = Duration.ofSeconds(20L)
    }

    fun send(uri: URI, data: Data): Mono<Void> {
        return webClient
            .post()
            .uri(uri)
            .contentType(MediaType.APPLICATION_JSON)
            .bodyValue(data)
            .retrieve()
            .toBodilessEntity()
            .doOnSubscribe {
                logger.info { "Calling backend, uri: $uri" }
            }
            .retryExponentialBackoff(maxRetries, firstBackOff, maxBackOff, jitter = false) {
                logger.debug { "Call to $uri failed, will retry (#${it.iteration()} of max $maxRetries)" }
            }
            .doOnError {
                logger.error { "Call to $uri with $maxRetries retries failed with $it" }
            }
            .doOnSuccess {
                logger.info { "Call to $uri succeeded" }
            }
            .then()
    }
}

（它返回一个空的mono，因为我们不期望得到答案，也不关心它。）

我想测试两个案例，其中一个让我头疼，即我想测试的所有重试都被解雇了。我们使用的是mockwebserver(https://github.com/square/okhttp/tree/master/mockwebserver)和reactor-test中的stepverifier。（成功的测试很简单，不需要任何虚拟时间调度器的魔力，而且工作得很好。）以下是失败的代码：

@JsonTest
@ContextConfiguration(classes = [Client::class, ClientConfiguration::class])
class ClientITest @Autowired constructor(
    private val client: Client
) {
    lateinit var server: MockWebServer

    @BeforeEach
    fun `init mock server`() {
        server = MockWebServer()
        server.start()
    }

    @AfterEach
    fun `shutdown server`() {
        server.shutdown()
    }

   @Test
   fun `server call is retried and eventually fails`() {
       val data = Data()
       val uri = server.url("/server").uri()
       val responseStatus = HttpStatus.INTERNAL_SERVER_ERROR

       repeat((0..Client.maxRetries).count()) {
           server.enqueue(MockResponse().setResponseCode(responseStatus.value()))
       }

       StepVerifier.withVirtualTime { client.send(uri, data) }
           .expectSubscription()
           .thenAwait(Duration.ofSeconds(10)) // wait for the first retry
           .expectNextCount(0)
           .thenAwait(Duration.ofSeconds(20)) // wait for the second retry
           .expectNextCount(0)
           .expectErrorMatches {
               val cause = it.cause
               it is RetryExhaustedException &&
                       cause is WebClientResponseException &&
                       cause.statusCode == responseStatus
           }
           .verify()

       // assertions
       }
   }

我使用WithVirtualTime，因为我不希望测试花费近几秒的时间。问题是测试无限期地阻塞。以下是（简化的）日志输出：

okhttp3.mockwebserver.MockWebServer      : MockWebServer[51058] starting to accept connections
Calling backend, uri: http://localhost:51058/server
MockWebServer[51058] received request: POST /server HTTP/1.1 and responded: HTTP/1.1 500 Server Error
Call to http://localhost:51058/server failed, will retry (#1 of max 2)
Calling backend, uri: http://localhost:51058/server
MockWebServer[51058] received request: POST /server HTTP/1.1 and responded: HTTP/1.1 500 Server Error
Call to http://localhost:51058/server failed, will retry (#2 of max 2)

以下使用stepverifier但不使用WebClient的测试工作正常，即使重试次数较多：

@Test
fun test() {
    StepVerifier.withVirtualTime {
        Mono
            .error<RuntimeException>(RuntimeException())
            .retryExponentialBackoff(5,
                                     Duration.ofSeconds(5),
                                     Duration.ofMinutes(2),
                                     jitter = true) {
                println("Retrying")
            }
            .then()
    }
        .expectSubscription()
        .thenAwait(Duration.ofDays(1)) // doesn't matter
        .expectNextCount(0)
        .expectError()
        .verify()
}

谁能帮我修复测试，最好解释出了什么问题？

Answer 1

这是对虚拟时间和stepverifier中时钟操作方式的限制。TheNaWait方法与基础调度不同步（例如，RetryBackoff操作的一部分）。这意味着操作员在时钟已经提前一天的点提交重试任务。因此，第二次重试被安排在+1天10秒，因为时钟是+1天。在此之后，时钟从不提前，因此不会向MockWebServer发出额外的请求。

您的情况变得更加复杂，因为涉及到一个额外的组件，MockWebServer，它仍然“实时”工作。尽管推进虚拟时钟是一个非常快速的操作，但来自MockWebServer的响应仍然通过套接字，因此重试调度有一定的延迟，从测试编写的角度来看，这使得事情变得更加复杂。

一个可能的解决方案是将VirtualTimeScheduler的创建外部化，并在并行线程中将AdvanceTimeBy调用绑定到MockServer.takerequest()。