congrats Icon
New! Tabnine Pro 14-day free trial
Start a free trial
Tabnine Logo
HttpClientResponse.headers
Code IndexAdd Tabnine to your IDE (free)

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

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

Refine searchRefine arrow

  • MultiMap.get
  • Test.<init>
origin: eclipse-vertx/vert.x

@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();
}
origin: eclipse-vertx/vert.x

@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();
}
origin: eclipse-vertx/vert.x

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();
}
origin: eclipse-vertx/vert.x

@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()) {
origin: eclipse-vertx/vert.x

@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();
}
origin: eclipse-vertx/vert.x

@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();
}
origin: eclipse-vertx/vert.x

@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);
origin: eclipse-vertx/vert.x

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();
}
origin: eclipse-vertx/vert.x

@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();
}
origin: eclipse-vertx/vert.x

@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();
}
origin: vert-x3/vertx-web

@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);
}
origin: eclipse-vertx/vert.x

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();
origin: eclipse-vertx/vert.x

@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();
}
origin: eclipse-vertx/vert.x

@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();
}
origin: vert-x3/vertx-web

@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);
}
origin: vert-x3/vertx-web

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"));
}
origin: eclipse-vertx/vert.x

@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();
}
origin: eclipse-vertx/vert.x

@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();
}
origin: vert-x3/vertx-web

@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);
}
origin: vert-x3/vertx-web

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);
}
io.vertx.core.httpHttpClientResponseheaders

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
  • cookies,
  • netSocket,
  • version,
  • customFrameHandler,
  • getTrailer,
  • streamPriorityHandler,
  • trailers,
  • fetch

Popular in Java

  • Creating JSON documents from java classes using gson
  • setRequestProperty (URLConnection)
  • getContentResolver (Context)
  • setScale (BigDecimal)
  • InputStreamReader (java.io)
    A class for turning a byte stream into a character stream. Data read from the source input stream is
  • MessageDigest (java.security)
    Uses a one-way hash function to turn an arbitrary number of bytes into a fixed-length byte sequence.
  • ArrayList (java.util)
    ArrayList is an implementation of List, backed by an array. All optional operations including adding
  • TimeZone (java.util)
    TimeZone represents a time zone offset, and also figures out daylight savings. Typically, you get a
  • JLabel (javax.swing)
  • JOptionPane (javax.swing)
  • 21 Best Atom Packages for 2021
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyStudentsTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now