How to use io.vertx.core.http

/**
 * Constructor to create an options from JSON
 *
 * @param json  the JSON
 */
public HttpClientOptions(JsonObject json) {
 super(json);
 init();
 HttpClientOptionsConverter.fromJson(json, this);
}

private void testURIAndPath(String uri, String path) {
 server.requestHandler(req -> {
  assertEquals(uri, req.uri());
  assertEquals(path, req.path());
  req.response().end();
 });
 server.listen(onSuccess(server -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, uri, resp -> testComplete()).end();
 }));
 await();
}

private void testHttpClientResponseDecodeError(Handler<Throwable> errorHandler) throws Exception {
 startServer();
 client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> {
  resp.exceptionHandler(errorHandler);
 }));
 await();
}

@Test
public void testOtherMethodRequest() throws Exception {
 server.requestHandler(r -> {
  assertEquals(HttpMethod.OTHER, r.method());
  assertEquals("COPY", r.rawMethod());
  r.response().end();
 }).listen(onSuccess(s -> {
  client.request(HttpMethod.OTHER, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", resp -> {
   testComplete();
  }).setRawMethod("COPY").end();
 }));
 await();
}

@Test
public void testGetAbsoluteURI() {
 server.requestHandler(req -> {
  assertEquals(req.scheme() + "://localhost:" + DEFAULT_HTTP_PORT + "/foo/bar", req.absoluteURI());
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/foo/bar", onSuccess(resp -> resp.endHandler(v -> testComplete()))).end();
 }));
 await();
}

@Test
public void testNoParams() {
 server.requestHandler(req -> {
  assertNull(req.query());
  assertTrue(req.params().isEmpty());
  req.response().end();
 });
 server.listen(onSuccess(server -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> testComplete()).end();
 }));
 await();
}

@Test
public void testRemoteAddress() {
 server.requestHandler(req -> {
  assertEquals("127.0.0.1", req.remoteAddress().host());
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> resp.endHandler(v -> testComplete()))).end();
 }));
 await();
}

@Test
public void testDefaultHttpVersion() {
 server.requestHandler(req -> {
  assertEquals(HttpVersion.HTTP_1_1, req.version());
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> resp.endHandler(v -> testComplete()))).end();
 }));
 await();
}

@Test
public void testClientExceptionHandlerCalledWhenServerTerminatesConnectionAfterPartialResponse() throws Exception {
 server.requestHandler(request -> {
  //Write partial response then close connection before completing it
  request.response().setChunked(true).write("foo").close();
 }).listen(DEFAULT_HTTP_PORT, onSuccess(s -> {
  // Exception handler should be called for any requests in the pipeline if connection is closed
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp ->
    resp.exceptionHandler(t -> testComplete()))).exceptionHandler(error -> fail()).end();
 }));
 await();
}

@Test
public void testRequestBodyBufferAtEnd() {
 Buffer body = TestUtils.randomBuffer(1000);
 server.requestHandler(req -> req.bodyHandler(buffer -> {
  assertEquals(body, buffer);
  req.response().end();
 }));
 server.listen(onSuccess(server -> {
  client.request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> testComplete()).end(body);
 }));
 await();
}

@Test
public void testHostHeaderOverridePossible() {
 server.requestHandler(req -> {
  assertEquals("localhost:4444", req.host());
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> testComplete());
  req.setHost("localhost:4444");
  req.end();
 }));
 await();
}

@Test
public void testSendFileNotFound() throws Exception {
 server.requestHandler(req -> {
  req.response().putHeader("Content-Type", "wibble");
  req.response().sendFile("nosuchfile.html");
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(err -> {})).end();
  vertx.setTimer(100, tid -> testComplete());
 }));
 await();
}

@Test
public void testServerChaining() {
 server.requestHandler(req -> {
  assertTrue(req.response().setChunked(true) == req.response());
  assertTrue(req.response().write("foo", "UTF-8") == req.response());
  assertTrue(req.response().write("foo") == req.response());
  testComplete();
 });
 server.listen(onSuccess(server -> {
  client.request(HttpMethod.PUT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler()).end();
 }));
 await();
}

@Test
public void testSetChunkedToFalse() throws Exception {
 server.requestHandler(req -> req.response().setChunked(false).end());
 startServer();
 client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", resp -> {
  testComplete();
 }).setChunked(false).end();
 await();
}

@Test
public void testKeepAliveTimeout() throws Exception {
 server.requestHandler(req -> {
  req.response().end();
 });
 testKeepAliveTimeout(new HttpClientOptions().setMaxPoolSize(1).setKeepAliveTimeout(3), 1);
}

private void testMinCompression() {
 client.request(HttpMethod.GET, DEFAULT_HTTP_PORT - 1, DEFAULT_HTTP_HOST, "some-uri",
  onSuccess(resp -> {
    resp.bodyHandler(responseBuffer -> {
     String responseBody = responseBuffer.toString(CharsetUtil.UTF_8);
     assertEquals(COMPRESS_TEST_STRING, responseBody);
     minCompressionTestPassed = true;
     terminateTestWhenAllPassed();
    });
   })).end();
}

public void testMaxCompression() {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT + 1, DEFAULT_HTTP_HOST, "some-uri",
   onSuccess(resp -> {
        resp.bodyHandler(responseBuffer -> {
          String responseBody = responseBuffer.toString(CharsetUtil.UTF_8);
          assertEquals(COMPRESS_TEST_STRING, responseBody);
          maxCompressionTestPassed = true;
          terminateTestWhenAllPassed();
        });
      })).end();
}

private void testInvalidKeyStore(KeyCertOptions options, List<String> expectedPossiblePrefixes, String expectedSuffix) {
 HttpServerOptions serverOptions = new HttpServerOptions();
 setOptions(serverOptions, options);
 testStore(serverOptions, expectedPossiblePrefixes, expectedSuffix);
}

private void testSimpleRequest(String uri, HttpMethod method, boolean absolute, Handler<HttpClientResponse> handler) {
 boolean ssl = this instanceof Http2Test;
 HttpClientRequest req;
 if (absolute) {
  req = client.requestAbs(method, (ssl ? "https://" : "http://") + DEFAULT_HTTP_HOST + ":" + DEFAULT_HTTP_PORT + uri, onSuccess(handler::handle));
 } else {
  req = client.request(method, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, uri, onSuccess(handler::handle));
 }
 testSimpleRequest(uri, method, req, absolute);
}

 @Override
 protected TLSTest testTLS(Cert<?> clientCert, Trust<?> clientTrust, Cert<?> serverCert, Trust<?> serverTrust) throws Exception {
  return super.testTLS(clientCert, clientTrust, serverCert, serverTrust).version(HttpVersion.HTTP_2);
 }
}