static void close(TestContext ctx, Consumer<Handler<AsyncResult<Void>>> producer) { if (producer != null) { Async closeAsync = ctx.async(); producer.accept(v -> { closeAsync.complete(); }); closeAsync.awaitSuccess(10000); } }
@Test public void testAwaitWhenAlreadyCompleted(TestContext context) { try { test0.add("before"); Async async = context.async(); test0.add("complete"); async.complete(); async.awaitSuccess(); test0.add("after"); } finally { done.countDown(); } }
static void close(TestContext ctx, Consumer<Handler<AsyncResult<Void>>> producer) { if (producer != null) { Async closeAsync = ctx.async(); producer.accept(v -> { closeAsync.complete(); }); closeAsync.awaitSuccess(10000); } }
protected void startHttpServer(TestContext ctx, HttpServerOptions options, Handler<HttpServerRequest> handler) { HttpServer proxyServer = vertx.createHttpServer(options); proxyServer.requestHandler(handler); Async async1 = ctx.async(); proxyServer.listen(ctx.asyncAssertSuccess(p -> async1.complete())); async1.awaitSuccess(); }
private void prepareServer(TestContext context, Consumer<HttpServerRequest> reqHandler) { Async async = context.async(); server.requestHandler(req -> { try { reqHandler.accept(req); } finally { req.response().end(); } }); server.listen(context.asyncAssertSuccess(s -> async.complete())); async.awaitSuccess(15000); }
private Properties setupConsumeWithHeaders(TestContext ctx, int numMessages, String topicName) { Async batch = ctx.async(); AtomicInteger index = new AtomicInteger(); kafkaCluster.useTo().produceStrings(numMessages, batch::complete, () -> new ProducerRecord<>(topicName, 0, "key-" + index.get(), "value-" + index.get(), Collections.singletonList(new RecordHeader("header_key" + index.get(), ("header_value" + index.getAndIncrement()).getBytes())))); batch.awaitSuccess(20000); Properties config = kafkaCluster.useTo().getConsumerProperties(topicName, topicName, OffsetResetStrategy.EARLIEST); config.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class); config.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class); return config; }
private Properties setupConsumeWithHeaders(TestContext ctx, int numMessages, String topicName) { Async batch = ctx.async(); AtomicInteger index = new AtomicInteger(); kafkaCluster.useTo().produceStrings(numMessages, batch::complete, () -> new ProducerRecord<>(topicName, 0, "key-" + index.get(), "value-" + index.get(), Collections.singletonList(new RecordHeader("header_key" + index.get(), ("header_value" + index.getAndIncrement()).getBytes())))); batch.awaitSuccess(20000); Properties config = kafkaCluster.useTo().getConsumerProperties(topicName, topicName, OffsetResetStrategy.EARLIEST); config.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class); config.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class); return config; }
protected SocketAddress startHttpBackend(TestContext ctx, HttpServerOptions options, Handler<HttpServerRequest> handler) { HttpServer backendServer = vertx.createHttpServer(options); backendServer.requestHandler(handler); Async async = ctx.async(); backendServer.listen(ctx.asyncAssertSuccess(s -> async.complete())); async.awaitSuccess(); return new SocketAddressImpl(options.getPort(), "localhost"); }
@Test public void websocketServiceCloseConnectionOnUnrecoverableError(final TestContext context) { final Async async = context.async(); final byte[] bigMessage = new byte[HttpServerOptions.DEFAULT_MAX_WEBSOCKET_MESSAGE_SIZE + 1]; Arrays.fill(bigMessage, (byte) 1); httpClient.websocket( "/", webSocket -> { webSocket.write(Buffer.buffer(bigMessage)); webSocket.closeHandler(v -> async.complete()); }); async.awaitSuccess(VERTX_AWAIT_TIMEOUT_MILLIS); }
@Test public void testUDP(TestContext testContext) throws Exception { auditContext.setAuditRepositoryTransport("UDP"); int count = 10; Async async = testContext.async(count + 1); deploy(testContext, createUDPServer(LOCALHOST, port, async)); while (async.count() > count) { Thread.sleep(10); } for (int i = 0; i < count; i++) sendAudit(); async.awaitSuccess(WAIT_TIME); }
@Test public void testOneWayTLS(TestContext testContext) throws Exception { initTLSSystemProperties(null); Async async = testContext.async(); deploy(testContext, createTCPServerOneWayTLS(port, SERVER_KEY_STORE, SERVER_KEY_STORE_PASS, async)); sendAudit(); async.awaitSuccess(WAIT_TIME); }
@Test(timeout = 20000) public void testCloseBridgeThatWasntStarted(TestContext context) throws Exception { stopBroker(); Async async = context.async(); AmqpBridge bridge = AmqpBridge.create(vertx); bridge.close(shutdownRes -> { LOG.trace("Shutdown complete"); context.assertTrue(shutdownRes.succeeded()); async.complete(); }); async.awaitSuccess(); } }
private void runClientRequests(TestContext ctx) { Async clientsFinished = ctx.async(concurrentClients); for (int i = 0; i < concurrentClients; i++) { ForkJoinPool.commonPool().execute(() -> { NetClient client = vertx.createNetClient(); request(client, ctx); clientsFinished.countDown(); }); } clientsFinished.awaitSuccess(); }
@Test public void testCloseShellServer(TestContext context) throws Exception { testClose(context, conn -> { Async async = context.async(); shellServer.close(context.asyncAssertSuccess(v -> async.complete())); async.awaitSuccess(20000); }); }
@AfterClass public static void shutdown(TestContext context) throws Exception { LOGGER.debug("performing shutdown"); if (vertx != null) { Async async = context.async(); vertx.close(ar -> { vertx = null; async.complete(); }); async.awaitSuccess(); LOGGER.debug("finished shutdown"); } }
@Test public void testUDPVertx(TestContext testContext) throws Exception { auditContext.setAuditTransmissionProtocol(new VertxUDPSyslogSenderImpl(vertx)); int count = 10; Async async = testContext.async(count); deploy(testContext, createUDPServer(LOCALHOST, port, async)); for (int i = 0; i < count; i++) sendAudit(); async.awaitSuccess(WAIT_TIME); }
private void startTelnet(TestContext context, TelnetTermOptions options, Handler<Term> termHandler) { server = TermServer.createTelnetTermServer(vertx, options.setPort(4000)); server.termHandler(termHandler); Async async = context.async(); server.listen(context.asyncAssertSuccess(v -> async.complete())); async.awaitSuccess(5000); }
private void startShellServer(TestContext context, long sessionTimeout, long reaperInterval) { if (shellServer != null) { throw new IllegalStateException("Already started"); } Async latch = context.async(); shellServer = ShellServer.create(vertx, new ShellServerOptions().setSessionTimeout(sessionTimeout).setReaperInterval(reaperInterval)). registerTermServer(termServer). registerCommandResolver(registry). listen(context.asyncAssertSuccess(v -> latch.complete())); latch.awaitSuccess(20000); }
protected SocketAddress startNetBackend(TestContext ctx, int port, Handler<NetSocket> handler) { NetServer backendServer = vertx.createNetServer(new HttpServerOptions().setPort(port).setHost("localhost")); backendServer.connectHandler(handler); Async async = ctx.async(); backendServer.listen(ctx.asyncAssertSuccess(s -> async.complete())); async.awaitSuccess(); return new SocketAddressImpl(port, "localhost"); }
private void connect(DoubleHandler<ILdapClientConnection, TestContext> handler) { TestCompletion completion = TestSuite.create("").test("", context -> { Async async = context.async(); ldapClientComponent.connect(config, connectionResult -> { context.assertTrue(connectionResult.isSuccess()); connection = connectionResult.getResult(); handler.handle(connection, context); async.complete(); }); async.awaitSuccess(); }).run(); completion.awaitSuccess(); }