private void connectUntilWebsocketHandshakeException(HttpClient client, int count, Handler<AsyncResult<Void>> doneHandler) { vertx.runOnContext(v -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/some/path", ws -> { if (count < 100) { connectUntilWebsocketHandshakeException(client, count + 1, doneHandler); } else { doneHandler.handle(Future.failedFuture(new AssertionError())); } }, err -> { if (err instanceof WebSocketHandshakeException || err instanceof IOException) { doneHandler.handle(Future.succeededFuture()); } else if (count < 100) { connectUntilWebsocketHandshakeException(client, count + 1, doneHandler); } else { doneHandler.handle(Future.failedFuture(err)); } }); }); }
private void testServerWebsocketPingPongCheck(int maxFrameSize, Consumer<ServerWebSocket> check) { server = vertx.createHttpServer(new HttpServerOptions().setIdleTimeout(1).setPort(DEFAULT_HTTP_PORT).setHost(HttpTestBase.DEFAULT_HTTP_HOST).setMaxWebsocketFrameSize(maxFrameSize)); server.websocketHandler(ws -> { ws.pongHandler(buff -> fail()); check.accept(ws); }).listen(onSuccess(v -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> {}); })); 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(); }
private SocketMessages testWriteTextMessages(List<String> messagesToSend, WebsocketVersion version) { String path = "/some/path"; server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).websocketHandler(ws -> { for (String messageToSend : messagesToSend) { ws.writeTextMessage(messageToSend); } ws.close(); }); List<String> receivedMessages = new ArrayList<>(); List<Throwable> receivedExceptions = new ArrayList<>(); server.listen(ar -> { assertTrue(ar.succeeded()); client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, path, null, version, ws -> { ws.textMessageHandler(receivedMessages::add); ws.exceptionHandler(receivedExceptions::add); ws.closeHandler(v -> testComplete()); }); }); await(); return new SocketMessages(receivedMessages, receivedExceptions); }
@Test public void httpClientWebsocketConnectionFailureHandlerShouldBeCalled() throws Exception { int port = 7867; HttpClient client = vertx.createHttpClient(); client.websocket(port, "localhost", "", websocket -> { websocket.handler(data -> { fail("connection should not succeed"); }); }, throwable -> testComplete()); await(); }
private void testWriteMessage(int size, WebsocketVersion version) { String path = "/some/path"; byte[] expected = TestUtils.randomByteArray(size); server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).websocketHandler(ws -> { ws.writeBinaryMessage(Buffer.buffer(expected)); ws.close(); }); server.listen(ar -> { assertTrue(ar.succeeded()); client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, path, null, version, ws -> { Buffer actual = Buffer.buffer(); ws.handler(actual::appendBuffer); ws.closeHandler(v -> { assertArrayEquals(expected, actual.getBytes(0, actual.length())); testComplete(); }); }); }); await(); }
@Test public void testClientWebsocketIdleTimeout() { client.close(); client = vertx.createHttpClient(new HttpClientOptions().setIdleTimeout(1)); server.websocketHandler(ws -> {}).listen(ar -> { client.websocket(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", ws -> { ws.closeHandler(v -> testComplete()); }); }); await(); }
@Test public void testServerWebsocketPingPong() { server = vertx.createHttpServer(new HttpServerOptions().setIdleTimeout(1).setPort(DEFAULT_HTTP_PORT).setHost(HttpTestBase.DEFAULT_HTTP_HOST)); server.websocketHandler(ws -> { ws.pongHandler(buff -> { assertEquals("ping", buff.toString()); testComplete(); }); ws.writePing(Buffer.buffer("ping")); }).listen(onSuccess(v -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> {}); })); await(); }
@Test public void testClientWebsocketPingPong() { server = vertx.createHttpServer(new HttpServerOptions().setIdleTimeout(1).setPort(DEFAULT_HTTP_PORT).setHost(HttpTestBase.DEFAULT_HTTP_HOST)); server.websocketHandler(ws -> { }).listen(onSuccess(v -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> { ws.pongHandler( pong -> { assertEquals("ping", pong.toString()); testComplete(); }); ws.writePing(Buffer.buffer("ping")); }); })); await(); }
@Test public void testCloseStatusCodeFromClient() throws InterruptedException { CountDownLatch latch = new CountDownLatch(2); client = vertx.createHttpClient(); server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)) .websocketHandler(socket -> { socket.closeHandler(a -> { latch.countDown(); }); socket.frameHandler(frame -> { assertEquals(1000, frame.binaryData().getByteBuf().getShort(0)); assertEquals(1000, frame.closeStatusCode()); assertNull(frame.closeReason()); latch.countDown(); }); }) .listen(ar -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> { ws.close(); }); }); awaitLatch(latch); }
@Test public void testClientWebsocketSendPingExceeds125Bytes() { //Netty will prevent us from encoding a pingBody greater than 126 bytes by silently throwing an error in the background String pingBody = randomAlphaString(126); Integer maxFrameSize = 256; server = vertx.createHttpServer(new HttpServerOptions().setIdleTimeout(1).setPort(DEFAULT_HTTP_PORT).setHost(HttpTestBase.DEFAULT_HTTP_HOST).setMaxWebsocketFrameSize(maxFrameSize)); server.websocketHandler(ws -> { }).listen(onSuccess(v -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> { ws.pongHandler(buffer -> fail()); ws.writeFrame(WebSocketFrame.pingFrame(Buffer.buffer(pingBody))); vertx.setTimer(2000, id -> testComplete()); }); })); await(); }
@Test public void testServerWebsocketSendPingExceeds125Bytes() { //Netty will prevent us from encoding a pingBody greater than 126 bytes by silently throwing an error in the background String pingBody = randomAlphaString(126); Integer maxFrameSize = 256; server = vertx.createHttpServer(new HttpServerOptions().setIdleTimeout(1).setPort(DEFAULT_HTTP_PORT).setHost(HttpTestBase.DEFAULT_HTTP_HOST).setMaxWebsocketFrameSize(maxFrameSize)); server.websocketHandler(ws -> { ws.pongHandler(buff -> fail()); ws.writeFrame(WebSocketFrame.pingFrame(Buffer.buffer(pingBody))); vertx.setTimer(2000, id -> testComplete()); }).listen(onSuccess(v -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> {}); })); await(); }
@Test public void testCloseStatusCodeFromServer() throws InterruptedException { CountDownLatch latch = new CountDownLatch(2); client = vertx.createHttpClient(); server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)) .websocketHandler(socket -> { socket.closeHandler(a -> { latch.countDown(); }); vertx.setTimer(1000, (ar) -> socket.close()); }) .listen(ar -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> { ws.frameHandler(frame -> { assertEquals(1000, frame.binaryData().getByteBuf().getShort(0)); assertEquals(1000, frame.closeStatusCode()); assertNull(frame.closeReason()); latch.countDown(); }); }); }); awaitLatch(latch); }
@Test public void testClientWebsocketSendPongExceeds125Bytes() { //Netty will prevent us from encoding a pingBody greater than 126 bytes by silently throwing an error in the background String pingBody = randomAlphaString(126); Integer maxFrameSize = 256; server = vertx.createHttpServer(new HttpServerOptions().setIdleTimeout(1).setPort(DEFAULT_HTTP_PORT).setHost(HttpTestBase.DEFAULT_HTTP_HOST).setMaxWebsocketFrameSize(maxFrameSize)); server.websocketHandler(ws -> { ws.pongHandler(buff -> fail()); vertx.setTimer(2000, id -> testComplete()); }).listen(onSuccess(v -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> { ws.writeFrame(WebSocketFrame.pongFrame(Buffer.buffer(pingBody))); }); })); await(); }
@Test public void testServerWebsocketSendPongExceeds125Bytes() { //Netty will prevent us from encoding a pingBody greater than 126 bytes by silently throwing an error in the background String pingBody = randomAlphaString(126); Integer maxFrameSize = 256; server = vertx.createHttpServer(new HttpServerOptions().setIdleTimeout(1).setPort(DEFAULT_HTTP_PORT).setHost(HttpTestBase.DEFAULT_HTTP_HOST).setMaxWebsocketFrameSize(maxFrameSize)); server.websocketHandler(ws -> { ws.writeFrame(WebSocketFrame.pongFrame(Buffer.buffer(pingBody))); }).listen(onSuccess(v -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> { ws.pongHandler(buff -> fail()); vertx.setTimer(2000, id -> testComplete()); }); })); await(); }
@Test public void testUnmaskedFrameRequest(){ client = vertx.createHttpClient(new HttpClientOptions().setSendUnmaskedFrames(true)); server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT).setAcceptUnmaskedFrames(true)); server.requestHandler(req -> { req.response().setChunked(true).write("connect"); }); server.websocketHandler(ws -> { ws.handler(new Handler<Buffer>() { public void handle(Buffer data) { assertEquals(data.toString(), "first unmasked frame"); testComplete(); } }); }); server.listen(onSuccess(server -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> { ws.writeFinalTextFrame("first unmasked frame"); }); })); await(); }
@Test public void testInvalidUnmaskedFrameRequest(){ client = vertx.createHttpClient(new HttpClientOptions().setSendUnmaskedFrames(true)); server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)); server.requestHandler(req -> { req.response().setChunked(true).write("connect"); }); server.websocketHandler(ws -> { ws.exceptionHandler(exception -> { testComplete(); }); ws.handler(result -> { fail("Cannot decode unmasked message because I require masked frame as configured"); }); }); server.listen(onSuccess(server -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> { ws.writeFinalTextFrame("first unmasked frame"); }); })); await(); }
@Test public void testServerWebSocketShouldBeClosedWhenTheClosedHandlerIsCalled() { server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).websocketHandler(ws -> { CheckingSender sender = new CheckingSender(vertx.getOrCreateContext(), ws); sender.send(); ws.closeHandler(v -> { Throwable failure = sender.close(); if (failure != null) { fail(failure); } else { testComplete(); } }); }); server.listen(onSuccess(s -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/someuri", ws -> { vertx.setTimer(1000, id -> { ws.close(); }); }); })); await(); }
@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 testClearClientSslOptions() { SelfSignedCertificate certificate = SelfSignedCertificate.create(); HttpServerOptions serverOptions = new HttpServerOptions().setPort(HttpTestBase.DEFAULT_HTTPS_PORT) .setSsl(true) .setKeyCertOptions(certificate.keyCertOptions()); HttpClientOptions clientOptions = new HttpClientOptions() .setTrustAll(true) .setVerifyHost(false); client = vertx.createHttpClient(clientOptions); server = vertx.createHttpServer(serverOptions).websocketHandler(WebSocketBase::close).listen(onSuccess(server -> { RequestOptions requestOptions = new RequestOptions().setPort(HttpTestBase.DEFAULT_HTTPS_PORT).setSsl(true); client.websocket(requestOptions, ws -> { ws.closeHandler(v -> { testComplete(); }); }); })); await(); }