How to use

getHeader

method

in

io.vertx.core.http.HttpClientResponse

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 testContentTypeSupport() throws Exception {
 testRequest(HttpMethod.GET, "/somedir/range.jpg", req -> {
 }, res -> {
  assertNotNull(res.getHeader("Content-Type"));
  assertEquals("image/jpeg", res.getHeader("Content-Type"));
  testComplete();
 }, 200, "OK", null);
 await();
}

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