How to use

statusCode

method

in

io.vertx.core.http.HttpClientResponse

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