@Test public void testListenWithNoHandler() { try { server.listen(testAddress); fail("Should throw exception"); } catch (IllegalStateException e) { // OK } }
@Test public void testListenWithNoHandler2() { try { server.listen(testAddress, ar -> { assertFalse(ar.succeeded()); }); fail("Should throw exception"); } catch (IllegalStateException e) { // OK } }
@Test public void testAttemptConnectAfterClose() { client.close(); try { client.connect(testAddress, ar -> { }); fail("Should throw exception"); } catch (IllegalStateException e) { //OK } }
void testEcho(Consumer<NetSocket> writer, Consumer<Buffer> dataChecker, int length) { Handler<AsyncResult<NetSocket>> clientHandler = (asyncResult) -> { if (asyncResult.succeeded()) { NetSocket sock = asyncResult.result(); Buffer buff = Buffer.buffer(); sock.handler((buffer) -> { buff.appendBuffer(buffer); if (buff.length() == length) { dataChecker.accept(buff); testComplete(); } if (buff.length() > length) { fail("Too many bytes received"); } }); writer.accept(sock); } else { fail("failed to connect"); } }; startEchoServer(testAddress, s -> client.connect(testAddress, clientHandler)); await(); }
@Test public void testSharedServersRoundRobinButFirstStartAndStopServer() throws Exception { // Start and stop a server on the same port/host before hand to make sure it doesn't interact server.close(); CountDownLatch latch = new CountDownLatch(1); server = vertx.createNetServer(); server.connectHandler(sock -> { fail("Should not connect"); }).listen(testAddress, ar -> { if (ar.succeeded()) { latch.countDown(); } else { fail("Failed to bind server"); } }); awaitLatch(latch); CountDownLatch closeLatch = new CountDownLatch(1); server.close(ar -> { assertTrue(ar.succeeded()); closeLatch.countDown(); }); assertTrue(closeLatch.await(10, TimeUnit.SECONDS)); testSharedServersRoundRobin(); }
@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 testSharedServersRoundRobinWithOtherServerRunningOnDifferentPort() throws Exception { CountDownLatch latch = new CountDownLatch(1); // Have a server running on a different port to make sure it doesn't interact server.close(); server = vertx.createNetServer(new NetServerOptions().setPort(4321)); server.connectHandler(sock -> { fail("Should not connect"); }).listen(ar2 -> { if (ar2.succeeded()) { latch.countDown(); } else { fail("Failed to bind server"); } }); awaitLatch(latch); testSharedServersRoundRobin(); }
@Test public void testClosingVertxCloseSharedServers() throws Exception { int numServers = 2; Vertx vertx = Vertx.vertx(getOptions()); List<NetServerImpl> servers = new ArrayList<>(); for (int i = 0;i < numServers;i++) { NetServer server = vertx.createNetServer().connectHandler(so -> { fail(); }); startServer(server); servers.add((NetServerImpl) server); } CountDownLatch latch = new CountDownLatch(1); vertx.close(onSuccess(v -> { latch.countDown(); })); awaitLatch(latch); servers.forEach(server -> { assertTrue(server.isClosed()); }); }
@Test public void testSendFileDirectory() throws Exception { File fDir = testFolder.newFolder(); server.connectHandler(socket -> { socket.handler(buff -> { fail("Should not receive any data"); }); }).listen(testAddress, ar -> { assertTrue(ar.succeeded()); client.connect(testAddress, result -> { assertTrue(result.succeeded()); NetSocket socket = result.result(); try { socket.sendFile(fDir.getAbsolutePath().toString()); // should throw exception and never hit the assert fail("Should throw exception"); } catch (IllegalArgumentException e) { 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 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(); }
awaitLatch(latch2); } catch (InterruptedException e) { fail(e.getMessage()); return;
@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 testTLSHostnameCertCheckIncorrect() { server.close(); server = vertx.createNetServer(new NetServerOptions().setSsl(true).setPort(4043) .setKeyCertOptions(Cert.SERVER_JKS_ROOT_CA.get())); server.connectHandler(netSocket -> netSocket.close()).listen(ar -> { NetClientOptions options = new NetClientOptions() .setHostnameVerificationAlgorithm("HTTPS") .setTrustOptions(Trust.SERVER_JKS_ROOT_CA.get()); NetClient client = vertx.createNetClient(options); client.connect(4043, "127.0.0.1", arSocket -> { if (arSocket.succeeded()) { NetSocket ns = arSocket.result(); ns.closeHandler(v -> { testComplete(); }); ns.upgradeToSsl(v -> { fail("this test should fail"); }); } else { fail(ar.cause()); } }); }); await(); }
@Test public void testTLSHostnameCertCheckCorrect() { server.close(); server = vertx.createNetServer(new NetServerOptions().setSsl(true).setPort(4043) .setKeyCertOptions(Cert.SERVER_JKS_ROOT_CA.get())); server.connectHandler(netSocket -> netSocket.close()).listen(ar -> { NetClientOptions options = new NetClientOptions() .setHostnameVerificationAlgorithm("HTTPS") .setTrustOptions(Trust.SERVER_JKS_ROOT_CA.get()); NetClient client = vertx.createNetClient(options); client.connect(4043, "localhost", arSocket -> { if (arSocket.succeeded()) { NetSocket ns = arSocket.result(); ns.exceptionHandler(th -> { fail(th); }); ns.upgradeToSsl(v -> { testComplete(); }); } else { fail(ar.cause()); } }); }); await(); }
ChannelPipeline pipeline = chctx.pipeline(); pipeline.addBefore("handler", "http", new HttpServerCodec()); internal.handler(buff -> fail()); internal.messageHandler(obj -> { if (obj instanceof LastHttpContent) {
server.connectHandler(so -> { NetSocketInternal soi = (NetSocketInternal) so; soi.messageHandler(msg -> fail("Unexpected")); soi.handler(msg -> { ByteBuf byteBuf = msg.getByteBuf(); NetSocketInternal soi = (NetSocketInternal) so; soi.write(Buffer.buffer("Hello World")); soi.messageHandler(msg -> fail("Unexpected")); soi.handler(msg -> { ByteBuf byteBuf = msg.getByteBuf();
@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(); }
NetSocket ns = ar2.result(); ns.exceptionHandler(th -> { fail(th); }); ns.upgradeToSsl(v2 -> {