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(); }
private void testParamDecoding(String value) throws UnsupportedEncodingException { server.requestHandler(req -> { req.setExpectMultipart(true); req.endHandler(v -> { MultiMap formAttributes = req.formAttributes(); assertEquals(value, formAttributes.get("param")); }); req.response().end(); }); String postData = "param=" + URLEncoder.encode(value,"UTF-8"); server.listen(onSuccess(server -> { client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> testComplete())) .putHeader(HttpHeaders.CONTENT_TYPE, HttpHeaders.APPLICATION_X_WWW_FORM_URLENCODED) .putHeader(HttpHeaders.CONTENT_LENGTH, String.valueOf(postData.length())) .write(postData).end(); })); await(); }
@Test public void testSendFileWithConnectionCloseHeader() throws Exception { String content = TestUtils.randomUnicodeString(1024 * 1024 * 2); sendFile("test-send-file.html", content, false, handler -> client .get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, handler) .putHeader(HttpHeaders.CONNECTION, "close")); }
public void testRawMinCompression() { clientraw.request(HttpMethod.GET, DEFAULT_HTTP_PORT - 1, DEFAULT_HTTP_HOST, "some-uri", onSuccess(resp -> { resp.bodyHandler(responseBuffer -> { String responseCompressedBody = responseBuffer.toString(CharsetUtil.UTF_8); Integer responseByteCount = responseCompressedBody.getBytes(CharsetUtil.UTF_8).length; // assertEquals((Integer)1642,responseByteCount); rawMinCompressionResponseByteCount = responseByteCount; terminateTestWhenAllPassed(); }); })).putHeader(HttpHeaders.ACCEPT_ENCODING, HttpHeaders.DEFLATE_GZIP).end(); }
private void testRawMinCompression() { clientraw.request(HttpMethod.GET, DEFAULT_HTTP_PORT - 1, DEFAULT_HTTP_HOST, "some-uri", onSuccess(resp -> { resp.bodyHandler(responseBuffer -> { String responseCompressedBody = responseBuffer.toString(CharsetUtil.UTF_8); Integer responseByteCount = responseCompressedBody.getBytes(CharsetUtil.UTF_8).length; // assertEquals((Integer)1642,responseByteCount); rawMinCompressionResponseByteCount = responseByteCount; terminateTestWhenAllPassed(); }); })).putHeader(HttpHeaders.ACCEPT_ENCODING, HttpHeaders.DEFLATE_GZIP).end(); }
public void testRawMaxCompression() { clientraw.request(HttpMethod.GET, DEFAULT_HTTP_PORT + 1, DEFAULT_HTTP_HOST, "some-uri", onSuccess(resp -> { resp.bodyHandler(responseBuffer -> { String responseCompressedBody = responseBuffer.toString(CharsetUtil.UTF_8); Integer responseByteCount = responseCompressedBody.getBytes(CharsetUtil.UTF_8).length; //1606 // assertEquals((Integer)1606,responseByteCount); // assertEquals(LARGE_HTML_STRING, responseBody); rawMaxCompressionResponseByteCount = responseByteCount; terminateTestWhenAllPassed(); }); })).putHeader(HttpHeaders.ACCEPT_ENCODING, HttpHeaders.DEFLATE_GZIP).end(); }
private void testRawMaxCompression() { clientraw.request(HttpMethod.GET, DEFAULT_HTTP_PORT + 1, DEFAULT_HTTP_HOST, "some-uri", onSuccess(resp -> { resp.bodyHandler(responseBuffer -> { String responseCompressedBody = responseBuffer.toString(CharsetUtil.UTF_8); Integer responseByteCount = responseCompressedBody.getBytes(CharsetUtil.UTF_8).length; //1606 // assertEquals((Integer)1606,responseByteCount); // assertEquals(LARGE_HTML_STRING, responseBody); rawMaxCompressionResponseByteCount = responseByteCount; terminateTestWhenAllPassed(); }); })).putHeader(HttpHeaders.ACCEPT_ENCODING, HttpHeaders.DEFLATE_GZIP).end(); }
@Test public void testConnectionCloseHttp_1_0_NoClose() throws Exception { testConnectionClose(req -> { req.putHeader("Connection", "close"); req.end(); }, socket -> { AtomicBoolean firstRequest = new AtomicBoolean(true); socket.handler(RecordParser.newDelimited("\r\n\r\n", buffer -> { if (firstRequest.getAndSet(false)) { socket.write("HTTP/1.0 200 OK\n" + "Content-Type: text/plain\n" + "Content-Length: 4\n" + "Connection: keep-alive\n" + "\n" + "xxx\n"); } else { socket.write("HTTP/1.0 200 OK\n" + "Content-Type: text/plain\n" + "Content-Length: 1\n" + "\n" + "\n"); } })); }); }
@Test public void testServerExceptionHandler() throws Exception { server.exceptionHandler(err -> { assertTrue(err instanceof TooLongFrameException); testComplete(); }); server.requestHandler(req -> { fail(); }); CountDownLatch listenLatch = new CountDownLatch(1); server.listen(onSuccess(s -> listenLatch.countDown())); awaitLatch(listenLatch); HttpClientRequest req = client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", resp -> { }); req.putHeader("the_header", TestUtils.randomAlphaString(10000)); req.sendHead(); await(); }
@Test public void testIncorrectHttpVersion() throws Exception { server.requestHandler(req -> { NetSocket so = req.netSocket(); so.write(Buffer.buffer("HTTP/1.2 200 OK\r\nContent-Length:5\r\n\r\nHELLO")); so.close(); }); startServer(); AtomicBoolean a = new AtomicBoolean(); HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(err -> { if (a.compareAndSet(false, true)) { assertTrue("message " + err.getMessage() + " should contain HTTP/1.2", err.getMessage().contains("HTTP/1.2")); } })); req.exceptionHandler(err -> { fail("Should not be called"); }).putHeader("connection", "close") .connectionHandler(conn -> conn.closeHandler(v -> testComplete())) .end(); await(); }
@Test public void testConnectionCloseHttp_1_0_Close() throws Exception { testConnectionClose(req -> { req.putHeader("Connection", "close"); req.end(); }, socket -> { AtomicBoolean firstRequest = new AtomicBoolean(true); socket.handler(RecordParser.newDelimited("\r\n\r\n", buffer -> { if (firstRequest.getAndSet(false)) { socket.write("HTTP/1.0 200 OK\n" + "Content-Type: text/plain\n" + "Content-Length: 4\n" + "Connection: keep-alive\n" + "\n" + "xxx\n"); } else { socket.write("HTTP/1.0 200 OK\n" + "Content-Type: text/plain\n" + "Content-Length: 1\n" + "\n" + "\n"); socket.close(); } })); }); }
@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 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 testBytesReadRequest() throws Exception { int length = 2048; Buffer expected = Buffer.buffer(TestUtils.randomAlphaString(length));; server.requestHandler(req -> { req.bodyHandler(buffer -> { assertEquals(req.bytesRead(), length); req.response().end(); }); }); startServer(); client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.bodyHandler(buff -> { testComplete(); }); })).exceptionHandler(this::fail) .putHeader("content-length", String.valueOf(length)) .write(expected) .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 testSkipEncoding() throws Exception { serverWithMaxCompressionLevel.requestHandler(req -> { assertNotNull(req.headers().get("Accept-Encoding")); req.response() .putHeader(HttpHeaders.CONTENT_ENCODING, HttpHeaders.IDENTITY) .end(Buffer.buffer(COMPRESS_TEST_STRING).toString(CharsetUtil.UTF_8)); }); startServer(serverWithMaxCompressionLevel); clientraw.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); testComplete(); }); })).putHeader(HttpHeaders.ACCEPT_ENCODING, HttpHeaders.DEFLATE_GZIP).end(); await(); }
@Test public void testClientRequestArguments() throws Exception { HttpClientRequest req = client.request(HttpMethod.PUT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler()); assertNullPointerException(() -> req.putHeader((String) null, "someValue")); assertNullPointerException(() -> req.putHeader((CharSequence) null, "someValue")); assertNullPointerException(() -> req.putHeader("someKey", (Iterable<String>) null)); assertNullPointerException(() -> req.write((Buffer) null)); assertNullPointerException(() -> req.write((String) null)); assertNullPointerException(() -> req.write(null, "UTF-8")); assertNullPointerException(() -> req.write("someString", null)); assertNullPointerException(() -> req.end((Buffer) null)); assertNullPointerException(() -> req.end((String) null)); assertNullPointerException(() -> req.end(null, "UTF-8")); assertNullPointerException(() -> req.end("someString", null)); assertIllegalArgumentException(() -> req.setTimeout(0)); }
@Test public void testPerHostPooling() throws Exception { client.close(); client = vertx.createHttpClient(new HttpClientOptions() .setMaxPoolSize(1) .setKeepAlive(true) .setPipelining(false)); testPerXXXPooling((i, handler) -> client.get(DEFAULT_HTTP_PORT, "host" + i, "/somepath", handler).setHost("host:8080") .putHeader("key", "host" + i), req -> req.getHeader("key")); }
@Test public void testContainsValueStringIgnoreCase() { server.requestHandler(req -> { assertTrue(req.headers().contains("Foo", "foo", true)); assertTrue(req.headers().contains("Foo", "fOo", true)); req.response().putHeader("quux", "quux"); req.response().end(); }); server.listen(onSuccess(server -> { HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertTrue(resp.headers().contains("Quux", "quux", true)); assertTrue(resp.headers().contains("Quux", "quUx", true)); testComplete(); })); req.putHeader("foo", "foo"); req.end(); })); await(); }
@Test public void testContainsValueString() { server.requestHandler(req -> { assertTrue(req.headers().contains("Foo", "foo", false)); assertFalse(req.headers().contains("Foo", "fOo", false)); req.response().putHeader("quux", "quux"); req.response().end(); }); server.listen(onSuccess(server -> { HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertTrue(resp.headers().contains("Quux", "quux", false)); assertFalse(resp.headers().contains("Quux", "quUx", false)); testComplete(); })); req.putHeader("foo", "foo"); req.end(); })); await(); }