private void testHttpClientResponseDecodeError(Handler<Throwable> errorHandler) throws Exception { startServer(); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> { resp.exceptionHandler(errorHandler); })); await(); }
@Test public void testClientExceptionHandlerCalledWhenExceptionOnDataHandler() throws Exception { server.requestHandler(request -> { request.response().end("foo"); }).listen(DEFAULT_HTTP_PORT, onSuccess(s -> { // Exception handler should be called for any exceptions in the data handler client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.handler(data -> { throw new RuntimeException("should be caught"); }); resp.exceptionHandler(t -> testComplete()); })).exceptionHandler(error -> fail()).end(); })); await(); }
@Test public void testClientExceptionHandlerCalledWhenExceptionOnBodyHandler() throws Exception { server.requestHandler(request -> { request.response().end("foo"); }).listen(DEFAULT_HTTP_PORT, onSuccess(s -> { // Exception handler should be called for any exceptions in the data handler client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.bodyHandler(data -> { throw new RuntimeException("should be caught"); }); resp.exceptionHandler(t -> testComplete()); })).exceptionHandler(error -> fail()).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(); }
protected MultiMap checkEmptyHttpResponse(HttpMethod method, int sc, MultiMap reqHeaders) throws Exception { server.requestHandler(req -> { HttpServerResponse resp = req.response(); resp.setStatusCode(sc); resp.headers().addAll(reqHeaders); resp.end(); }); startServer(); try { CompletableFuture<MultiMap> result = new CompletableFuture<>(); client.request(method, DEFAULT_HTTP_PORT, DEFAULT_HTTPS_HOST, "/", onSuccess(resp -> { Buffer body = Buffer.buffer(); resp.exceptionHandler(result::completeExceptionally); resp.handler(body::appendBuffer); resp.endHandler(v -> { if (body.length() > 0) { result.completeExceptionally(new Exception()); } else { result.complete(resp.headers()); } }); })).setFollowRedirects(false) .exceptionHandler(result::completeExceptionally) .end(); return result.get(20, TimeUnit.SECONDS); } finally { client.close(); } }
@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 testBodyEndHandler() throws Exception { // Large body so it will be fragmented in several HTTP2 data frames Buffer expected = Buffer.buffer(TestUtils.randomAlphaString(128 * 1024)); server.requestHandler(req -> { HttpServerResponse resp = req.response(); resp.end(expected); }); startServer(); client.getNow(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> { Context ctx = vertx.getOrCreateContext(); resp.exceptionHandler(this::fail); resp.bodyHandler(body -> { assertOnIOContext(ctx); assertEquals(expected, body); testComplete(); }); })); await(); }
@Test public void testNoExceptionHandlerCalledWhenResponseEnded() throws Exception { server.requestHandler(req -> { HttpServerResponse resp = req.response(); req.exceptionHandler(this::fail); resp.exceptionHandler(err -> { err.printStackTrace(); }); resp.end(); }).listen(DEFAULT_HTTP_PORT, onSuccess(s -> { client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.endHandler(v -> { vertx.setTimer(100, tid -> testComplete()); }); resp.exceptionHandler(t -> { fail("Should not be called"); }); })).exceptionHandler(t -> { fail("Should not be called"); }).end(); })); await(); }
@Test public void testClientResetServerStreamDuringResponse() throws Exception { server.requestHandler(req -> { req.exceptionHandler(err -> { assertEquals(err.getClass(), StreamResetException.class); }); AtomicLong reset = new AtomicLong(); req.response().exceptionHandler(err -> { if (err instanceof StreamResetException) { reset.set(((StreamResetException) err).getCode()); } }); req.response().closeHandler(v -> { assertEquals(10L, reset.get()); testComplete(); }); req.response().setChunked(true).write(Buffer.buffer("some-data")); }); startServer(); client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> { resp.exceptionHandler(this::fail); resp.request().reset(10); assertIllegalStateException(() -> resp.request().write(Buffer.buffer())); assertIllegalStateException(resp.request()::end); })).end(Buffer.buffer("hello")); await(); }
}); }); resp.exceptionHandler(this::fail); resp.endHandler(v -> { assertEquals(expected, length[0]);
private void sendFile(String fileName, String contentExpected, boolean useHandler, Function<Handler<AsyncResult<HttpClientResponse>>, HttpClientRequest> requestFact) throws Exception { waitFor(2); File fileToSend = setupFile(fileName, contentExpected); server.requestHandler(req -> { if (useHandler) { Handler<AsyncResult<Void>> completionHandler = onSuccess(v -> complete()); req.response().sendFile(fileToSend.getAbsolutePath(), completionHandler); } else { req.response().sendFile(fileToSend.getAbsolutePath()); complete(); } }); startServer(); requestFact.apply(onSuccess(resp -> { assertEquals(200, resp.statusCode()); assertEquals("text/html", resp.headers().get("Content-Type")); resp.exceptionHandler(this::fail); resp.bodyHandler(buff -> { assertEquals(contentExpected, buff.toString()); assertEquals(fileToSend.length(), Long.parseLong(resp.headers().get("content-length"))); complete(); }); })).end(); await(); }
client = vertx.createHttpClient(clientOptions.setHttp2KeepAliveTimeout(5).setIdleTimeout(2)); HttpClientRequest req = client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> { resp.exceptionHandler(err -> { fail(); });
@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(); }
resp.exceptionHandler(th -> { fail(); });
@Test public void testSendFilePipelined() throws Exception { int n = 4; waitFor(n); File sent = TestUtils.tmpFile(".dat", 16 * 1024); server.requestHandler( req -> { req.response().sendFile(sent.getAbsolutePath()); }); startServer(); client.close(); client = vertx.createHttpClient(createBaseClientOptions().setPipelining(true).setMaxPoolSize(1)); for (int i = 0;i < n;i++) { client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.exceptionHandler(this::fail); resp.bodyHandler(body -> { complete(); }); })); } await(); } }
client = vertx.createHttpClient(createBaseClientOptions().setTryUseCompression(true)); client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.exceptionHandler(err -> { if (exceptionCount.incrementAndGet() == 1) { if (err instanceof Http2Exception) {
@Test public void testTrailers() throws Exception { server.requestHandler(req -> { HttpServerResponse resp = req.response(); resp.setChunked(true); resp.write("some-content"); resp.putTrailer("Foo", "foo_value"); resp.putTrailer("bar", "bar_value"); resp.putTrailer("juu", (List<String>)Arrays.asList("juu_value_1", "juu_value_2")); resp.end(); }); startServer(); client.getNow(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepeth", onSuccess(resp -> { assertEquals(null, resp.getTrailer("foo")); resp.exceptionHandler(this::fail); resp.endHandler(v -> { assertEquals("foo_value", resp.getTrailer("foo")); assertEquals("foo_value", resp.getTrailer("Foo")); assertEquals("bar_value", resp.getTrailer("bar")); assertEquals(2, resp.trailers().getAll("juu").size()); assertEquals("juu_value_1", resp.trailers().getAll("juu").get(0)); assertEquals("juu_value_2", resp.trailers().getAll("juu").get(1)); testComplete(); }); })); await(); }
.setDefaultHost("localhost")); client.get("/somepath", onSuccess(resp1 -> { resp1.exceptionHandler(this::fail); resp1.endHandler(v1 -> { vertx.setTimer(10, id1 -> { client.get("/somepath", onSuccess(resp2 -> { resp2.exceptionHandler(this::fail); resp2.endHandler(v2 -> { testComplete();
@Test public void testServerResetClientStreamDuringResponse() throws Exception { waitFor(2); String chunk = TestUtils.randomAlphaString(1024); Future<Void> doReset = Future.future(); server.requestHandler(req -> { doReset.setHandler(onSuccess(v -> { req.response().reset(8); })); req.response().setChunked(true).write(Buffer.buffer(chunk)); }); startServer(); Context ctx = vertx.getOrCreateContext(); Handler<Throwable> resetHandler = err -> { assertOnIOContext(ctx); assertTrue(err instanceof StreamResetException); StreamResetException reset = (StreamResetException) err; assertEquals(8, reset.getCode()); complete(); }; ctx.runOnContext(v -> { client.post(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> { resp.exceptionHandler(resetHandler); resp.handler(buff -> { doReset.complete(); }); })).exceptionHandler(resetHandler).setChunked(true).write(chunk); }); await(); }
ctx.runOnContext(v1 -> { HttpClientRequest req = client.get("/somepath", onSuccess(resp -> { resp.exceptionHandler(err -> { assertSame(ctx, Vertx.currentContext()); assertOnIOContext(ctx);