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