@Override public NetClient createNetClient() { return createNetClient(new NetClientOptions()); }
@Test public final void testAdd() { NetClientOptions options = new NetClientOptions(new JsonObject("{}")); options.addEnabledCipherSuite("XXX"); }
@Test public void testConnectError() { testConnectErrorNotifiesOnEventLoop(new NetClientOptions()); }
@Test public final void testEquals() { NetClientOptions options1 = new NetClientOptions(); NetClientOptions options2 = new NetClientOptions(new JsonObject("{}")); assertEquals(options1, options2); options1.setHostnameVerificationAlgorithm("HTTPS"); options2.setHostnameVerificationAlgorithm("HTTPS"); assertEquals(options1, options2); options2.setHostnameVerificationAlgorithm(new String("HTTPS")); assertEquals(options1, options2); }
@Test public void testDummyNetClientMetrics() { NetClient client = vertx.createNetClient(new NetClientOptions()); assertFalse(client.isMetricsEnabled()); }
ConnectionHolder(ClusteredEventBus eventBus, ServerID serverID, EventBusOptions options) { this.eventBus = eventBus; this.serverID = serverID; this.vertx = eventBus.vertx(); this.metrics = eventBus.getMetrics(); NetClientOptions clientOptions = new NetClientOptions(options.toJson()); ClusteredEventBus.setCertOptions(clientOptions, options.getKeyCertOptions()); ClusteredEventBus.setTrustOptions(clientOptions, options.getTrustOptions()); client = new NetClientImpl(eventBus.vertx(), clientOptions, false); }
@Test public void testExceptionCaught() throws Exception { vertx.createNetClient(new NetClientOptions().setSoLinger(0)).connect(8080, "localhost", onSuccess(socket -> { vertx.setTimer(2000, id -> { socket.close(); }); })); awaitLatch(resetLatch); assertThat(caught.get(), instanceOf(IOException.class)); }
@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(); }
public void setUp() throws Exception { super.setUp(); if (USE_DOMAIN_SOCKETS) { assertTrue("Native transport not enabled", USE_NATIVE_TRANSPORT); tmp = TestUtils.tmpFile(".sock"); testAddress = SocketAddress.domainSocketAddress(tmp.getAbsolutePath()); } else { testAddress = SocketAddress.inetSocketAddress(1234, "localhost"); } client = vertx.createNetClient(new NetClientOptions().setConnectTimeout(1000)); server = vertx.createNetServer(); }
@Test public void testProxyConnectError() { testConnectErrorNotifiesOnEventLoop(new NetClientOptions() .setProxyOptions(new ProxyOptions() .setPort(1234) .setType(ProxyType.SOCKS5) .setHost("localhost"))); }
@Test public void testRequestHandlerNotCalledInvalidRequest() { server.requestHandler(req -> { fail(); }); server.listen(onSuccess(s -> { vertx.createNetClient(new NetClientOptions()).connect(8080, "127.0.0.1", onSuccess(socket -> { socket.closeHandler(r -> { testComplete(); }); socket.write("GET HTTP1/1\r\n"); // trigger another write to be sure we detect that the other peer has closed the connection. socket.write("X-Header: test\r\n"); })); })); await(); }
@Test public void testClientLogging() throws Exception { client.close(); client = vertx.createNetClient(new NetClientOptions().setLogActivity(true)); TestLoggerFactory factory = testLogging(); assertTrue(factory.hasName("io.netty.handler.logging.LoggingHandler")); }
@Test public void testClientIdleTimeout() { client.close(); NetClientOptions netClientOptions = new NetClientOptions(); netClientOptions.setIdleTimeout(1000); netClientOptions.setIdleTimeoutUnit(TimeUnit.MILLISECONDS); client = vertx.createNetClient(netClientOptions); 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(); }
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(); }
/** * test socks5 proxy for accessing arbitrary server port with authentication. */ @Test public void testWithSocks5ProxyAuth() throws Exception { NetClientOptions clientOptions = new NetClientOptions() .setProxyOptions(new ProxyOptions().setType(ProxyType.SOCKS5).setPort(11080) .setUsername("username").setPassword("username")); NetClient client = vertx.createNetClient(clientOptions); server.connectHandler(sock -> { }); proxy = new SocksProxy("username"); proxy.start(vertx); server.listen(1234, "localhost", ar -> { assertTrue(ar.succeeded()); client.connect(1234, "localhost", ar2 -> { assertTrue(ar2.succeeded()); testComplete(); }); }); await(); }
@Test public void testNetClientInternalTLS() throws Exception { client.close(); client = vertx.createNetClient(new NetClientOptions().setSsl(true).setTrustStoreOptions(Trust.SERVER_JKS.get())); testNetClientInternal_(new HttpServerOptions() .setHost("localhost") .setPort(1234) .setSsl(true) .setKeyStoreOptions(Cert.SERVER_JKS.get()), true); }
@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 testDefaultClientOptionsJson() { NetClientOptions def = new NetClientOptions(); NetClientOptions json = new NetClientOptions(new JsonObject()); assertEquals(def.getReconnectAttempts(), json.getReconnectAttempts()); assertEquals(def.getReconnectInterval(), json.getReconnectInterval()); assertEquals(def.isTrustAll(), json.isTrustAll()); assertEquals(def.getCrlPaths(), json.getCrlPaths()); assertEquals(def.getCrlValues(), json.getCrlValues()); assertEquals(def.getConnectTimeout(), json.getConnectTimeout()); assertEquals(def.isTcpNoDelay(), json.isTcpNoDelay()); assertEquals(def.isTcpKeepAlive(), json.isTcpKeepAlive()); assertEquals(def.getSoLinger(), json.getSoLinger()); assertEquals(def.isUsePooledBuffers(), json.isUsePooledBuffers()); assertEquals(def.isSsl(), json.isSsl()); assertEquals(def.isUseAlpn(), json.isUseAlpn()); assertEquals(def.getSslEngineOptions(), json.getSslEngineOptions()); assertEquals(def.getHostnameVerificationAlgorithm(), json.getHostnameVerificationAlgorithm()); }
@Test public void testClientLocalAddress() { String expectedAddress = TestUtils.loopbackAddress(); NetClientOptions clientOptions = new NetClientOptions().setLocalAddress(expectedAddress); client.close(); client = vertx.createNetClient(clientOptions); server.connectHandler(sock -> { assertEquals(expectedAddress, sock.remoteAddress().host()); sock.close(); }); server.listen(1234, "localhost", onSuccess(v -> { client.connect(1234, "localhost", onSuccess(socket -> { socket.closeHandler(v2 -> { testComplete(); }); })); })); await(); }