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

  • 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
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