How to use

aggregate

method

in

com.hotels.styx.api.LiveHttpRequest

@Test(dataProvider = "emptyBodyRequests")
public void encodesToStreamingHttpRequestWithEmptyBody(LiveHttpRequest streamingRequest) throws Exception {
  HttpRequest full = Mono.from(streamingRequest.aggregate(0x1000)).block();
  assertThat(full.body(), is(new byte[0]));
}

  @Override
  protected LiveHttpResponse doHandle(LiveHttpRequest request) {
    HttpRequest fullRequest = Mono.from(request.aggregate(0x100000)).block();

    String responseBody = format("Response From %s - %s, received content digest: %s",
        origin.hostAndPortString(),
        randomUUID(),
        fullRequest.bodyAs(UTF_8).hashCode());

    return HttpResponse.response(OK)
        .header(CONTENT_TYPE, HTML_UTF_8.toString())
        .header(CONTENT_LENGTH, responseBody.getBytes(UTF_8).length)
        .body(responseBody, UTF_8)
        .build()
        .stream();
  }
}

private static Eventual<PluginEnabledState> requestedNewState(LiveHttpRequest request) {
  return request.aggregate(MAX_CONTENT_SIZE)
      .map(fullRequest -> fullRequest.bodyAs(UTF_8))
      .map(PluginToggleHandler::parseToBoolean)
      .map(PluginEnabledState::fromBoolean);
}

private static HttpHandler newHandler(String originId, RequestHandler wireMockHandler) {
  return (httpRequest, ctx) ->
      httpRequest.aggregate(MAX_CONTENT_LENGTH)
          .map(fullRequest -> {
            LOGGER.info("{} received: {}\n{}", new Object[]{originId, fullRequest.url(), fullRequest.body()});
            return fullRequest;
          })
          .flatMap(fullRequest -> {
            Request wmRequest = new WiremockStyxRequestAdapter(fullRequest);
            com.github.tomakehurst.wiremock.http.Response wmResponse = wireMockHandler.handle(wmRequest);
            return Eventual.of(toStyxResponse(wmResponse).stream());
          });
}

  private static HttpHandler newHandler(RequestHandler wireMockHandler) {
    return (httpRequest, ctx) ->
        httpRequest.aggregate(MAX_CONTENT_LENGTH)
            .map(fullRequest -> {
              LOGGER.info("Received: {}\n{}", new Object[]{fullRequest.url(), fullRequest.body()});
              return fullRequest;
            })
            .flatMap(fullRequest -> {
              Request wmRequest = new WiremockStyxRequestAdapter(fullRequest);
              com.github.tomakehurst.wiremock.http.Response wmResponse = wireMockHandler.handle(wmRequest);
              return Eventual.of(toStyxResponse(wmResponse).stream());
            });
  }
}

@Test
public void toFullRequestReleasesOriginalReferenceCountedBuffers() throws ExecutionException, InterruptedException {
  Buffer content = new Buffer("original", UTF_8);
  LiveHttpRequest original = LiveHttpRequest.get("/foo")
      .body(new ByteStream(Flux.just(content)))
      .build();
  HttpRequest fullRequest = Mono.from(original.aggregate(100)).block();
  assertThat(content.delegate().refCnt(), is(0));
  assertThat(fullRequest.bodyAs(UTF_8), is("original"));
}

@Test
public void decodesToFullHttpRequest() throws Exception {
  LiveHttpRequest streamingRequest = post("/foo/bar", body("foo", "bar"))
      .version(HTTP_1_0)
      .header("HeaderName", "HeaderValue")
      .cookies(requestCookie("CookieName", "CookieValue"))
      .build();
  HttpRequest full = Mono.from(streamingRequest.aggregate(0x1000)).block();
  assertThat(full.method(), is(POST));
  assertThat(full.url(), is(url("/foo/bar").build()));
  assertThat(full.version(), is(HTTP_1_0));
  assertThat(full.headers(), containsInAnyOrder(
      header("HeaderName", "HeaderValue"),
      header("Cookie", "CookieName=CookieValue")));
  assertThat(full.cookies(), contains(requestCookie("CookieName", "CookieValue")));
  assertThat(full.body(), is(bytes("foobar")));
}

  @Override
  public Eventual<LiveHttpResponse> intercept(LiveHttpRequest request, Chain chain) {
    return request.aggregate(config.maxContentLength())
            .flatMap(fullHttpRequest -> Eventual.from(asyncOperation(config.delayMillis())))
            .map(outcome -> request.newBuilder().header("X-Outcome", outcome.result()))
            .flatMap(x -> chain.proceed(request));
  }
}

@Test
public void convertsToStreamingHttpRequest() throws Exception {
  HttpRequest fullRequest = new HttpRequest.Builder(POST, "/foo/bar").body("foobar", UTF_8)
      .version(HTTP_1_1)
      .header("HeaderName", "HeaderValue")
      .cookies(requestCookie("CookieName", "CookieValue"))
      .build();
  LiveHttpRequest streaming = fullRequest.stream();
  assertThat(streaming.method(), is(HttpMethod.POST));
  assertThat(streaming.url(), is(url("/foo/bar").build()));
  assertThat(streaming.version(), is(HTTP_1_1));
  assertThat(streaming.headers(), containsInAnyOrder(
      header("Content-Length", "6"),
      header("HeaderName", "HeaderValue"),
      header("Cookie", "CookieName=CookieValue")));
  assertThat(streaming.cookies(), contains(requestCookie("CookieName", "CookieValue")));
  StepVerifier.create(streaming.aggregate(0x10000).map(it -> it.bodyAs(UTF_8)))
      .expectNext("foobar")
      .verifyComplete();
}