private String xHcomPluginsHeader(LiveHttpRequest message) { return message.headers().get(X_HCOM_PLUGINS_HEADER).orElse("") .concat(" test-plugin-a") .trim(); }
private static CharSequence viaHeader(LiveHttpRequest httpMessage) { CharSequence styxViaEntry = styxViaEntry(httpMessage.version()); return httpMessage.headers().get(VIA) .map(viaHeader -> !isNullOrEmpty(viaHeader) ? viaHeader + ", " + styxViaEntry : styxViaEntry) .orElse(styxViaEntry); }
@Override public Eventual<LiveHttpResponse> handle(LiveHttpRequest request, HttpInterceptor.Context context) { HttpResponse.Builder responseBuilder = standardResponse.newBuilder() .headers(request.headers()) .header(STUB_ORIGIN_INFO, origin.applicationInfo()); return Eventual.of(Optional.ofNullable(responseBuilder) .map(it -> request.queryParam("status") .map(status -> it.status(httpResponseStatus(status)) .body("Returning requested status (" + status + ")", UTF_8)) .orElse(it)) .map(it -> request.queryParam("length") .map(length -> it.body(generateContent(parseInt(length)), UTF_8)) .orElse(it)) .orElse(responseBuilder) .build() .stream()); }
@Test public void chunkedReturnsTrueWhenChunkedTransferEncodingIsAbsent() { HttpHeaders headers = requestBuilder().build().headers(); assertThat(chunked(headers), is(false)); }
@VisibleForTesting static DefaultHttpRequest toNettyRequest(LiveHttpRequest request) { HttpVersion version = request.version(); HttpMethod method = request.method(); String url = request.url().toString(); DefaultHttpRequest nettyRequest = new DefaultHttpRequest(toNettyVersion(version), toNettyMethod(method), url, false); request.headers().forEach((name, value) -> nettyRequest.headers().add(name, value)); return nettyRequest; }
Builder(LiveHttpRequest request) { this.id = request.id(); this.method = request.method(); this.url = request.url(); this.version = request.version(); this.headers = request.headers().newBuilder(); this.body = request.body(); }
@Test public void chunkedReturnsFalseWhenChunkedTransferEncodingIsNotSet() { HttpHeaders headers = requestBuilder() .header(TRANSFER_ENCODING, "foo") .build() .headers(); assertThat(chunked(headers), is(false)); }
/** * Creates a new {@link Builder} from streaming request and a content byte array. * * @param request a streaming HTTP request object * @param body an HTTP body content array */ public Builder(LiveHttpRequest request, byte[] body) { this.id = request.id(); this.method = request.method(); this.url = request.url(); this.version = request.version(); this.headers = request.headers().newBuilder(); this.body = body; }
@Test public void canUseBuilderToSetRequestProperties() { LiveHttpRequest request = patch("https://hotels.com") .version(HTTP_1_0) .id("id") .header("headerName", "a") .cookies(requestCookie("cfoo", "bar")) .build(); assertThat(request.toString(), is("LiveHttpRequest{version=HTTP/1.0, method=PATCH, uri=https://hotels.com, headers=[headerName=a, Cookie=cfoo=bar, Host=hotels.com], id=id}")); assertThat(request.headers("headerName"), is(singletonList("a"))); }
@Test public void keepAliveReturnsTrueWhenHttpConnectionMustBeKeptAlive() { HttpHeaders connectionHeaderAbsent = requestBuilder().build().headers(); HttpHeaders connectionHeaderClose = requestBuilder() .header(CONNECTION, CLOSE) .build() .headers(); HttpHeaders connectionHeaderKeepAlive = requestBuilder() .header(CONNECTION, KEEP_ALIVE) .build() .headers(); assertThat(keepAlive(connectionHeaderAbsent, HTTP_1_0), is(false)); assertThat(keepAlive(connectionHeaderAbsent, HTTP_1_1), is(true)); assertThat(keepAlive(connectionHeaderClose, HTTP_1_0), is(false)); assertThat(keepAlive(connectionHeaderClose, HTTP_1_1), is(false)); assertThat(keepAlive(connectionHeaderKeepAlive, HTTP_1_0), is(true)); assertThat(keepAlive(connectionHeaderKeepAlive, HTTP_1_1), is(true)); } }
@Test public void createsRequestBuilderFromRequest() { LiveHttpRequest originalRequest = get("/home") .cookies(requestCookie("fred", "blogs")) .header("some", "header") .build(); LiveHttpRequest clonedRequest = originalRequest.newBuilder().build(); assertThat(clonedRequest.method(), is(originalRequest.method())); assertThat(clonedRequest.url(), is(originalRequest.url())); assertThat(clonedRequest.headers().toString(), is(originalRequest.headers().toString())); assertThat(clonedRequest.body(), is(originalRequest.body())); }
@Test public void createsARequestWithDefaultValues() { LiveHttpRequest request = get("/index").build(); assertThat(request.version(), is(HTTP_1_1)); assertThat(request.url().toString(), is("/index")); assertThat(request.path(), is("/index")); assertThat(request.id(), is(notNullValue())); assertThat(request.cookies(), is(emptyIterable())); assertThat(request.headers(), is(emptyIterable())); assertThat(request.headers("any"), is(emptyIterable())); assertThat(bytesToString(request.body()), is("")); assertThat(request.cookie("any"), isAbsent()); assertThat(request.header("any"), isAbsent()); assertThat(request.keepAlive(), is(true)); assertThat(request.method(), is(GET)); assertThat(request.queryParam("any"), isAbsent()); assertThat(request.queryParams("any"), is(emptyIterable())); }
@Test public void chunkedReturnsTrueWhenChunkedTransferEncodingIsSet() { HttpHeaders headers = requestBuilder() .header(TRANSFER_ENCODING, CHUNKED) .build() .headers(); assertThat(chunked(headers), is(true)); HttpHeaders headers2 = requestBuilder() .header(TRANSFER_ENCODING, "foo") .addHeader(TRANSFER_ENCODING, CHUNKED) .addHeader(TRANSFER_ENCODING, "bar") .build() .headers(); assertThat(chunked(headers2), is(true)); }
private static Info information(LiveHttpRequest request, Origin origin, boolean longFormatEnabled) { Info info = new Info() .add("method", request.method()) .add("uri", request.url()) .add("origin", origin != null ? origin.hostAndPortString() : "N/A"); if (longFormatEnabled) { info.add("headers", request.headers()); } return info; }
@Test public void canModifyPreviouslyCreatedRequest() { LiveHttpRequest request = get("/foo") .header("remove", "remove") .build(); LiveHttpRequest newRequest = request.newBuilder() .uri("/home") .header("remove", "notanymore") .build(); assertThat(newRequest.url().path(), is("/home")); assertThat(newRequest.headers(), hasItem(header("remove", "notanymore"))); }
@Test public void canRemoveAHeader() { Object hdValue = "b"; LiveHttpRequest request = get("/") .header("a", hdValue) .addHeader("c", hdValue) .build(); LiveHttpRequest shouldRemoveHeader = request.newBuilder() .removeHeader("c") .build(); assertThat(shouldRemoveHeader.headers(), contains(header("a", "b"))); }
/** * Creates a new {@link Builder} from an existing request with a new body content stream. * * @param request a HTTP request object * @param contentStream a body content stream */ public Builder(LiveHttpRequest request, ByteStream contentStream) { this.id = request.id(); this.method = httpMethod(request.method().name()); this.url = request.url(); this.version = httpVersion(request.version().toString()); this.headers = request.headers().newBuilder(); this.body = body; }
@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(); }