io.vertx.core.http.HttpClientResponse.statusCode java code examples

private void expectStatusError(int error, int responseStatus, String username, String url) throws Exception {
 proxyTest(error, username, url, onSuccess(resp -> {
  assertEquals(responseStatus, resp.statusCode());
  testComplete();
 }));
}

 @Test
 public void testNoRequestHandler() throws Exception {
  CountDownLatch latch = new CountDownLatch(1);
  vertx.createHttpServer()
   .websocketHandler(ws -> fail())
   .listen(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(v -> latch.countDown()));
  awaitLatch(latch);
  client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> {
   resp.endHandler(v -> {
    assertEquals(400, resp.statusCode());
    testComplete();
   });
  }));
  await();
 }
}

private void testHttpProxyRequest2(Function<Handler<AsyncResult<HttpClientResponse>>, HttpClientRequest> reqFact) throws Exception {
 server.requestHandler(req -> {
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  HttpClientRequest req = reqFact.apply(onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   assertNotNull("request did not go through proxy", proxy.getLastUri());
   assertEquals("Host header doesn't contain target host", "localhost:8080", proxy.getLastRequestHeaders().get("Host"));
   testComplete();
  }));
  req.exceptionHandler(this::fail);
  req.end();
 }));
 await();
}

@Test
public void testServerOptionsCopiedBeforeUse() {
 server.close();
 HttpServerOptions options = new HttpServerOptions().setHost(DEFAULT_HTTP_HOST).setPort(DEFAULT_HTTP_PORT);
 HttpServer server = vertx.createHttpServer(options);
 // Now change something - but server should still listen at previous port
 options.setPort(DEFAULT_HTTP_PORT + 1);
 server.requestHandler(req -> {
  req.response().end();
 });
 server.listen(ar -> {
  assertTrue(ar.succeeded());
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/uri", onSuccess(res -> {
   assertEquals(200, res.statusCode());
   testComplete();
  })).end();
 });
 await();
}

@Test
public void testServerActualPortWhenSet() {
 server
   .requestHandler(request -> {
    request.response().end("hello");
   })
   .listen(ar -> {
    assertEquals(ar.result().actualPort(), DEFAULT_HTTP_PORT);
    vertx.createHttpClient(createBaseClientOptions()).getNow(ar.result().actualPort(), DEFAULT_HTTP_HOST, "/", onSuccess(response -> {
     assertEquals(response.statusCode(), 200);
     response.bodyHandler(body -> {
      assertEquals(body.toString("UTF-8"), "hello");
      testComplete();
     });
    }));
   });
 await();
}

@Test
public void testClientOptionsCopiedBeforeUse() {
 client.close();
 server.requestHandler(req -> {
  req.response().end();
 });
 server.listen(ar -> {
  assertTrue(ar.succeeded());
  HttpClientOptions options = new HttpClientOptions();
  client = vertx.createHttpClient(options);
  // Now change something - but server should ignore this
  options.setSsl(true);
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/uri", onSuccess(res -> {
   assertEquals(200, res.statusCode());
   testComplete();
  })).end();
 });
 await();
}

@Test
public void testServerResponseWriteBufferFromOtherThread() throws Exception {
 server.requestHandler(req -> {
  runAsync(() -> {
   req.response().write("hello ").end("world");
  });
 }).listen(onSuccess(v -> {
  client.get(8080, "localhost", "/somepath", onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   resp.bodyHandler(buff -> {
    assertEquals(Buffer.buffer("hello world"), buff);
    testComplete();
   });
  })).exceptionHandler(this::fail).end();
 }));
 await();
}

@Test
public void testServerActualPortWhenZero() {
 server = vertx.createHttpServer(createBaseServerOptions().setPort(0).setHost(DEFAULT_HTTP_HOST));
 server
   .requestHandler(request -> {
    request.response().end("hello");
   })
   .listen(ar -> {
    assertTrue(ar.result().actualPort() != 0);
    vertx.createHttpClient(createBaseClientOptions()).getNow(ar.result().actualPort(), DEFAULT_HTTP_HOST, "/", onSuccess(response -> {
     assertEquals(response.statusCode(), 200);
     response.bodyHandler(body -> {
      assertEquals(body.toString("UTF-8"), "hello");
      testComplete();
     });
    }));
   });
 await();
}

@Test
public void testServerActualPortWhenZeroPassedInListen() {
 server = vertx.createHttpServer(new HttpServerOptions(createBaseServerOptions()).setHost(DEFAULT_HTTP_HOST));
 server
   .requestHandler(request -> {
    request.response().end("hello");
   })
   .listen(0, ar -> {
    assertTrue(ar.result().actualPort() != 0);
    vertx.createHttpClient(createBaseClientOptions()).getNow(ar.result().actualPort(), DEFAULT_HTTP_HOST, "/", onSuccess(response -> {
     assertEquals(response.statusCode(), 200);
     response.bodyHandler(body -> {
      assertEquals(body.toString("UTF-8"), "hello");
      testComplete();
     });
    }));
   });
 await();
}

@Test
public void testSetWriteQueueMaxSize() throws Exception {
 server.requestHandler(req -> {
  HttpServerResponse resp = req.response();
  resp.setWriteQueueMaxSize(256 * 1024);
  // Now something bigger
  resp.setWriteQueueMaxSize(512 * 1024);
  // And something smaller again
  resp.setWriteQueueMaxSize(128 * 1024);
  resp.setWriteQueueMaxSize(129 * 1024);
  resp.end();
 }).listen(8080, onSuccess(s -> {
  client.getNow(8080, "localhost", "/", onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   testComplete();
  }));
 }));
 await();
}

@Test
public void testPutHeadersOnRequest() {
 server.requestHandler(req -> {
  assertEquals("bar", req.headers().get("foo"));
  assertEquals("bar", req.getHeader("foo"));
  req.response().end();
 });
 server.listen(onSuccess(server -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   testComplete();
  })).putHeader("foo", "bar").end();
 }));
 await();
}

@Test
public void testHttpInvalidConnectResponseEnded() {
 waitFor(2);
 server.requestHandler(req -> {
  req.response().end();
  try {
   req.netSocket();
   fail();
  } catch (IllegalStateException e) {
   complete();
  }
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.CONNECT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   complete();
  })).end();
 }));
 await();
}

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

private void handshake(Handler<NetSocket> handler) {
 HttpClientRequest request = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/",
  onSuccess(resp -> {
   assertEquals(101, resp.statusCode());
   handler.handle(resp.netSocket());
  })
 );
 request
  .putHeader("Upgrade", "websocket")
  .putHeader("Connection", "Upgrade")
  .putHeader("Sec-WebSocket-Key", "dGhlIHNhbXBsZSBub25jZQ==")
  .putHeader("Sec-WebSocket-Protocol", "chat")
  .putHeader("Sec-WebSocket-Version", "13")
  .putHeader("Origin", "http://example.com");
 request.end();
}

@Test
public void testClientLocalAddress() throws Exception {
 String expectedAddress = TestUtils.loopbackAddress();
 client.close();
 client = vertx.createHttpClient(createBaseClientOptions().setLocalAddress(expectedAddress));
 server.requestHandler(req -> {
  assertEquals(expectedAddress, req.remoteAddress().host());
  req.response().end();
 });
 startServer();
 client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> {
  assertEquals(200, resp.statusCode());
  testComplete();
 }));
 await();
}

@Test
public void testHttpInvalidConnectResponseChunked() {
 waitFor(2);
 server.requestHandler(req -> {
  req.response().setChunked(true).write("some-chunk");
  try {
   req.netSocket();
   fail();
  } catch (IllegalStateException e) {
   complete();
  }
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.CONNECT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   complete();
  })).end();
 }));
 await();
}

@Test
public void testRequestEntityTooLarge() {
 String path = "/some/path";
 server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).websocketHandler(ws -> fail());
 server.listen(onSuccess(ar -> {
  client.get(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTPS_HOST, path, onSuccess(resp -> {
   assertEquals(413, resp.statusCode());
   resp.request().connection().closeHandler(v -> {
    testComplete();
   });
  })).putHeader("Upgrade", "Websocket")
   .putHeader("Connection", "Upgrade")
   .end(TestUtils.randomBuffer(8192 + 1));
 }));
 await();
}

@Test
public void testHttpSocksProxyRequest() throws Exception {
 startProxy(null, ProxyType.SOCKS5);
 client.close();
 client = vertx.createHttpClient(new HttpClientOptions()
   .setProxyOptions(new ProxyOptions().setType(ProxyType.SOCKS5).setHost("localhost").setPort(proxy.getPort())));
 server.requestHandler(req -> {
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   assertNotNull("request did not go through proxy", proxy.getLastUri());
   testComplete();
  })).exceptionHandler(th -> fail(th)).end();
 }));
 await();
}

@Test
public void testHttpSocksProxyRequestAuth() throws Exception {
 startProxy("user", ProxyType.SOCKS5);
 client.close();
 client = vertx.createHttpClient(new HttpClientOptions()
   .setProxyOptions(new ProxyOptions().setType(ProxyType.SOCKS5).setHost("localhost").setPort(proxy.getPort())
     .setUsername("user").setPassword("user")));
 server.requestHandler(req -> {
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   assertNotNull("request did not go through proxy", proxy.getLastUri());
   testComplete();
  })).exceptionHandler(th -> fail(th)).end();
 }));
 await();
}

@Test
public void testHttpProxyRequestAuth() throws Exception {
 startProxy("user", ProxyType.HTTP);
 client.close();
 client = vertx.createHttpClient(new HttpClientOptions()
   .setProxyOptions(new ProxyOptions().setType(ProxyType.HTTP).setHost("localhost").setPort(proxy.getPort())
     .setUsername("user").setPassword("user")));
 server.requestHandler(req -> {
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   assertNotNull("request did not go through proxy", proxy.getLastUri());
   assertEquals("Host header doesn't contain target host", "localhost:8080", proxy.getLastRequestHeaders().get("Host"));
   testComplete();
  })).exceptionHandler(th -> fail(th)).end();
 }));
 await();
}

Popular methods of HttpClientResponse

bodyHandler
Convenience method for receiving the entire request body in one piece. This saves you having to manu
statusMessage
headers
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

Popular in Java

Running tasks concurrently on multiple threads
getSharedPreferences (Context)
setContentView (Activity)
getContentResolver (Context)
FlowLayout (java.awt)
A flow layout arranges components in a left-to-right flow, much like lines of text in a paragraph. F
Runnable (java.lang)
Represents a command that can be executed. Often used to run code in a different Thread.
HttpURLConnection (java.net)
An URLConnection for HTTP (RFC 2616 [http://tools.ietf.org/html/rfc2616]) used to send and receive d
HashMap (java.util)
HashMap is an implementation of Map. All optional operations are supported.All elements are permitte
JPanel (javax.swing)
JTextField (javax.swing)
PhpStorm for WordPress

How to use statusCodemethodin io.vertx.core.http.HttpClientResponse

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

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