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

Refine search

@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

Parsing JSON documents to java classes using gson
getResourceAsStream (ClassLoader)
getOriginalFilename (MultipartFile)
Return the original filename in the client's filesystem.This may contain path information depending
putExtra (Intent)
InputStreamReader (java.io)
A class for turning a byte stream into a character stream. Data read from the source input stream is
SQLException (java.sql)
An exception that indicates a failed JDBC operation. It provides the following information about pro
List (java.util)
An ordered collection (also known as a sequence). The user of this interface has precise control ove
Vector (java.util)
Vector is an implementation of List, backed by an array and synchronized. All optional operations in
Cipher (javax.crypto)
This class provides access to implementations of cryptographic ciphers for encryption and decryption
JOptionPane (javax.swing)
21 Best Atom Packages for 2021

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