io.vertx.core.http.HttpClientResponse.headers java code examples

Refine search

Common ways to obtain HttpClientResponse

private void myMethod () {
 HttpClientResponse h =HttpClientResponse httpClientResponse;httpClientResponse.resume()
HttpClientResponse httpClientResponse;httpClientResponse.pause()
Smart code suggestions by Tabnine
}

@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 testHeadHasNoContentLengthByDefault() {
 server.requestHandler(req -> {
  assertEquals(HttpMethod.HEAD, req.method());
  // By default HEAD does not have a content-length header
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.HEAD, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   assertNull(resp.headers().get(HttpHeaders.CONTENT_LENGTH));
   resp.endHandler(v -> testComplete());
  })).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();
}

@Test
public void testHttpServerResponseHeadersDontContainCROrLF() throws Exception {
 server.requestHandler(req -> {
 startServer();
 client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
  resp.headers().forEach(header -> {
   String name = header.getKey();
   switch (name.toLowerCase()) {

@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();
}

@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 testHeaders() throws Exception {
 AtomicInteger reqCount = new AtomicInteger();
   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);

private void sendFile(String fileName, String contentExpected, boolean useHandler, Function<Handler<AsyncResult<HttpClientResponse>>, HttpClientRequest> requestFact) throws Exception {
 waitFor(2);
 File fileToSend = setupFile(fileName, contentExpected);
 server.requestHandler(req -> {
  if (useHandler) {
   Handler<AsyncResult<Void>> completionHandler = onSuccess(v -> complete());
   req.response().sendFile(fileToSend.getAbsolutePath(), completionHandler);
  } else {
   req.response().sendFile(fileToSend.getAbsolutePath());
   complete();
  }
 });
 startServer();
 requestFact.apply(onSuccess(resp -> {
  assertEquals(200, resp.statusCode());
  assertEquals("text/html", resp.headers().get("Content-Type"));
  resp.exceptionHandler(this::fail);
  resp.bodyHandler(buff -> {
   assertEquals(contentExpected, buff.toString());
   assertEquals(fileToSend.length(), Long.parseLong(resp.headers().get("content-length")));
   complete();
  });
 })).end();
 await();
}

@Test
public void testSendFileOverrideHeaders() throws Exception {
 String content = TestUtils.randomUnicodeString(10000);
 File file = setupFile("test-send-file.html", content);
 server.requestHandler(req -> {
  req.response().putHeader("Content-Type", "wibble");
  req.response().sendFile(file.getAbsolutePath());
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   assertEquals(file.length(), Long.parseLong(resp.headers().get("content-length")));
   assertEquals("wibble", resp.headers().get("content-type"));
   resp.bodyHandler(buff -> {
    assertEquals(content, buff.toString());
    file.delete();
    testComplete();
   });
  })).end();
 }));
 await();
}

@Test
public void testContainsValueStringIgnoreCase() {
 server.requestHandler(req -> {
  assertTrue(req.headers().contains("Foo", "foo", true));
  assertTrue(req.headers().contains("Foo", "fOo", true));
  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", true));
   assertTrue(resp.headers().contains("Quux", "quUx", true));
   testComplete();
  }));
  req.putHeader("foo", "foo");
  req.end();
 }));
 await();
}

@Test
public void testNoLinkPreload() throws Exception {
 stat.setWebRoot("webroot/somedir3");
 testRequest(HttpMethod.GET, "/testLinkPreload.html", null, res -> {
  List<String> linkHeaders = res.headers().getAll("Link");
  assertTrue(linkHeaders.isEmpty());
 }, 200, "OK", null);
}

String cnt = req.headers().get("count");
req.response().headers().set("count", cnt);
req.response().end();
 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();

@Test
public void testHeadButCanSetContentLength() {
 server.requestHandler(req -> {
  assertEquals(HttpMethod.HEAD, req.method());
  // By default HEAD does not have a content-length header but it can contain a content-length header
  // if explicitly set
  req.response().putHeader(HttpHeaders.CONTENT_LENGTH, "41").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(HttpHeaders.CONTENT_LENGTH));
   resp.endHandler(v -> testComplete());
  })).end();
 }));
 await();
}

@Test
public void testContainsValueCharSequenceIgnoreCase() {
 CharSequence Foo = HttpHeaders.createOptimized("Foo");
 CharSequence foo = HttpHeaders.createOptimized("foo");
 CharSequence fOo = HttpHeaders.createOptimized("fOo");
 CharSequence Quux = HttpHeaders.createOptimized("Quux");
 CharSequence quux = HttpHeaders.createOptimized("quux");
 CharSequence quUx = HttpHeaders.createOptimized("quUx");
 server.requestHandler(req -> {
  assertTrue(req.headers().contains(Foo, foo, true));
  assertTrue(req.headers().contains(Foo, fOo, true));
  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, true));
   assertTrue(resp.headers().contains(Quux, quUx, true));
   testComplete();
  }));
  req.putHeader(foo, foo);
  req.end();
 }));
 await();
}

@Test
public void testLinkPreload() throws Exception {
 List<Http2PushMapping> mappings = new ArrayList<>();
 mappings.add(new Http2PushMapping("style.css", "style", false));
 mappings.add(new Http2PushMapping("coin.png", "image", false));
 stat.setHttp2PushMapping(mappings)
   .setWebRoot("webroot/somedir3");
 testRequest(HttpMethod.GET, "/testLinkPreload.html", null, res -> {
  List<String> linkHeaders = res.headers().getAll("Link");
  assertTrue(linkHeaders.contains("<style.css>; rel=preload; as=style"));
  assertTrue(linkHeaders.contains("<coin.png>; rel=preload; as=image"));
 }, 200, "OK", null);
}

private void checkHeaders(HttpClientResponse resp, String accessControlAllowOrigin,
             String accessControlAllowMethods, String accessControlAllowHeaders,
             String accessControlExposeHeaders, String allowCredentials,
             String maxAgeSeconds) {
 assertEquals(accessControlAllowOrigin, resp.headers().get("access-control-allow-origin"));
 assertEquals(accessControlAllowMethods, resp.headers().get("access-control-allow-methods"));
 assertEquals(accessControlAllowHeaders, resp.headers().get("access-control-allow-headers"));
 assertEquals(accessControlExposeHeaders, resp.headers().get("access-control-expose-headers"));
 assertEquals(allowCredentials, resp.headers().get("access-control-allow-credentials"));
 assertEquals(maxAgeSeconds, resp.headers().get("access-control-max-age"));
}

@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 testContainsValueCharSequence() {
 CharSequence Foo = HttpHeaders.createOptimized("Foo");
 CharSequence foo = HttpHeaders.createOptimized("foo");
 CharSequence fOo = HttpHeaders.createOptimized("fOo");
 CharSequence Quux = HttpHeaders.createOptimized("Quux");
 CharSequence quux = HttpHeaders.createOptimized("quux");
 CharSequence quUx = HttpHeaders.createOptimized("quUx");
 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 testGetCookie() throws Exception {
 router.route().handler(CookieHandler.create());
 router.route().handler(CSRFHandler.create("Abracadabra"));
 router.get().handler(rc -> rc.response().end());
 testRequest(HttpMethod.GET, "/", null, resp -> {
  List<String> cookies = resp.headers().getAll("set-cookie");
  assertEquals(1, cookies.size());
  assertEquals(CSRFHandler.DEFAULT_COOKIE_NAME, cookies.get(0).substring(0, cookies.get(0).indexOf('=')));
 }, 200, "OK", null);
}

private void checkTextResponse(Buffer buff, HttpClientResponse resp, int statusCode, String statusMessage) {
 assertEquals("text/plain", resp.headers().get(HttpHeaders.CONTENT_TYPE));
 String page = buff.toString();
 assertEquals("Error " + statusCode + ": " + statusMessage, page);
}

Popular methods of HttpClientResponse

statusCode
bodyHandler
Convenience method for receiving the entire request body in one piece. This saves you having to manu
statusMessage
exceptionHandler
endHandler
getHeader
Return the first header value with the specified name
handler
pause
resume
request
cookies
netSocket
Get a net socket for the underlying connection of this request. USE THIS WITH CAUTION! Writing to th

Popular in Java

Running tasks concurrently on multiple threads
onRequestPermissionsResult (Fragment)
setRequestProperty (URLConnection)
setContentView (Activity)
HttpServer (com.sun.net.httpserver)
This class implements a simple HTTP server. A HttpServer is bound to an IP address and port number a
LinkedList (java.util)
Doubly-linked list implementation of the List and Dequeinterfaces. Implements all optional list oper
Callable (java.util.concurrent)
A task that returns a result and may throw an exception. Implementors define a single method with no
JFileChooser (javax.swing)
JLabel (javax.swing)
Response (javax.ws.rs.core)
Defines the contract between a returned instance and the runtime when an application needs to provid

How to use headersmethodin io.vertx.core.http.HttpClientResponse

Best Java code snippets using io.vertx.core.http.HttpClientResponse.headers (Showing top 20 results out of 315)

Refine search

How to use
headers
method
in
io.vertx.core.http.HttpClientResponse