Crash with POST requests and WebTestClient: Request body incomplete.

[joaoe]

Hi.

I'm getting the following crash

java.lang.IllegalArgumentException: Request body incomplete.

	at org.springframework.util.Assert.isTrue(Assert.java:116)
	at org.springframework.test.web.reactive.server.ExchangeResult.getRequestBodyContent(ExchangeResult.java:149)
	at org.springframework.restdocs.webtestclient.WebTestClientRequestConverter.convert(WebTestClientRequestConverter.java:73)
	at org.springframework.restdocs.webtestclient.WebTestClientRequestConverter.convert(WebTestClientRequestConverter.java:60)
	at org.springframework.restdocs.generate.RestDocumentationGenerator.handle(RestDocumentationGenerator.java:199)
	at org.springframework.restdocs.webtestclient.WebTestClientRestDocumentation.lambda$document$0(WebTestClientRestDocumentation.java:81)
	at org.springframework.test.web.reactive.server.DefaultWebTestClient$DefaultBodyContentSpec.lambda$consumeWith$2(DefaultWebTestClient.java:496)
	at org.springframework.test.web.reactive.server.ExchangeResult.assertWithDiagnostics(ExchangeResult.java:194)
	at org.springframework.test.web.reactive.server.DefaultWebTestClient$DefaultBodyContentSpec.consumeWith(DefaultWebTestClient.java:496)
	at MyTest.testMain(MyTest.java:72)

The issue is related with the use of a request body with a post request.
This happens due to an assert Assert.isTrue(MonoProcessor.isTerminated(). Inspecting that method isTerminated returns subscribers == TERMINATED, but in the case of the request body, debugging shows that subscribers == EMPTY.

Testcase follows.

[joaoe]

Testcase (can't upload java files)

import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInstance;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.restdocs.RestDocumentationContextProvider;
import org.springframework.restdocs.RestDocumentationExtension;
import org.springframework.restdocs.webtestclient.WebTestClientRestDocumentation;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.reactive.server.WebTestClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.reactive.config.EnableWebFlux;
import reactor.core.publisher.Mono;

import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.restdocs.webtestclient.WebTestClientRestDocumentation.document;

@ExtendWith({RestDocumentationExtension.class, SpringExtension.class})
@WebAppConfiguration
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
@ContextConfiguration(classes = {MyTest.TestConfig.class, MyTest.TestController.class})
public class MyTest {
    private static final String END_POINT = "/end-point";

    protected WebTestClient mockClient;

    @Configuration
    @EnableWebFlux
    public static class TestConfig {}

    @RestController
    public static class TestController {
        @PostMapping(path=END_POINT, produces=MediaType.APPLICATION_JSON_VALUE)
        public ResponseEntity<String> handlePutPoll() {
            return ResponseEntity.ok("{\"hi\":1}");
        }
    }

    @BeforeAll
    public void postTestBaseWithWebTestClient(
        WebApplicationContext webApplicationContext,
        RestDocumentationContextProvider restDocumentation)
    {
        assertThat(webApplicationContext).isNotNull();
        assertThat(restDocumentation).isNotNull();
        mockClient = WebTestClient
            .bindToApplicationContext(webApplicationContext)
            .configureClient()
            .filter(WebTestClientRestDocumentation.documentationConfiguration(restDocumentation))
            .build();
    }

    @Test
    public void testMain() {
        mockClient
            .post()
            .uri(END_POINT)
            //.syncBody("xxxx")
            //.body(BodyInserters.fromObject("xxxx"))
            .body(Mono.just("xxxx"), String.class)
            .exchange()
            .expectBody()
            .jsonPath("$").exists()
            .consumeWith(document("xx"));
    }
}

[wilkinsona]

Thanks for the report. Given where the failure is occurring, this looks like it's either a bug in how REST Docs is attempting to retrieve the request body or in how WebFlux is making the body available. I'll move the issue to REST Docs as that looks like where the initial investigation should happen.

Edit: Oops, the issue's already in the REST Docs repository.

[wilkinsona]

What version of REST Docs and Spring Framework are you using?

[joaoe]

Spring rest docs is on version 2.0.2.RELEASE
Spring is on version 5.0.7.RELEASE

[joaoe]

I finally pinpointed the problem: the class WiretapConnector.WiretapClientHttpRequest caches the request body, which is then relayed to the rest docs code.
If the request body is not injected into the @RequestMapping, then the original publisher is never written and the MonoProcessor never reaches the terminated state.

This fixes the test case

@PostMapping(path=END_POINT, produces=MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<String> handlePutPoll(@RequestBody String stuff) {
  // ...
}

[wilkinsona]

Thanks for tracking it down. Given that the reactive approach is only to do something when it's needed, I think WebFlux's behaviour makes sense here. It's also something that is out of REST Docs' control.

[joaoe]

Would it make sense at least to improve the error message ? Or do some check earlier ? Because someone else might get this cryptic error again.

Something like

The request body has not been completly read. Did you inject the @RequestBody into your @RequestMapping?

[wilkinsona]

REST Docs is just dealing with an ExchangeResult upon which it calls getResponseBodyContent(). The problem being caused by the request body not being consumed is several steps removed from that. I don't see how REST Docs can provide a more accurate error message as it doesn't have access to the information that would be needed to do so.

An improvement in WebFlux may be possible, although I don't think it could be tied to @RequestBody and @RequestMapping as there's no guarantee that they're being used. If you'd like to pursue this and get some input from the WebFlux experts, please open a Spring Framework JIRA referencing this issue.

[joaoe]

Ok. Thanks for the input. Cheers.

PS: One of the very last classes in the stack is org.springframework.restdocs.webtestclient.WebTestClientRequestConverter so I asked about the error message.