private void testHttpProxyRequest2(Function<Handler<AsyncResult<HttpClientResponse>>, HttpClientRequest> reqFact) throws Exception { server.requestHandler(req -> { req.response().end(); }); server.listen(onSuccess(s -> { HttpClientRequest req = reqFact.apply(onSuccess(resp -> { assertEquals(200, resp.statusCode()); assertNotNull("request did not go through proxy", proxy.getLastUri()); assertEquals("Host header doesn't contain target host", "localhost:8080", proxy.getLastRequestHeaders().get("Host")); testComplete(); })); req.exceptionHandler(this::fail); req.end(); })); await(); }
@Test public void testResponseEndHandlers2() { waitFor(2); AtomicInteger cnt = new AtomicInteger(); String content = "blah"; server.requestHandler(req -> { req.response().headersEndHandler(v -> { // Insert another header req.response().putHeader("extraheader", "wibble"); assertEquals(0, cnt.getAndIncrement()); }); req.response().bodyEndHandler(v -> { assertEquals(content.length(), req.response().bytesWritten()); assertEquals(1, cnt.getAndIncrement()); complete(); }); req.response().end(content); }).listen(onSuccess(server -> { client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(res -> { assertEquals(200, res.statusCode()); assertEquals("wibble", res.headers().get("extraheader")); res.bodyHandler(buff -> { assertEquals(Buffer.buffer(content), buff); complete(); }); })).end(); })); await(); }
assertEquals(2, req.headers().getAll("juu_request").size()); assertEquals("juu_request_value_1", req.headers().getAll("juu_request").get(0)); assertEquals("juu_request_value_2", req.headers().getAll("juu_request").get(1)); }); startServer(); client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> { Context ctx = vertx.getOrCreateContext(); assertOnIOContext(ctx); assertEquals(1, resp.request().streamId()); assertEquals(1, reqCount.get()); assertEquals(HttpVersion.HTTP_2, resp.version()); assertEquals(200, resp.statusCode()); assertEquals("OK", resp.statusMessage()); assertEquals("text/plain", resp.getHeader("content-type")); assertEquals("200", resp.getHeader(":status")); assertEquals("foo_value", resp.getHeader("foo_response")); assertEquals("bar_value", resp.getHeader("bar_response")); assertEquals(2, resp.headers().getAll("juu_response").size()); assertEquals("juu_value_1", resp.headers().getAll("juu_response").get(0)); assertEquals("juu_value_2", resp.headers().getAll("juu_response").get(1)); resp.endHandler(v -> { assertOnIOContext(ctx); testComplete(); }); })).putHeader("Foo_request", "foo_request_value") .putHeader("bar_request", "bar_request_value")
@Test public void testHttpClientResponsePauseIsIgnoredAtRequestEnd() throws Exception { testHttpClientResponsePause(resp -> { resp.endHandler(v -> { // Pausing the request in end handler should be a no-op resp.pause(); }); }); }
protected MultiMap checkEmptyHttpResponse(HttpMethod method, int sc, MultiMap reqHeaders) throws Exception { server.requestHandler(req -> { HttpServerResponse resp = req.response(); resp.setStatusCode(sc); resp.headers().addAll(reqHeaders); resp.end(); }); startServer(); try { CompletableFuture<MultiMap> result = new CompletableFuture<>(); client.request(method, DEFAULT_HTTP_PORT, DEFAULT_HTTPS_HOST, "/", onSuccess(resp -> { Buffer body = Buffer.buffer(); resp.exceptionHandler(result::completeExceptionally); resp.handler(body::appendBuffer); resp.endHandler(v -> { if (body.length() > 0) { result.completeExceptionally(new Exception()); } else { result.complete(resp.headers()); } }); })).setFollowRedirects(false) .exceptionHandler(result::completeExceptionally) .end(); return result.get(20, TimeUnit.SECONDS); } finally { client.close(); } }
@Test public void testClientExceptionHandlerCalledWhenExceptionOnBodyHandler() throws Exception { server.requestHandler(request -> { request.response().end("foo"); }).listen(DEFAULT_HTTP_PORT, onSuccess(s -> { // Exception handler should be called for any exceptions in the data handler client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.bodyHandler(data -> { throw new RuntimeException("should be caught"); }); resp.exceptionHandler(t -> testComplete()); })).exceptionHandler(error -> fail()).end(); })); await(); }
@Test public void testContainsValueString() { server.requestHandler(req -> { assertTrue(req.headers().contains("Foo", "foo", false)); assertFalse(req.headers().contains("Foo", "fOo", false)); req.response().putHeader("quux", "quux"); req.response().end(); }); server.listen(onSuccess(server -> { HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertTrue(resp.headers().contains("Quux", "quux", false)); assertFalse(resp.headers().contains("Quux", "quUx", false)); testComplete(); })); req.putHeader("foo", "foo"); req.end(); })); await(); }
@Test public void testHeadCanSetContentLength() { server.requestHandler(req -> { assertEquals(HttpMethod.HEAD, req.method()); // Head never contains a body but it can contain a Content-Length header // Since headers from HEAD must correspond EXACTLY with corresponding headers for GET req.response().headers().set("Content-Length", String.valueOf(41)); req.response().end(); }); server.listen(onSuccess(s -> { client.request(HttpMethod.HEAD, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertEquals("41", resp.headers().get("Content-Length")); resp.endHandler(v -> testComplete()); })).end(); })); await(); }
@Test public void testHttp11PersistentConnectionNotClosed() throws Exception { client.close(); server.requestHandler(req -> { assertEquals(HttpVersion.HTTP_1_1, req.version()); assertNull(req.getHeader("Connection")); req.response().end(); assertFalse(req.response().closed()); }); server.listen(onSuccess(s -> { client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_1).setKeepAlive(true)); HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.endHandler(v -> { assertNull(resp.getHeader("Connection")); assertEquals(resp.getHeader("Content-Length"), "0"); testComplete(); }); })); req.end(); })); await(); }
private void testResponseHeaders(boolean individually) { MultiMap headers = getHeaders(10); server.requestHandler(req -> { if (individually) { for (Map.Entry<String, String> header : headers) { req.response().headers().add(header.getKey(), header.getValue()); } } else { req.response().headers().setAll(headers); } req.response().end(); }); server.listen(onSuccess(server -> { client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertTrue(headers.size() < resp.headers().size()); for (Map.Entry<String, String> entry : headers) { assertEquals(entry.getValue(), resp.headers().get(entry.getKey())); assertEquals(entry.getValue(), resp.getHeader(entry.getKey())); } testComplete(); })).end(); })); await(); }
int numGets = 100; int maxPoolSize = 10; client.close(); client = vertx.createHttpClient(new HttpClientOptions().setKeepAlive(keepAlive).setPipelining(pipelining).setMaxPoolSize(maxPoolSize)); server.requestHandler(req -> { String cnt = req.headers().get("count"); req.response().headers().set("count", cnt); req.response().end(); }); server.listen(onSuccess(s -> { HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, path, onSuccess(resp -> { assertEquals(200, resp.statusCode()); assertEquals(theCount, Integer.parseInt(resp.headers().get("count"))); if (cnt.incrementAndGet() == numGets) { testComplete(); req.exceptionHandler(t -> { fail("Should not throw exception: " + t.getMessage()); }); req.headers().set("count", String.valueOf(i)); req.end();
private void testStatusCode(int code, String statusMessage) { server.requestHandler(req -> { if (code != -1) { req.response().setStatusCode(code); } if (statusMessage != null) { req.response().setStatusMessage(statusMessage); } req.response().end(); }); server.listen(onSuccess(s -> { client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { int theCode; if (code == -1) { // Default code - 200 assertEquals(200, resp.statusCode()); theCode = 200; } else { theCode = code; } if (statusMessage != null && resp.version() != HttpVersion.HTTP_2) { assertEquals(statusMessage, resp.statusMessage()); } else { assertEquals(HttpResponseStatus.valueOf(theCode).reasonPhrase(), resp.statusMessage()); } testComplete(); })).end(); })); await(); }
@Test public void testPutHeadersOnRequest() { server.requestHandler(req -> { assertEquals("bar", req.headers().get("foo")); assertEquals("bar", req.getHeader("foo")); req.response().end(); }); server.listen(onSuccess(server -> { client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertEquals(200, resp.statusCode()); testComplete(); })).putHeader("foo", "bar").end(); })); await(); }
@Test public void testClientMaxHeaderSizeOption() { String longHeader = TestUtils.randomAlphaString(9000); // min 9023 = 9000 for longHeader and 23 for "Content-Length: 0 t: " vertx.createHttpServer(new HttpServerOptions().setHost(DEFAULT_HTTP_HOST).setPort(DEFAULT_HTTP_PORT)).requestHandler(req -> { // Add longHeader req.response().putHeader("t", longHeader).end(); }).listen(onSuccess(res -> { HttpClientRequest req = vertx.createHttpClient(new HttpClientOptions().setMaxHeaderSize(10000)) .request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> { assertEquals(200, resp.statusCode()); assertEquals(resp.getHeader("t"), longHeader); testComplete(); })); req.end(); })); await(); }
@Test public void testServerResponseWriteBufferFromOtherThread() throws Exception { server.requestHandler(req -> { runAsync(() -> { req.response().write("hello ").end("world"); }); }).listen(onSuccess(v -> { client.get(8080, "localhost", "/somepath", onSuccess(resp -> { assertEquals(200, resp.statusCode()); resp.bodyHandler(buff -> { assertEquals(Buffer.buffer("hello world"), buff); testComplete(); }); })).exceptionHandler(this::fail).end(); })); await(); }
@Test public void testResponseBodyWriteFixedString() { String body = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."; Buffer bodyBuff = Buffer.buffer(body); server.requestHandler(req -> { req.response().setChunked(true); req.response().write(body); req.response().end(); }); server.listen(onSuccess(s -> { client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.bodyHandler(buff -> { assertEquals(bodyBuff, buff); testComplete(); }); })).end(); })); await(); }
@Test public void testPutHeaderReplacesPreviousHeaders() throws Exception { server.requestHandler(req -> req.response() .putHeader("Location", "http://example1.org") .putHeader("location", "http://example2.org") .end()); server.listen(onSuccess(server -> { client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertEquals(singletonList("http://example2.org"), resp.headers().getAll("LocatioN")); testComplete(); })).end(); })); await(); }
@Test public void testSkipEncoding() throws Exception { serverWithMaxCompressionLevel.requestHandler(req -> { assertNotNull(req.headers().get("Accept-Encoding")); req.response() .putHeader(HttpHeaders.CONTENT_ENCODING, HttpHeaders.IDENTITY) .end(Buffer.buffer(COMPRESS_TEST_STRING).toString(CharsetUtil.UTF_8)); }); startServer(serverWithMaxCompressionLevel); clientraw.get(DEFAULT_HTTP_PORT + 1, DEFAULT_HTTP_HOST, "some-uri", onSuccess(resp -> { resp.bodyHandler(responseBuffer -> { String responseBody = responseBuffer.toString(CharsetUtil.UTF_8); assertEquals(COMPRESS_TEST_STRING, responseBody); testComplete(); }); })).putHeader(HttpHeaders.ACCEPT_ENCODING, HttpHeaders.DEFLATE_GZIP).end(); await(); }
@Test public void test100ContinueHandledAutomatically() throws Exception { Buffer toSend = TestUtils.randomBuffer(1000); server.requestHandler(req -> { req.bodyHandler(data -> { assertEquals(toSend, data); req.response().end(); }); }); server.listen(onSuccess(s -> { HttpClientRequest req = client.request(HttpMethod.PUT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.endHandler(v -> testComplete()); })); req.headers().set("Expect", "100-continue"); req.setChunked(true); req.continueHandler(v -> { req.write(toSend); req.end(); }); req.sendHead(); })); await(); }
@Test public void testFollowRedirectLimit() throws Exception { AtomicInteger redirects = new AtomicInteger(); server.requestHandler(req -> { int val = redirects.incrementAndGet(); if (val > 16) { fail(); } else { String scheme = createBaseServerOptions().isSsl() ? "https" : "http"; req.response().setStatusCode(301).putHeader(HttpHeaders.LOCATION, scheme + "://localhost:8080/otherpath").end(); } }); startServer(); client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> { assertEquals(16, redirects.get()); assertEquals(301, resp.statusCode()); assertEquals("/otherpath", resp.request().path()); testComplete(); })).setFollowRedirects(true).end(); await(); }