@Test public void testHttpClientResponseThrowsExceptionInChunkHandler() throws Exception { testHttpClientResponseThrowsExceptionInHandler("blah", (resp, latch) -> { resp.handler(chunk -> { latch.countDown(); throw new RuntimeException(); }); }); }
@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 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 testHttp() throws Exception { HttpClient client = vertx.createHttpClient(); HttpServer server = vertx.createHttpServer().requestHandler(req -> { req.response().end("foo"); }); try { CountDownLatch listenLatch = new CountDownLatch(1); server.listen(8080, "vertx.io", onSuccess(s -> { listenLatch.countDown(); })); awaitLatch(listenLatch); client.getNow(8080, "vertx.io", "/somepath", onSuccess(resp -> { Buffer buffer = Buffer.buffer(); resp.handler(buffer::appendBuffer); resp.endHandler(v -> { assertEquals(Buffer.buffer("foo"), buffer); testComplete(); }); })); await(); } finally { client.close(); server.close(); } }
Buffer body = Buffer.buffer(); Thread t = Thread.currentThread(); resp.handler(buff -> { assertSame(t, Thread.currentThread()); resumes.get(idx).complete(null);
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 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 testResponseBody(String expected) throws Exception { server.requestHandler(req -> { HttpServerResponse resp = req.response(); resp.end(expected); }); startServer(); client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> { AtomicInteger count = new AtomicInteger(); Buffer content = Buffer.buffer(); resp.handler(buff -> { content.appendBuffer(buff); count.incrementAndGet(); }); resp.endHandler(v -> { assertTrue(count.get() > 0); assertEquals(expected, content.toString()); testComplete(); }); })) .exceptionHandler(err -> fail()) .end(); await(); }
HttpClientRequest clientRequest = httpClient.get(10000, "localhost", "/", onSuccess(resp -> { resp.handler(b -> { readBuffer.appendBuffer(b); for (int i = 0; i < 64; i++) {
@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(); }
resp.pause(); paused.set(true); resp.handler(chunk -> { if (paused.get()) { fail("Shouldn't receive chunks when paused");
assertEquals(200, resp.statusCode()); Buffer content = Buffer.buffer(); resp.handler(content::appendBuffer); resp.endHandler(v -> { complete();
long now = System.currentTimeMillis(); int[] length = {0}; resp.handler(buff -> { length[0] += buff.length(); resp.pause();
resp.handler(buffer -> {
@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(); }
assertTrue(Vertx.currentContext().isWorkerContext()); assertTrue(Context.isOnWorkerThread()); resp.handler(buf -> { assertEquals("bye", buf.toString()); resp.endHandler(v -> {
@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(); }
client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> { Buffer content = Buffer.buffer(); resp.handler(content::appendBuffer); resp.endHandler(v -> { assertEquals(expected, content.toString());
@Test public void testResetActivePushPromise() throws Exception { server.requestHandler(req -> { req.response().push(HttpMethod.GET, "/wibble", ar -> { assertTrue(ar.succeeded()); HttpServerResponse response = ar.result(); response.exceptionHandler(err -> { if (err instanceof StreamResetException) { assertEquals(Http2Error.CANCEL.code(), ((StreamResetException) err).getCode()); testComplete(); } }); response.setChunked(true).write("some_content"); }); }); startServer(); HttpClientRequest req = client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onFailure(resp -> { })); req.pushHandler(pushedReq -> { pushedReq.handler(onSuccess(pushedResp -> { pushedResp.handler(buff -> { pushedReq.reset(Http2Error.CANCEL.code()); }); })); }); req.end(); await(); }
@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(); }