for (int i = 0; i < numConnections; i++) { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/someuri", ws -> { ws.closeHandler(v -> latchClient.countDown()); ws.close(); });
@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 testReportProtocolViolationOnClient() { server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).requestHandler(req -> { NetSocket sock = getUpgradedNetSocket(req, "/some/path"); // Let's write an invalid frame Buffer buff = Buffer.buffer(); buff.appendByte((byte)(0x8)).appendByte((byte)0); // Violates protocol with V13 (final control frame) sock.write(buff); }); server.listen(ar -> { assertTrue(ar.succeeded()); client.websocketStream(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/some/path", null, WebsocketVersion.V13). handler(ws -> { AtomicReference<Throwable> failure = new AtomicReference<>(); ws.closeHandler(v -> { assertNotNull(failure.get()); testComplete(); }); ws.exceptionHandler(failure::set); }); }); 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); }
private void testCloseCallHandlers(boolean local) { String path = "/some/path"; server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).websocketHandler(ws -> { if (!local) { ws.close(); } }); AtomicInteger doneCount = new AtomicInteger(); server.listen(ar -> { assertTrue(ar.succeeded()); client.websocketStream(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, path, null). endHandler(done -> doneCount.incrementAndGet()). handler(ws -> { assertEquals(0, doneCount.get()); boolean[] closed = new boolean[1]; ws.closeHandler(v -> { closed[0] = true; assertEquals(1, doneCount.get()); testComplete(); }); if (local) { vertx.runOnContext(v -> { ws.close(); }); } }); }); 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(); }
client.websocket(8080, "localhost", "/", ws -> { ws.handler(buf -> { ws.closeHandler(v -> { vertx.close(v4 -> { assertTrue(websocketConnected.get());
client.websocket(8080, "localhost", "/", ws -> { ws.handler(buf -> { ws.closeHandler(v2 -> { executeInVanillaThread(() -> { client.close();
ws.handler(buffer -> { assertEquals("whatever", buffer.toString("UTF-8")); ws.closeHandler(v2 -> { testComplete(); });
@Test public void testWebSocket() { server = vertx.createHttpServer(); server.websocketHandler(ws -> { ws.write(Buffer.buffer("wibble")); ws.handler(buff -> ws.close()); }); server.listen(HttpTestBase.DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, ar -> { assertTrue(ar.succeeded()); client = vertx.createHttpClient(); client.websocket(HttpTestBase.DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> { FakeHttpClientMetrics metrics = FakeMetricsBase.getMetrics(client); WebSocketMetric metric = metrics.getMetric(ws); assertNotNull(metric); assertNotNull(metric.soMetric); ws.closeHandler(closed -> { assertNull(metrics.getMetric(ws)); testComplete(); }); ws.handler(ws::write); }); }); await(); }
client = vertx.createHttpClient(); client.websocket(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/chat", ws -> { ws.closeHandler(v -> { complete(); });
@Test public void testWebsocketAbs() { 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).requestHandler(request -> { if ("/test".equals(request.path())) { request.upgrade().close(); } else { request.response().end(); } }).listen(onSuccess(server -> { String url = "wss://" + clientOptions.getDefaultHost() + ":" + HttpTestBase.DEFAULT_HTTPS_PORT + "/test"; client.websocketAbs(url, null, null, null, ws -> { ws.closeHandler(v -> { testComplete(); }); }, null); })); await(); }
@Test public void testClientWebSocketShouldBeClosedWhenTheClosedHandlerIsCalled() { server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).websocketHandler(ws -> { vertx.setTimer(1000, id -> { ws.close(); }); }); server.listen(onSuccess(s -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/someuri", ws -> { CheckingSender sender = new CheckingSender(vertx.getOrCreateContext(), ws); sender.send(); ws.closeHandler(v -> { Throwable failure = sender.close(); if (failure != null) { fail(failure); } else { 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(); }
client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/someuri", ws -> { CheckingSender sender = new CheckingSender(vertx.getOrCreateContext(), ws); ws.closeHandler(v -> sender.close()); sender.send(); });
@Test public void testConnectionClosedAfterPingTimeout() throws Exception { sockJSHandler.bridge(allAccessOptions.setPingTimeout(1000)); CountDownLatch latch = new CountDownLatch(1); long start = System.currentTimeMillis(); client.websocket(websocketURI, ws -> ws.closeHandler(v -> latch.countDown())); awaitLatch(latch); long dur = System.currentTimeMillis() - start; assertTrue(dur > 1000 && dur < 3000); }
@Test public void testHookCreateSocketRejected() throws Exception { CountDownLatch latch = new CountDownLatch(2); sockJSHandler.bridge(allAccessOptions, be -> { if (be.type() == BridgeEventType.SOCKET_CREATED) { be.complete(false); latch.countDown(); } else { be.complete(true); } }); client.websocket(websocketURI, ws -> { JsonObject msg = new JsonObject().put("type", "send").put("address", addr).put("body", "foobar"); ws.writeFrame(io.vertx.core.http.WebSocketFrame.textFrame(msg.encode(), true)); ws.closeHandler(v -> latch.countDown()); }); awaitLatch(latch); }
@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 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(); }