void clientCloseHandlers(boolean closeFromClient) { client.connect(testAddress, onSuccess(so -> { AtomicInteger counter = new AtomicInteger(0); so.endHandler(v -> assertEquals(1, counter.incrementAndGet())); so.closeHandler(v -> { assertEquals(2, counter.incrementAndGet()); testComplete(); }); if (closeFromClient) { so.close(); } })); }
void serverCloseHandlers(boolean closeFromServer, Handler<AsyncResult<NetServer>> listenHandler) { server.connectHandler((sock) -> { AtomicInteger counter = new AtomicInteger(0); sock.endHandler(v -> assertEquals(1, counter.incrementAndGet())); sock.closeHandler(v -> { assertEquals(2, counter.incrementAndGet()); testComplete(); }); if (closeFromServer) { sock.close(); } }).listen(testAddress, listenHandler); }
@Test public void testConnectInvalidHost() { assertNullPointerException(() -> client.connect(80, null, res -> {})); client.connect(1234, "127.0.0.2", res -> { assertTrue(res.failed()); assertFalse(res.succeeded()); assertNotNull(res.cause()); testComplete(); }); await(); }
@Test public void testConnectInvalidPort() { assertIllegalArgumentException(() -> client.connect(-1, "localhost", res -> {})); assertIllegalArgumentException(() -> client.connect(65536, "localhost", res -> {})); client.connect(9998, "localhost", res -> { assertTrue(res.failed()); assertFalse(res.succeeded()); assertNotNull(res.cause()); testComplete(); }); await(); }
@Test public void testListenInvalidPort() { /* Port 80 is free to use by any application on Windows, so this test fails. */ Assume.assumeFalse(System.getProperty("os.name").startsWith("Windows")); server.close(); server = vertx.createNetServer(new NetServerOptions().setPort(80)); server.connectHandler((netSocket) -> { }).listen(ar -> { assertTrue(ar.failed()); assertFalse(ar.succeeded()); assertNotNull(ar.cause()); testComplete(); }); await(); }
@Test public void testReconnectAttemptsNotEnough() { client.close(); client = vertx.createNetClient(new NetClientOptions().setReconnectAttempts(100).setReconnectInterval(10)); client.connect(testAddress, (res) -> { assertFalse(res.succeeded()); assertTrue(res.failed()); testComplete(); }); await(); }
@Test public void testListenInvalidHost() { server.close(); server = vertx.createNetServer(new NetServerOptions().setPort(1234).setHost("uhqwduhqwudhqwuidhqwiudhqwudqwiuhd")); server.connectHandler(netSocket -> { }).listen(ar -> { assertTrue(ar.failed()); assertFalse(ar.succeeded()); assertNotNull(ar.cause()); testComplete(); }); await(); }
@Test public void testListenTwice2() { server.connectHandler(sock -> { }); server.listen(testAddress, ar -> { assertTrue(ar.succeeded()); try { server.listen(testAddress, sock -> { }); fail("Should throw exception"); } catch (IllegalStateException e) { // OK } testComplete(); }); await(); }
@Test public void testListenOnWildcardPort() { server.close(); server = vertx.createNetServer(new NetServerOptions().setPort(0)); server.connectHandler((netSocket) -> { }).listen(ar -> { assertFalse(ar.failed()); assertTrue(ar.succeeded()); assertNull(ar.cause()); assertTrue(server.actualPort() > 1024); assertEquals(server, ar.result()); testComplete(); }); await(); }
@Test public void testSetHandlerAfterListen2() { server.connectHandler(sock -> { }); server.listen(testAddress, ar -> { assertTrue(ar.succeeded()); try { server.connectHandler(sock -> { }); fail("Should throw exception"); } catch (IllegalStateException e) { // OK } testComplete(); }); await(); }
@Test public void testListenTwice() { server.connectHandler(sock -> { }); server.listen(testAddress, onSuccess(s -> { try { server.listen(testAddress, res -> {}); fail("Should throw exception"); } catch (IllegalStateException e) { // OK testComplete(); } catch (Exception e) { fail(e.getMessage()); } })); await(); }
@Test public void testServerIdleTimeout() { server.close(); NetServerOptions netServerOptions = new NetServerOptions(); netServerOptions.setIdleTimeout(1000); netServerOptions.setIdleTimeoutUnit(TimeUnit.MILLISECONDS); server = vertx.createNetServer(netServerOptions); server.connectHandler(s -> {}).listen(testAddress, ar -> { assertTrue(ar.succeeded()); client.connect(testAddress, res -> { assertTrue(res.succeeded()); NetSocket socket = res.result(); socket.closeHandler(v -> testComplete()); }); }); await(); }
@Test public void testClientOptionsCopiedBeforeUse() { client.close(); NetClientOptions options = new NetClientOptions(); client = vertx.createNetClient(options); options.setSsl(true); // Now change something - but server should ignore this server.connectHandler(sock -> { testComplete(); }); server.listen(1234, "localhost", ar -> { assertTrue(ar.succeeded()); client.connect(1234, "localhost", ar2 -> { assertTrue(ar2.succeeded()); }); }); await(); }
@Test public void testSetHandlerAfterListen() { server.connectHandler(sock -> { }); server.listen(testAddress, onSuccess(v -> testComplete())); try { server.connectHandler(sock -> { }); fail("Should throw exception"); } catch (IllegalStateException e) { // OK } await(); }
@Test public void testListenOnPortNoHandler() { server.connectHandler(NetSocket::close); server.listen(1234, onSuccess(ns -> { client.connect(1234, "localhost", onSuccess(so -> { so.closeHandler(v -> { testComplete(); }); })); })); await(); }
@Test public void testListen() { server.connectHandler(NetSocket::close); server.listen(testAddress, onSuccess(ns -> { client.connect(testAddress, onSuccess(so -> { so.closeHandler(v -> { testComplete(); }); })); })); await(); }
private void reconnectAttempts(int attempts) { client.close(); client = vertx.createNetClient(new NetClientOptions().setReconnectAttempts(attempts).setReconnectInterval(10)); //The server delays starting for a a few seconds, but it should still connect client.connect(testAddress, onSuccess(so -> testComplete())); // Start the server after a delay vertx.setTimer(2000, id -> startEchoServer(testAddress, s -> {})); await(); }
private TestLoggerFactory testLogging() throws Exception { return TestUtils.testLogging(() -> { server.connectHandler(so -> { so.write("fizzbuzz").end(); }); server.listen(testAddress, onSuccess(v1 -> { client.connect(testAddress, onSuccess(so -> { so.closeHandler(v2 -> testComplete()); })); })); await(); }); }
@Test public void testRemoteAddress() { server.connectHandler(socket -> { SocketAddress addr = socket.remoteAddress(); assertEquals("127.0.0.1", addr.host()); socket.close(); }).listen(1234, "localhost", ar -> { assertTrue(ar.succeeded()); vertx.createNetClient(new NetClientOptions()).connect(1234, "localhost", onSuccess(socket -> { SocketAddress addr = socket.remoteAddress(); assertEquals("127.0.0.1", addr.host()); assertEquals(addr.port(), 1234); socket.closeHandler(v -> testComplete()); })); }); await(); }
@Test public void testCloseCompletionHandlerNotCalledWhenActualServerFailed() { server.close(); server = vertx.createNetServer( new NetServerOptions() .setSsl(true) .setPemKeyCertOptions(new PemKeyCertOptions().setKeyPath("invalid"))) .connectHandler(c -> { }); try { server.listen(10000, r -> fail()); } catch (Exception ignore) { // Expected } server.close(onSuccess(v -> { testComplete(); })); await(); }