@Test public void testSetHandlersAfterListening() throws Exception { server.requestHandler(noOpHandler()); server.listen(onSuccess(s -> { assertIllegalStateException(() -> server.requestHandler(noOpHandler())); assertIllegalStateException(() -> server.websocketHandler(noOpHandler())); testComplete(); })); await(); }
@Test public void testSetHandlersAfterListening2() throws Exception { server.requestHandler(noOpHandler()); server.listen(onSuccess(v -> testComplete())); assertIllegalStateException(() -> server.requestHandler(noOpHandler())); assertIllegalStateException(() -> server.websocketHandler(noOpHandler())); await(); }
@Test public void testListenTwice() throws Exception { server.requestHandler(noOpHandler()); server.listen(onSuccess(v -> testComplete())); assertIllegalStateException(() -> server.listen()); await(); }
@Test public void testListenTwice2() throws Exception { server.requestHandler(noOpHandler()); server.listen(ar -> { assertTrue(ar.succeeded()); assertIllegalStateException(() -> server.listen()); testComplete(); }); await(); }
@Test public void testListenInvalidPort() throws Exception { /* Port 7 is free for use by any application in Windows, so this test fails. */ Assume.assumeFalse(System.getProperty("os.name").startsWith("Windows")); server.close(); server = vertx.createHttpServer(new HttpServerOptions().setPort(7)); server.requestHandler(noOpHandler()).listen(onFailure(server -> testComplete())); await(); }
@Test public void testListenInvalidHost() { server.close(); server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT).setHost("iqwjdoqiwjdoiqwdiojwd")); server.requestHandler(noOpHandler()); server.listen(onFailure(s -> testComplete())); }
@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 testRequestTimeoutCanceledWhenRequestEndsNormally() { server.requestHandler(req -> req.response().end()); server.listen(onSuccess(s -> { AtomicReference<Throwable> exception = new AtomicReference<>(); // There is no server running, should fail to connect HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler()); req.exceptionHandler(exception::set); req.setTimeout(500); req.end(); vertx.setTimer(1000, id -> { assertNull("Did not expect any exception", exception.get()); testComplete(); }); })); await(); }
@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(); }
private void testRequestBodyStringAtEnd(String encoding) { String body = TestUtils.randomUnicodeString(1000); Buffer bodyBuff; if (encoding == null) { bodyBuff = Buffer.buffer(body); } else { bodyBuff = Buffer.buffer(body, encoding); } server.requestHandler(req -> { req.bodyHandler(buffer -> { assertEquals(bodyBuff, buffer); testComplete(); }); }); server.listen(onSuccess(server -> { HttpClientRequest req = client.request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler()); if (encoding == null) { req.end(body); } else { req.end(body, encoding); } })); await(); }
@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 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(); }
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")); }
private void testRequestBodyWriteString(boolean chunked, String encoding) { String body = TestUtils.randomUnicodeString(1000); Buffer bodyBuff; if (encoding == null) { bodyBuff = Buffer.buffer(body); } else { bodyBuff = Buffer.buffer(body, encoding); } server.requestHandler(req -> { req.bodyHandler(buff -> { assertEquals(bodyBuff, buff); testComplete(); }); }); server.listen(onSuccess(server -> { HttpClientRequest req = client.request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler()); if (chunked) { req.setChunked(true); } else { req.headers().set("Content-Length", String.valueOf(bodyBuff.length())); } if (encoding == null) { req.write(body); } else { req.write(body, encoding); } req.end(); })); await(); }
@Test public void testRequestWrite() { int times = 3; Buffer chunk = TestUtils.randomBuffer(1000); server.requestHandler(req -> { req.bodyHandler(buff -> { Buffer expected = Buffer.buffer(); for (int i = 0;i < times;i++) { expected.appendBuffer(chunk); } assertEquals(expected, buff); testComplete(); }); }); server.listen(onSuccess(s -> { HttpClientRequest req = client.request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler()); req.setChunked(true); int padding = 5; for (int i = 0;i < times;i++) { Buffer paddedChunk = TestUtils.leftPad(padding, chunk); assertEquals(paddedChunk.getByteBuf().readerIndex(), padding); req.write(paddedChunk); } req.end(); })); await(); }
@Test public void testClientRequestExceptionHandlerCalledWhenExceptionOnDrainHandler() { pausingServer(resumeFuture -> { HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler()); req.setChunked(true); assertFalse(req.writeQueueFull()); req.setWriteQueueMaxSize(1000); Buffer buff = TestUtils.randomBuffer(10000); AtomicBoolean failed = new AtomicBoolean(); vertx.setPeriodic(1, id -> { req.write(buff); if (req.writeQueueFull()) { vertx.cancelTimer(id); req.drainHandler(v -> { throw new RuntimeException("error"); }) .exceptionHandler(t -> { // Called a second times when testComplete is called and close the http client if (failed.compareAndSet(false, true)) { testComplete(); } }); // Tell the server to resume resumeFuture.complete(); } }); }); await(); }
@Test public void testUseRequestAfterComplete() { server.requestHandler(noOpHandler()); server.listen(onSuccess(server -> { HttpClientRequest req = client.request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler()); req.end(); Buffer buff = Buffer.buffer(); assertIllegalStateException(() -> req.end()); assertIllegalStateException(() -> req.continueHandler(noOpHandler())); assertIllegalStateException(() -> req.drainHandler(noOpHandler())); assertIllegalStateException(() -> req.end("foo")); assertIllegalStateException(() -> req.end(buff)); assertIllegalStateException(() -> req.end("foo", "UTF-8")); assertIllegalStateException(() -> req.sendHead()); assertIllegalStateException(() -> req.setChunked(false)); assertIllegalStateException(() -> req.setWriteQueueMaxSize(123)); assertIllegalStateException(() -> req.write(buff)); assertIllegalStateException(() -> req.write("foo")); assertIllegalStateException(() -> req.write("foo", "UTF-8")); assertIllegalStateException(() -> req.write(buff)); assertIllegalStateException(() -> req.writeQueueFull()); testComplete(); })); 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 testClientDrainHandler() { pausingServer(resumeFuture -> { HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler()); req.setChunked(true); assertFalse(req.writeQueueFull()); req.setWriteQueueMaxSize(1000); Buffer buff = TestUtils.randomBuffer(10000); vertx.setPeriodic(1, id -> { req.write(buff); if (req.writeQueueFull()) { vertx.cancelTimer(id); req.drainHandler(v -> { assertFalse(req.writeQueueFull()); testComplete(); }); // Tell the server to resume resumeFuture.complete(); } }); }); await(); }
@Test public void testClientRequestArguments() throws Exception { HttpClientRequest req = client.request(HttpMethod.PUT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler()); assertNullPointerException(() -> req.putHeader((String) null, "someValue")); assertNullPointerException(() -> req.putHeader((CharSequence) null, "someValue")); assertNullPointerException(() -> req.putHeader("someKey", (Iterable<String>) null)); assertNullPointerException(() -> req.write((Buffer) null)); assertNullPointerException(() -> req.write((String) null)); assertNullPointerException(() -> req.write(null, "UTF-8")); assertNullPointerException(() -> req.write("someString", null)); assertNullPointerException(() -> req.end((Buffer) null)); assertNullPointerException(() -> req.end((String) null)); assertNullPointerException(() -> req.end(null, "UTF-8")); assertNullPointerException(() -> req.end("someString", null)); assertIllegalArgumentException(() -> req.setTimeout(0)); }