@Test public void testSetChunkedToFalse() throws Exception { server.requestHandler(req -> req.response().setChunked(false).end()); startServer(); client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", resp -> { testComplete(); }).setChunked(false).end(); await(); }
@Test public void testClientResponseExceptionHandlerCalledWhenConnectionClosed() throws Exception { AtomicReference<HttpConnection> conn = new AtomicReference<>(); server.requestHandler(req -> { conn.set(req.connection()); req.response().setChunked(true).write("chunk"); }); startServer(); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> { resp.handler(buff -> { conn.get().close(); }); resp.exceptionHandler(err -> { testComplete(); }); })); await(); }
private void pausingServer(Consumer<Future<Void>> consumer) { Future<Void> resumeFuture = Future.future(); server.requestHandler(req -> { req.response().setChunked(true); req.pause(); Context ctx = vertx.getOrCreateContext(); resumeFuture.setHandler(v1 -> { ctx.runOnContext(v2 -> { req.resume(); }); }); req.handler(buff -> { req.response().write(buff); }); }); server.listen(onSuccess(s -> consumer.accept(resumeFuture))); }
@Test public void testResponseBodyWriteFixedString() { String body = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."; Buffer bodyBuff = Buffer.buffer(body); server.requestHandler(req -> { req.response().setChunked(true); req.response().write(body); req.response().end(); }); server.listen(onSuccess(s -> { client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.bodyHandler(buff -> { assertEquals(bodyBuff, buff); testComplete(); }); })).end(); })); await(); }
@Test public void testResetPushPromiseNoHandler() throws Exception { server.requestHandler(req -> { req.response().push(HttpMethod.GET, "/wibble", ar -> { assertTrue(ar.succeeded()); HttpServerResponse resp = ar.result(); resp.setChunked(true).write("content"); AtomicLong reset = new AtomicLong(); resp.exceptionHandler(err -> { if (err instanceof StreamResetException) { reset.set(((StreamResetException)err).getCode()); } }); resp.closeHandler(v -> { assertEquals(Http2Error.CANCEL.code(), reset.get()); testComplete(); }); }); }); startServer(); HttpClientRequest req = client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", resp -> { }); req.end(); await(); }
@Test public void testResponseNoTrailers() { server.requestHandler(req -> { req.response().setChunked(true); 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 -> { assertTrue(resp.trailers().isEmpty()); testComplete(); }); })).end(); })); await(); }
@Test public void testClientExceptionHandlerCalledWhenServerTerminatesConnectionAfterPartialResponse() throws Exception { server.requestHandler(request -> { //Write partial response then close connection before completing it request.response().setChunked(true).write("foo").close(); }).listen(DEFAULT_HTTP_PORT, onSuccess(s -> { // Exception handler should be called for any requests in the pipeline if connection is closed client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> resp.exceptionHandler(t -> testComplete()))).exceptionHandler(error -> fail()).end(); })); await(); }
@Test public void testResponseDataTimeout() { Buffer expected = TestUtils.randomBuffer(1000); server.requestHandler(req -> { req.response().setChunked(true).write(expected); }); server.listen(onSuccess(s -> { Buffer received = Buffer.buffer(); HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.request().setTimeout(500); resp.handler(received::appendBuffer); })); AtomicInteger count = new AtomicInteger(); req.exceptionHandler(t -> { if (count.getAndIncrement() == 0) { assertTrue(t instanceof TimeoutException); assertEquals(expected, received); testComplete(); } }); req.sendHead(); })); await(); }
@Test public void testResponseWrite() { Buffer body = TestUtils.randomBuffer(1000); server.requestHandler(req -> { req.response().setChunked(true); req.response().write(body); req.response().end(); }); server.listen(onSuccess(s -> { client.request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.bodyHandler(buff -> { assertEquals(body, buff); testComplete(); }); })).end(); })); await(); }
@Test public void testUnmaskedFrameRequest(){ client = vertx.createHttpClient(new HttpClientOptions().setSendUnmaskedFrames(true)); server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT).setAcceptUnmaskedFrames(true)); server.requestHandler(req -> { req.response().setChunked(true).write("connect"); }); server.websocketHandler(ws -> { ws.handler(new Handler<Buffer>() { public void handle(Buffer data) { assertEquals(data.toString(), "first unmasked frame"); testComplete(); } }); }); server.listen(onSuccess(server -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> { ws.writeFinalTextFrame("first unmasked frame"); }); })); await(); }
private void checkHttpServerResponse(HttpServerResponse resp) { Buffer buff = Buffer.buffer(); assertIllegalStateException(() -> resp.drainHandler(noOpHandler())); assertIllegalStateException(() -> resp.end()); assertIllegalStateException(() -> resp.end("foo")); assertIllegalStateException(() -> resp.end(buff)); assertIllegalStateException(() -> resp.end("foo", "UTF-8")); assertIllegalStateException(() -> resp.exceptionHandler(noOpHandler())); assertIllegalStateException(() -> resp.setChunked(false)); assertIllegalStateException(() -> resp.setWriteQueueMaxSize(123)); assertIllegalStateException(() -> resp.write(buff)); assertIllegalStateException(() -> resp.write("foo")); assertIllegalStateException(() -> resp.write("foo", "UTF-8")); assertIllegalStateException(() -> resp.write(buff)); assertIllegalStateException(() -> resp.writeQueueFull()); assertIllegalStateException(() -> resp.sendFile("asokdasokd")); }
@Test public void testChunkedServerResponse() { server.requestHandler(req -> { HttpServerResponse resp = req.response(); resp.setChunked(true); assertTrue(resp.isChunked()); resp.write("the-chunk"); vertx.setTimer(1, id -> { resp.end(); }); }).listen(onSuccess(server -> { client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(res -> { assertEquals("chunked", res.getHeader("transfer-encoding")); res.bodyHandler(body -> { assertEquals("the-chunk", body.toString()); testComplete(); }); })); })); await(); }
@Test public void testInvalidUnmaskedFrameRequest(){ client = vertx.createHttpClient(new HttpClientOptions().setSendUnmaskedFrames(true)); server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)); server.requestHandler(req -> { req.response().setChunked(true).write("connect"); }); server.websocketHandler(ws -> { ws.exceptionHandler(exception -> { testComplete(); }); ws.handler(result -> { fail("Cannot decode unmasked message because I require masked frame as configured"); }); }); server.listen(onSuccess(server -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> { ws.writeFinalTextFrame("first unmasked frame"); }); })); await(); }
@Test public void testServerChaining() { server.requestHandler(req -> { assertTrue(req.response().setChunked(true) == req.response()); assertTrue(req.response().write("foo", "UTF-8") == req.response()); assertTrue(req.response().write("foo") == req.response()); testComplete(); }); server.listen(onSuccess(server -> { client.request(HttpMethod.PUT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler()).end(); })); 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(); }
private void drainingServer(Consumer<Future<Void>> consumer) { Future<Void> resumeFuture = Future.future(); server.requestHandler(req -> { req.response().setChunked(true); assertFalse(req.response().writeQueueFull()); req.response().setWriteQueueMaxSize(1000); Buffer buff = TestUtils.randomBuffer(10000); //Send data until the buffer is full vertx.setPeriodic(1, id -> { req.response().write(buff); if (req.response().writeQueueFull()) { vertx.cancelTimer(id); req.response().drainHandler(v -> { assertFalse(req.response().writeQueueFull()); testComplete(); }); // Tell the client to resume resumeFuture.complete(); } }); }); server.listen(onSuccess(s -> consumer.accept(resumeFuture))); }
@Test public void testClientConnectionClosed() throws Exception { server.requestHandler(req -> { req.response().setChunked(true).write(Buffer.buffer("some-data")); }); startServer(); client = vertx.createHttpClient(createBaseClientOptions().setIdleTimeout(2)); FakeHttpClientMetrics metrics = FakeMetricsBase.getMetrics(client); HttpClientRequest req = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> { HttpClientMetric metric = metrics.getMetric(resp.request()); assertNotNull(metric); assertFalse(metric.failed.get()); resp.exceptionHandler(err -> { assertNull(metrics.getMetric(resp.request())); assertTrue(metric.failed.get()); testComplete(); }); })); req.end(); await(); }
@Test public void testCloseHandlerWhenConnectionEnds() throws Exception { server.requestHandler(req -> { req.response().closeHandler(v -> { testComplete(); }); req.response().setChunked(true).write("some-data"); }); startServer(); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> { resp.handler(v -> { resp.request().connection().close(); }); })); await(); }
@Test public void testCloseHandlerWhenConnectionClose() throws Exception { server.requestHandler(req -> { HttpServerResponse resp = req.response(); resp.setChunked(true).write("some-data"); resp.closeHandler(v -> { checkHttpServerResponse(resp); testComplete(); }); }); startServer(); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> { resp.handler(v -> { resp.request().connection().close(); }); })); await(); }
@Test public void testClientWebsocketWithHttp2Client() throws Exception { client.close(); client = vertx.createHttpClient(new HttpClientOptions().setHttp2ClearTextUpgrade(false).setProtocolVersion(HttpVersion.HTTP_2)); server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)); server.requestHandler(req -> { req.response().setChunked(true).write("connect"); }); server.websocketHandler(ws -> { ws.writeFinalTextFrame("ok"); }); server.listen(onSuccess(server -> { client.getNow(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", resp -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> { ws.handler(buff -> { assertEquals("ok", buff.toString()); testComplete(); }); }); }); })); await(); }