@Test public void testInvalidChunkInHttpServerRequest() throws Exception { testHttpServerRequestDecodeError(so -> { so.write("invalid\r\n"); // Empty chunk }, errors -> { assertEquals(2, errors.size()); assertEquals(NumberFormatException.class, errors.get(0).getClass()); }); }
@Test public void testInvalidTrailerInHttpServerRequest() throws Exception { testHttpServerRequestDecodeError(so -> { so.write("0\r\n"); // Empty chunk // Send large trailer for (int i = 0;i < 2000;i++) { so.write("01234567"); } }, errors -> { assertEquals(2, errors.size()); assertEquals(TooLongFrameException.class, errors.get(0).getClass()); }); }
@Test public void testRandomPorts() throws Exception { int numServers = 10; Set<Integer> ports = Collections.synchronizedSet(new HashSet<>()); AtomicInteger count = new AtomicInteger(); for (int i = 0;i < numServers;i++) { vertx.createHttpServer().requestHandler(req -> { req.response().end(); }).listen(0, DEFAULT_HTTP_HOST, onSuccess(s -> { int port = s.actualPort(); ports.add(port); client.getNow(port, DEFAULT_HTTP_HOST, "/somepath", resp -> { if (count.incrementAndGet() == numServers) { assertEquals(numServers, ports.size()); 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 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 testPausedHttpClientResponseUnpauseTheConnectionAtRequestEnd() throws Exception { testHttpClientResponsePause(resp -> { resp.handler(buff -> { // Pausing the request here should have no effect since it's the last chunk assertEquals("ok", buff.toString()); resp.pause(); }); }); }
@Test public void testChunkedClientRequest() { server.requestHandler(req -> { HttpServerResponse resp = req.response(); assertEquals("chunked", req.getHeader("transfer-encoding")); req.bodyHandler(body -> { assertEquals("the-chunk", body.toString()); req.response().end(); }); }).listen(onSuccess(server -> { HttpClientRequest req = client.put(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", res -> { testComplete(); }); req.setChunked(true); req.write("the-chunk"); vertx.setTimer(1, id -> { 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 testContentDecompression() throws Exception { server.close(); server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT).setDecompressionSupported(true)); String expected = TestUtils.randomAlphaString(1000); byte[] dataGzipped = TestUtils.compressGzip(expected); server.requestHandler(req -> { assertEquals("localhost:" + DEFAULT_HTTP_PORT, req.headers().get("host")); req.bodyHandler(buffer -> { assertEquals(expected, buffer.toString()); req.response().end(); }); }); server.listen(onSuccess(server -> { client .request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "some-uri", onSuccess(resp -> testComplete())) .putHeader("Content-Encoding", "gzip") .end(Buffer.buffer(dataGzipped)); })); 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(); }
@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 testHttp11NonPersistentConnectionClosed() throws Exception { client.close(); server.requestHandler(req -> { assertEquals(HttpVersion.HTTP_1_1, req.version()); assertEquals(req.getHeader("Connection"), "close"); req.response().end(); assertTrue(req.response().closed()); }); server.listen(onSuccess(s -> { client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_1).setKeepAlive(false)); HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.endHandler(v -> { assertEquals(resp.getHeader("Connection"), "close"); testComplete(); }); })); req.end(); })); 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 testHttpProxyFtpRequest() throws Exception { startProxy(null, ProxyType.HTTP); client.close(); client = vertx.createHttpClient(new HttpClientOptions() .setProxyOptions(new ProxyOptions().setType(ProxyType.HTTP).setHost("localhost").setPort(proxy.getPort()))); final String url = "ftp://ftp.gnu.org/gnu/"; proxy.setForceUri("http://localhost:8080/"); server.requestHandler(req -> { req.response().end(); }); server.listen(onSuccess(s -> { HttpClientRequest clientReq = client.getAbs(url, onSuccess(resp -> { assertEquals(200, resp.statusCode()); assertEquals("request did sent the expected url", url, proxy.getLastUri()); testComplete(); })); clientReq.exceptionHandler(this::fail); clientReq.end(); })); await(); }
@Test public void testAccessNetSocket() throws Exception { Buffer toSend = TestUtils.randomBuffer(1000); server.requestHandler(req -> { req.response().headers().set("HTTP/1.1", "101 Upgrade"); req.bodyHandler(data -> { assertEquals(toSend, data); req.response().end("somecontent"); }); }); server.listen(onSuccess(s -> { HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.endHandler(v -> { assertNotNull(resp.netSocket()); testComplete(); }); })); req.headers().set("content-length", String.valueOf(toSend.length())); req.write(toSend); })); await(); }
@Test public void testPartialH2CAmbiguousRequest() throws Exception { server.requestHandler(req -> { assertEquals("POST", req.rawMethod()); testComplete(); }); Buffer fullRequest = Buffer.buffer("POST /whatever HTTP/1.1\r\n\r\n"); startServer(); NetClient client = vertx.createNetClient(); client.connect(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(so -> { so.write(fullRequest.slice(0, 1)); vertx.setTimer(1000, id -> { so.write(fullRequest.slice(1, fullRequest.length())); }); })); 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(); }
@Test public void testHttp10RequestNonKeepAliveConnectionClosed() throws Exception { client.close(); server.requestHandler(req -> { assertEquals(HttpVersion.HTTP_1_0, req.version()); assertNull(req.getHeader("Connection")); req.response().end(); assertTrue(req.response().closed()); }); server.listen(onSuccess(s -> { client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_0).setKeepAlive(false)); HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.endHandler(v -> { assertNull(resp.getHeader("Connection")); testComplete(); }); })); req.end(); })); 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(); }