Examples with Async io.vertx.ext.unit.Async used on opensource projects

Example 1 with Async

use of io.vertx.ext.unit.Async in project vertx-swagger by bobxwang.

the class DatabaseVerticleTest method testSendMsg.

@Test
public void testSendMsg(TestContext context) {
    final Async async = context.async();
    databaseService.fetchAllPages(r -> {
        if (r.succeeded()) {
            JsonObject jsonObject = r.result();
            context.assertNotNull(jsonObject);
            context.assertNotNull(jsonObject.getString("dbthread"));
            async.complete();
        }
    });
    async.awaitSuccess(5 * 1000);
}

Example 2 with Async

use of io.vertx.ext.unit.Async in project vertx-proton by vert-x3.

the class ProtonClientTest method testMaxMessageSize.

@Test(timeout = 20000)
public void testMaxMessageSize(TestContext context) throws Exception {
    server.close();
    Async serverAsync = context.async();
    Async clientAsync = context.async();
    final UnsignedLong clientMaxMsgSize = UnsignedLong.valueOf(54321);
    final UnsignedLong serverMaxMsgSize = UnsignedLong.valueOf(12345);
    ProtonServer protonServer = null;
    try {
        protonServer = createServer((serverConnection) -> {
            serverConnection.openHandler(result -> {
                serverConnection.open();
            });
            serverConnection.sessionOpenHandler(session -> {
                session.open();
            });
            serverConnection.senderOpenHandler(serverSender -> {
                context.assertEquals(clientMaxMsgSize, serverSender.getRemoteMaxMessageSize(), "unexpected remote max message size at server");
                context.assertNull(serverSender.getMaxMessageSize(), "Expected no value to be set");
                serverSender.setMaxMessageSize(serverMaxMsgSize);
                context.assertEquals(serverMaxMsgSize, serverSender.getMaxMessageSize(), "Expected value to now be set");
                LOG.trace("Server sender opened");
                serverSender.open();
                serverAsync.complete();
            });
        });
        // ===== Client Handling =====
        ProtonClient client = ProtonClient.create(vertx);
        client.connect("localhost", protonServer.actualPort(), res -> {
            context.assertTrue(res.succeeded());
            ProtonConnection connection = res.result();
            connection.openHandler(x -> {
                LOG.trace("Client connection opened");
                final ProtonLink<?> receiver = connection.createReceiver("some-address");
                context.assertNull(receiver.getMaxMessageSize(), "Expected no value to be set");
                receiver.setMaxMessageSize(clientMaxMsgSize);
                context.assertEquals(clientMaxMsgSize, receiver.getMaxMessageSize(), "Expected value to now be set");
                receiver.openHandler(y -> {
                    LOG.trace("Client link opened");
                    context.assertEquals(serverMaxMsgSize, receiver.getRemoteMaxMessageSize(), "unexpected remote max message size at client");
                    clientAsync.complete();
                });
                receiver.open();
            }).open();
        });
        serverAsync.awaitSuccess();
        clientAsync.awaitSuccess();
    } finally {
        if (protonServer != null) {
            protonServer.close();
        }
    }
}

Example 3 with Async

use of io.vertx.ext.unit.Async in project hono by eclipse.

the class IntegrationTestSupport method deleteObjects.

/**
 * Deletes all temporary objects from the Device Registry which
 * have been created during the last test execution.
 *
 * @param ctx The vert.x context.
 */
public void deleteObjects(final TestContext ctx) {
    devicesToDelete.forEach((tenantId, devices) -> {
        devices.forEach(deviceId -> {
            final Async deletion = ctx.async();
            CompositeFuture.join(registry.deregisterDevice(tenantId, deviceId), registry.removeAllCredentials(tenantId, deviceId)).setHandler(ok -> deletion.complete());
            deletion.await();
        });
    });
    devicesToDelete.clear();
    tenantsToDelete.forEach(tenantId -> {
        final Async deletion = ctx.async();
        registry.removeTenant(tenantId).setHandler(ok -> deletion.complete());
        deletion.await();
    });
    tenantsToDelete.clear();
}

Example 4 with Async

use of io.vertx.ext.unit.Async in project hono by eclipse.

the class ClientTestBase method testSendingMessages.

/**
 * Verifies that a number of messages uploaded to Hono's Telemetry or Event API can be successfully
 * consumed via the AMQP Messaging Network.
 *
 * @param ctx The test context.
 * @throws InterruptedException if test execution is interrupted.
 */
@Test
public void testSendingMessages(final TestContext ctx) throws InterruptedException {
    final CountDownLatch received = new CountDownLatch(IntegrationTestSupport.MSG_COUNT);
    final Async setup = ctx.async();
    final AtomicReference<String> registrationAssertion = new AtomicReference<>();
    registrationClient.register(DEVICE_ID, null).compose(ok -> registrationClient.assertRegistration(DEVICE_ID)).compose(result -> {
        registrationAssertion.set(result.getString(RegistrationConstants.FIELD_ASSERTION));
        return createConsumer(TEST_TENANT_ID, msg -> {
            LOGGER.trace("received {}", msg);
            assertMessageProperties(ctx, msg);
            assertAdditionalMessageProperties(ctx, msg);
            received.countDown();
            if (received.getCount() % 200 == 0) {
                LOGGER.info("messages received: {}", IntegrationTestSupport.MSG_COUNT - received.getCount());
            }
        });
    }).map(c -> {
        consumer = c;
        setup.complete();
        return null;
    });
    setup.await(1000);
    long start = System.currentTimeMillis();
    final AtomicInteger messagesSent = new AtomicInteger();
    while (messagesSent.get() < IntegrationTestSupport.MSG_COUNT) {
        final Async sending = ctx.async();
        sender.send(DEVICE_ID, "payload_" + messagesSent.getAndIncrement(), CONTENT_TYPE_TEXT_PLAIN, registrationAssertion.get(), creditAvailable -> sending.complete());
        if (messagesSent.get() % 200 == 0) {
            LOGGER.info("messages sent: " + messagesSent.get());
        }
        sending.await();
    }
    long timeToWait = Math.max(DEFAULT_TEST_TIMEOUT, Math.round(IntegrationTestSupport.MSG_COUNT * 1.2));
    if (!received.await(timeToWait, TimeUnit.MILLISECONDS)) {
        LOGGER.info("sent {} and received {} messages after {} milliseconds", messagesSent.get(), IntegrationTestSupport.MSG_COUNT - received.getCount(), System.currentTimeMillis() - start);
        ctx.fail("did not receive all messages sent");
    } else {
        LOGGER.info("sent {} and received {} messages after {} milliseconds", messagesSent.get(), IntegrationTestSupport.MSG_COUNT - received.getCount(), System.currentTimeMillis() - start);
    }
}

Example 5 with Async

use of io.vertx.ext.unit.Async in project hono by eclipse.

the class ClientTestBase method deregister.

/**
 * Deregisters the test device (DEVICE_ID) and disconnects from
 * the Hono server, Hono device registry and AMQP messaging network.
 *
 * @param ctx The test context
 */
@After
public void deregister(final TestContext ctx) {
    if (registrationClient != null) {
        final Async done = ctx.async();
        LOGGER.debug("deregistering devices");
        registrationClient.deregister(DEVICE_ID).setHandler(r -> done.complete());
        done.await(2000);
    }
    disconnect(ctx);
}