Best Java code snippets using io.vertx.core.http (Showing top 15 results out of 1,755)

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();
}

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

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

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();
}

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

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

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

private 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();
}

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

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 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();
}