private void testResponseCompression(boolean enabled) throws Exception { byte[] expected = TestUtils.randomAlphaString(1000).getBytes(); ByteArrayOutputStream baos = new ByteArrayOutputStream(); GZIPOutputStream in = new GZIPOutputStream(baos); in.write(expected); in.close(); byte[] compressed = baos.toByteArray(); server.close(); server = vertx.createHttpServer(serverOptions); server.requestHandler(req -> { assertEquals(enabled ? "deflate, gzip" : null, req.getHeader(HttpHeaderNames.ACCEPT_ENCODING)); req.response().putHeader(HttpHeaderNames.CONTENT_ENCODING.toLowerCase(), "gzip").end(Buffer.buffer(compressed)); }); startServer(); client.close(); client = vertx.createHttpClient(clientOptions.setTryUseCompression(enabled)); client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> { String encoding = resp.getHeader(HttpHeaderNames.CONTENT_ENCODING); assertEquals(enabled ? null : "gzip", encoding); resp.bodyHandler(buff -> { assertEquals(Buffer.buffer(enabled ? expected : compressed), buff); testComplete(); }); })).end(); await(); }
@Test public void testResponseHeadersWithCharSequence() { HashMap<CharSequence, String> headers = new HashMap<>(); headers.put(HttpHeaders.TEXT_HTML, "text/html"); headers.put(HttpHeaders.USER_AGENT, "User-Agent"); headers.put(HttpHeaders.APPLICATION_X_WWW_FORM_URLENCODED, "application/x-www-form-urlencoded"); server.requestHandler(req -> { headers.forEach((k, v) -> req.response().headers().add(k, v)); 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()); headers.forEach((k,v) -> assertEquals(v, resp.headers().get(k))); headers.forEach((k,v) -> assertEquals(v, resp.getHeader(k))); testComplete(); })).end(); })); await(); }
@Override public String getContentType() { return clientResponse.getHeader(HttpHeaders.CONTENT_TYPE); }
@Override public String getHeader(String name) { return clientResponse.getHeader(name); }
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(); }
@Test public void testUnknownContentLengthIsSetToZeroWithHTTP_1_0() throws Exception { server.requestHandler(req -> { req.response().write("Some-String").end(); }); startServer(); client.close(); client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_0)); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertNull(resp.getHeader("Content-Length")); testComplete(); })); await(); }
req.handler(resp -> { process.write(resp.statusCode() + " " + resp.statusMessage() + "\n"); String contentType = resp.getHeader("Content-Type"); String contentLength = resp.getHeader("Content-Length"); process.write("Length: " + (contentLength != null ? contentLength : "unspecified")); if (contentType != null) {
@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 testChunkedServerResponse() { server.requestHandler(req -> { HttpServerResponse resp = req.response(); resp.setChunked(true); assertTrue(resp.isChunked()); resp.write("the-chunk"); vertx.setTimer(1, id -> { resp.end(); }); }).listen(onSuccess(server -> { client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(res -> { assertEquals("chunked", res.getHeader("transfer-encoding")); res.bodyHandler(body -> { assertEquals("the-chunk", body.toString()); testComplete(); }); })); })); 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(); }
@Test public void testHttp10KeepAliveConnectionNotClosed() throws Exception { client.close(); server.requestHandler(req -> { assertEquals(HttpVersion.HTTP_1_0, req.version()); assertEquals(req.getHeader("Connection"), "keep-alive"); req.response().end(); assertFalse(req.response().closed()); }); server.listen(onSuccess(s -> { client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_0).setKeepAlive(true)); HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.endHandler(v -> { assertEquals(resp.getHeader("Connection"), "keep-alive"); assertEquals(resp.getHeader("Content-Length"), "0"); testComplete(); }); })); req.end(); })); await(); }
@Test public void testFoo() throws Exception { waitFor(2); server.requestHandler(req -> { HttpServerResponse resp = req.response(); resp.write("Hello"); resp.end("World"); assertNull(resp.headers().get("content-length")); complete(); }); startServer(); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertNull(resp.getHeader("content-length")); resp.bodyHandler(body -> { assertEquals("HelloWorld", body.toString()); complete(); }); })); await(); }
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));
@Test public void testHttp10RequestNonKeepAliveConnectionClosed() throws Exception { client.close(); server.requestHandler(req -> { assertEquals(HttpVersion.HTTP_1_0, req.version()); assertNull(req.getHeader("Connection")); req.response().end(); assertTrue(req.response().closed()); }); server.listen(onSuccess(s -> { client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_0).setKeepAlive(false)); HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.endHandler(v -> { assertNull(resp.getHeader("Connection")); testComplete(); }); })); req.end(); })); await(); }
@Test public void testHttp11NonPersistentConnectionClosed() throws Exception { client.close(); server.requestHandler(req -> { assertEquals(HttpVersion.HTTP_1_1, req.version()); assertEquals(req.getHeader("Connection"), "close"); req.response().end(); assertTrue(req.response().closed()); }); server.listen(onSuccess(s -> { client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_1).setKeepAlive(false)); HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.endHandler(v -> { assertEquals(resp.getHeader("Connection"), "close"); testComplete(); }); })); req.end(); })); await(); }
public ReadStreamPart(Context context, HttpClientResponse httpClientResponse) { this(context, (ReadStream<Buffer>) httpClientResponse); setSubmittedFileName( HttpUtils.parseFileNameFromHeaderValue(httpClientResponse.getHeader(HttpHeaders.CONTENT_DISPOSITION))); String contentType = httpClientResponse.getHeader(HttpHeaders.CONTENT_TYPE); if (StringUtils.isNotEmpty(contentType)) { this.contentType(contentType); } }
@Test public void testRerouteClearHeader() throws Exception { router.get("/users/:name").handler(ctx -> ctx.response().end("/users/:name")); router.get("/me").handler(ctx -> { ctx.response().putHeader("X-woop", "durp"); ctx.reroute("/users/paulo"); }); testRequest(HttpMethod.GET, "/me", null, res -> assertNull(res.getHeader("X-woop")), 200, "OK", "/users/:name"); }
private void testGreeting(String uri) { client.getNow(uri, onSuccess(resp -> { assertEquals(200, resp.statusCode()); assertEquals("text/plain; charset=UTF-8", resp.getHeader("content-type")); resp.bodyHandler(buff -> { assertEquals("Welcome to SockJS!\n", buff.toString()); complete(); }); })); }
@Test public void testRerouteClearHeader2() throws Exception { router.get("/users/:name").handler(ctx -> { ctx.response().putHeader("X-woop", "durp2"); ctx.response().end("/users/:name"); }); router.get("/me").handler(ctx -> { ctx.response().putHeader("X-woop", "durp"); ctx.reroute("/users/paulo"); }); testRequest(HttpMethod.GET, "/me", null, res -> assertEquals("durp2", res.getHeader("X-woop")), 200, "OK", "/users/:name"); }