@Test public void testPutHeaderReplacesPreviousHeaders() throws Exception { server.requestHandler(req -> req.response() .putHeader("Location", "http://example1.org") .putHeader("location", "http://example2.org") .end()); server.listen(onSuccess(server -> { client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertEquals(singletonList("http://example2.org"), resp.headers().getAll("LocatioN")); testComplete(); })).end(); })); await(); }
@Test public void testBeginPipelinedRequestByResponseSentBeforeRequestCompletion() throws Exception { server.requestHandler(req -> { if (req.method() == HttpMethod.POST) { req.pause(); vertx.setTimer(100, id1 -> { req.response().end(); vertx.setTimer(100, id2 -> { req.resume(); }); }); } else if (req.method() == HttpMethod.GET) { req.response().end(); } }); startServer(); client.close(); client = vertx.createHttpClient(new HttpClientOptions().setPipelining(true).setMaxPoolSize(1).setKeepAlive(true)); client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", resp -> { }).end(TestUtils.randomAlphaString(1024)); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", resp -> { testComplete(); }); await(); }
@Test public void testServerResponseWriteBufferFromOtherThread() throws Exception { server.requestHandler(req -> { runAsync(() -> { req.response().write("hello ").end("world"); }); }).listen(onSuccess(v -> { client.get(8080, "localhost", "/somepath", onSuccess(resp -> { assertEquals(200, resp.statusCode()); resp.bodyHandler(buff -> { assertEquals(Buffer.buffer("hello world"), buff); testComplete(); }); })).exceptionHandler(this::fail).end(); })); await(); }
private void testHttpClientResponsePause(Handler<HttpClientResponse> h) throws Exception { server.requestHandler(req -> req.response().end("ok")); startServer(); client.close(); client = vertx.createHttpClient(new HttpClientOptions().setMaxPoolSize(1).setKeepAlive(true)); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp1 -> { h.handle(resp1); vertx.setTimer(10, timerId -> { // The connection should be resumed as it's ended client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp2 -> { assertSame(resp1.request().connection(), resp2.request().connection()); resp2.endHandler(v -> testComplete()); })); }); })); await(); }
private void testClientConnectionHandler(boolean local, boolean global) throws Exception { server.requestHandler(req -> { req.response().end(); }); CountDownLatch listenLatch = new CountDownLatch(1); server.listen(onSuccess(s -> listenLatch.countDown())); awaitLatch(listenLatch); AtomicInteger status = new AtomicInteger(); Handler<HttpConnection> handler = conn -> status.getAndIncrement(); if (global) { client.connectionHandler(handler); } HttpClientRequest req = client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", resp -> { assertEquals((local ? 1 : 0) + (global ? 1 : 0), status.getAndIncrement()); testComplete(); }); if (local) { req.connectionHandler(handler); } req.end(); await(); }
@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 testServerActualPortWhenSet() { server .requestHandler(request -> { request.response().end("hello"); }) .listen(ar -> { assertEquals(ar.result().actualPort(), DEFAULT_HTTP_PORT); vertx.createHttpClient(createBaseClientOptions()).getNow(ar.result().actualPort(), DEFAULT_HTTP_HOST, "/", onSuccess(response -> { assertEquals(response.statusCode(), 200); response.bodyHandler(body -> { assertEquals(body.toString("UTF-8"), "hello"); testComplete(); }); })); }); await(); }
Context ctx = contextFactory.apply(vertx); ctx.runOnContext(v1 -> { HttpServer server = vertx.createHttpServer().requestHandler(req -> { HttpServerResponse response = req.response(); response.setStatusCode(200).setChunked(true).write("bye").end(); response.close(); }); server.listen(8080, "localhost", onSuccess(s -> { expectedThread.set(Thread.currentThread()); expectedContext.set(Vertx.currentContext()); latch.countDown(); })); }); awaitLatch(latch); HttpClient client = vertx.createHttpClient(); client.put(8080, "localhost", "/", onSuccess(resp -> { resp.netSocket().closeHandler(v -> { vertx.close(v4 -> { assertTrue(requestBeginCalled.get()); }); }); })).exceptionHandler(err -> { fail(err.getMessage()); }).setChunked(true).write(Buffer.buffer("hello")).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(); }
ctx.runOnContext(v1 -> { expectedThread.set(Thread.currentThread()); expectedContext.set(Vertx.currentContext()); HttpClient client = vertx.createHttpClient(); checker.accept(expectedThread.get(), expectedContext.get()); HttpClientRequest req = client.put(8080, "localhost", "/"); req.handler(resp -> { executeInVanillaThread(() -> { client.close(); vertx.close(v2 -> { assertTrue(requestBeginCalled.get()); }); }); req.setChunked(true).write("hello"); req.end(); });
@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(); }
@Test public void testSendFileFromClasspath() { vertx.createHttpServer(new HttpServerOptions().setPort(8080)).requestHandler(res -> { res.response().sendFile(webRoot + "/somefile.html"); }).listen(onSuccess(res -> { vertx.createHttpClient(new HttpClientOptions()).request(HttpMethod.GET, 8080, "localhost", "/", onSuccess(resp -> { resp.bodyHandler(buff -> { assertTrue(buff.toString().startsWith("<html><body>blah</body></html>")); testComplete(); }); })).end(); })); await(); }
private void testFollowRedirectWithBody(Function<Buffer, Buffer> translator) throws Exception { Buffer expected = TestUtils.randomBuffer(2048); AtomicBoolean redirected = new AtomicBoolean(); server.requestHandler(req -> { if (redirected.compareAndSet(false, true)) { assertEquals(HttpMethod.PUT, req.method()); req.bodyHandler(body -> { assertEquals(body, expected); String scheme = createBaseServerOptions().isSsl() ? "https" : "http"; req.response().setStatusCode(303).putHeader(HttpHeaders.LOCATION, scheme + "://localhost:8080/whatever").end(); }); } else { assertEquals(HttpMethod.GET, req.method()); req.response().end(); } }); startServer(); client.put(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> { assertEquals(200, resp.statusCode()); testComplete(); })).setFollowRedirects(true).end(translator.apply(expected)); await(); }
@Override public void start() throws Exception { assertTrue(Vertx.currentContext().isWorkerContext()); assertTrue(Context.isOnWorkerThread()); HttpServer server1 = vertx.createHttpServer(new HttpServerOptions() .setHost(HttpTestBase.DEFAULT_HTTP_HOST).setPort(HttpTestBase.DEFAULT_HTTP_PORT)); server1.requestHandler(req -> { assertTrue(Vertx.currentContext().isWorkerContext()); assertTrue(Context.isOnWorkerThread()); Buffer buf = Buffer.buffer(); req.handler(buf::appendBuffer); req.endHandler(v -> { assertEquals("hello", buf.toString()); req.response().end("bye"); }); }).listen(onSuccess(s -> { client.put(HttpTestBase.DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/blah", onSuccess(resp -> { assertEquals(200, resp.statusCode()); resp.handler(buf -> { assertEquals("bye", buf.toString()); resp.endHandler(v -> { testComplete(); }); }); })).setChunked(true).write(Buffer.buffer("hello")).end(); }));
req.endHandler(v -> { assertEquals(expected, body); }); startServer(); AtomicBoolean called = new AtomicBoolean(); HttpClientRequest req = client.put(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", ar -> { assertEquals(expectFail, ar.failed()); if (ar.succeeded()) { HttpClientResponse resp = ar.result(); assertEquals(200, resp.statusCode()); testComplete(); } else { }).setFollowRedirects(true) .setChunked(true) .write(buff1); awaitLatch(latch);
@Test public void testFollowRedirectSendHeadThenBody() throws Exception { Buffer expected = Buffer.buffer(TestUtils.randomAlphaString(2048)); AtomicBoolean redirected = new AtomicBoolean(); server.requestHandler(req -> { if (redirected.compareAndSet(false, true)) { assertEquals(HttpMethod.PUT, req.method()); req.bodyHandler(body -> { assertEquals(body, expected); req.response().setStatusCode(303).putHeader(HttpHeaders.LOCATION, "/whatever").end(); }); } else { assertEquals(HttpMethod.GET, req.method()); req.response().end(); } }); startServer(); HttpClientRequest req = client.put(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> { assertEquals(200, resp.statusCode()); testComplete(); })).setFollowRedirects(true); req.putHeader("Content-Length", "" + expected.length()); req.exceptionHandler(this::fail); req.sendHead(v -> { req.end(expected); }); await(); }
@Test public void testHandleInvalid204Response() throws Exception { int numReq = 3; waitFor(numReq); client.close(); client = vertx.createHttpClient(new HttpClientOptions().setPipelining(true).setKeepAlive(true).setMaxPoolSize(1)); server.requestHandler(r -> { // Generate an invalid response for the pipe-lined r.response().setChunked(true).setStatusCode(204).end(); }).listen(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(v1 -> { for (int i = 0;i < numReq;i++) { AtomicInteger count = new AtomicInteger(); HttpClientRequest post = client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(r -> { r.endHandler(v2 -> { complete(); }); })).exceptionHandler(err -> { if (count.incrementAndGet() == 1) { complete(); } }); post.end(); } })); await(); }
@Test public void testPausedHttpServerRequestDuringLastChunkEndsTheRequest() throws Exception { server.requestHandler(req -> { req.handler(buff -> { assertEquals("small", buff.toString()); req.pause(); }); req.endHandler(v -> { req.response().end(); }); }); startServer(); client.close(); client = vertx.createHttpClient(createBaseClientOptions().setMaxPoolSize(1)); client.put(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/someuri", resp -> { complete(); }).end("small"); await(); }
@Test public void testServerWebsocketIdleTimeout() { server.close(); server = vertx.createHttpServer(new HttpServerOptions().setIdleTimeout(1).setPort(DEFAULT_HTTP_PORT).setHost(DEFAULT_HTTP_HOST)); server.websocketHandler(ws -> {}).listen(ar -> { assertTrue(ar.succeeded()); client.websocket(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", ws -> { ws.closeHandler(v -> testComplete()); }); }); 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(); }