@Test public void testClientChaining() { server.requestHandler(noOpHandler()); server.listen(onSuccess(server -> { HttpClientRequest req = client.request(HttpMethod.PUT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler()); assertTrue(req.setChunked(true) == req); assertTrue(req.sendHead() == req); assertTrue(req.write("foo", "UTF-8") == req); assertTrue(req.write("foo") == req); assertTrue(req.write(Buffer.buffer("foo")) == req); testComplete(); })); await(); }
@Test public void testListenTwice2() throws Exception { server.requestHandler(noOpHandler()); server.listen(ar -> { assertTrue(ar.succeeded()); assertIllegalStateException(() -> server.listen()); testComplete(); }); await(); }
@Test public void testServerLogging() throws Exception { server.close(); server = vertx.createHttpServer(createBaseServerOptions().setLogActivity(true)); TestLoggerFactory factory = testLogging(); if (this instanceof Http1xTest) { assertTrue(factory.hasName("io.netty.handler.logging.LoggingHandler")); } else { assertTrue(factory.hasName("io.netty.handler.codec.http2.Http2FrameLogger")); } }
@Test public void testServerChainingSendFile() throws Exception { File file = setupFile("test-server-chaining.dat", "blah"); server.requestHandler(req -> { assertTrue(req.response().sendFile(file.getAbsolutePath()) == req.response()); assertTrue(req.response().ended()); file.delete(); testComplete(); }); server.listen(onSuccess(server -> { client.request(HttpMethod.PUT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler()).end(); })); await(); }
@Test public void testClientLogging() throws Exception { client.close(); client = vertx.createHttpClient(createBaseClientOptions().setLogActivity(true)); TestLoggerFactory factory = testLogging(); if (this instanceof Http1xTest) { assertTrue(factory.hasName("io.netty.handler.logging.LoggingHandler")); } else { assertTrue(factory.hasName("io.netty.handler.codec.http2.Http2FrameLogger")); } }
@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 testRequestTimesoutWhenIndicatedPeriodExpiresWithoutAResponseFromRemoteServer() { server.requestHandler(noOpHandler()); // No response handler so timeout triggers AtomicBoolean failed = new AtomicBoolean(); server.listen(onSuccess(s -> { HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(t -> { // Catch the first, the second is going to be a connection closed exception when the // server is shutdown on testComplete if (failed.compareAndSet(false, true)) { assertTrue("Expected to end with timeout exception but ended with other exception: " + t, t instanceof TimeoutException); testComplete(); } })); req.setTimeout(1000); req.end(); })); await(); }
@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 testNoParams() { server.requestHandler(req -> { assertNull(req.query()); assertTrue(req.params().isEmpty()); req.response().end(); }); server.listen(onSuccess(server -> { client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> testComplete()).end(); })); await(); }
@Test public void testListenSocketAddress() { NetClient netClient = vertx.createNetClient(); server = vertx.createHttpServer().requestHandler(req -> req.response().end()); SocketAddress sockAddress = SocketAddress.inetSocketAddress(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST); server.listen(sockAddress, onSuccess(server -> { netClient.connect(sockAddress, onSuccess(sock -> { sock.handler(buf -> { assertTrue("Response is not an http 200", buf.toString("UTF-8").startsWith("HTTP/1.1 200 OK")); testComplete(); }); sock.write("GET / HTTP/1.1\r\n\r\n"); })); })); try { await(); } finally { netClient.close(); } }
@Test public void testRequestHeadersWithCharSequence() { HashMap<CharSequence, String> headers = new HashMap<>(); headers.put(HttpHeaders.TEXT_HTML, "text/html"); headers.put(HttpHeaders.USER_AGENT, "User-Agent"); headers.put(HttpHeaders.APPLICATION_X_WWW_FORM_URLENCODED, "application/x-www-form-urlencoded"); server.requestHandler(req -> { assertTrue(headers.size() < req.headers().size()); headers.forEach((k, v) -> assertEquals(v, req.headers().get(k))); headers.forEach((k, v) -> assertEquals(v, req.getHeader(k))); req.response().end(); }); server.listen(onSuccess(server -> { HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> testComplete()); headers.forEach((k, v) -> req.headers().add(k, v)); req.end(); })); await(); }
@Test public void testSendOpenRangeFileFromClasspath() { vertx.createHttpServer(new HttpServerOptions().setPort(8080)).requestHandler(res -> { res.response().sendFile("webroot/somefile.html", 6); }).listen(onSuccess(res -> { vertx.createHttpClient(new HttpClientOptions()).request(HttpMethod.GET, 8080, "localhost", "/", onSuccess(resp -> { resp.bodyHandler(buff -> { assertTrue(buff.toString().startsWith("<body>blah</body></html>")); testComplete(); }); })).end(); })); await(); }
@Test public void testResponseHeadersWithCharSequence() { HashMap<CharSequence, String> headers = new HashMap<>(); headers.put(HttpHeaders.TEXT_HTML, "text/html"); headers.put(HttpHeaders.USER_AGENT, "User-Agent"); headers.put(HttpHeaders.APPLICATION_X_WWW_FORM_URLENCODED, "application/x-www-form-urlencoded"); server.requestHandler(req -> { headers.forEach((k, v) -> req.response().headers().add(k, v)); req.response().end(); }); server.listen(onSuccess(server -> { client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertTrue(headers.size() < resp.headers().size()); headers.forEach((k,v) -> assertEquals(v, resp.headers().get(k))); headers.forEach((k,v) -> assertEquals(v, resp.getHeader(k))); testComplete(); })).end(); })); await(); }
@Test public void testUseResponseAfterComplete() throws Exception { server.requestHandler(req -> { HttpServerResponse resp = req.response(); assertFalse(resp.ended()); resp.end(); assertTrue(resp.ended()); checkHttpServerResponse(resp); testComplete(); }); startServer(); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler()); await(); }
@Test public void testSendFileDirectoryWithHandler() throws Exception { File dir = testFolder.newFolder(); server.requestHandler(req -> { req.response().putHeader("Content-Type", "wibble"); req.response().sendFile(dir.getAbsolutePath(), onFailure(t -> { assertTrue(t instanceof FileNotFoundException); testComplete(); })); }); server.listen(onSuccess(s -> { client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(err -> {})).end(); })); await(); }
@Test public void testServerActualPortWhenZero() { server = vertx.createHttpServer(createBaseServerOptions().setPort(0).setHost(DEFAULT_HTTP_HOST)); server .requestHandler(request -> { request.response().end("hello"); }) .listen(ar -> { assertTrue(ar.result().actualPort() != 0); 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(); }
@Test public void testServerActualPortWhenZeroPassedInListen() { server = vertx.createHttpServer(new HttpServerOptions(createBaseServerOptions()).setHost(DEFAULT_HTTP_HOST)); server .requestHandler(request -> { request.response().end("hello"); }) .listen(0, ar -> { assertTrue(ar.result().actualPort() != 0); 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(); }
@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 testSendFileNotFoundWithHandler() throws Exception { server.requestHandler(req -> { req.response().putHeader("Content-Type", "wibble"); req.response().sendFile("nosuchfile.html", onFailure(t -> { assertTrue(t instanceof FileNotFoundException); testComplete(); })); }); server.listen(onSuccess(s -> { client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(resp -> {})).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(); }