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

Example 11 with Async

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

the class ProtonClientTest method testNonAnonymousSenderDoesNotEnforceMessageHasAddress.

@Test(timeout = 20000)
public void testNonAnonymousSenderDoesNotEnforceMessageHasAddress(TestContext context) {
    Async async = context.async();
    connect(context, connection -> {
        connection.open();
        ProtonSender sender = connection.createSender(MockServer.Addresses.drop.toString());
        Message messageWithNoAddress = Proton.message();
        sender.send(messageWithNoAddress);
        connection.disconnect();
        async.complete();
    });
}

Example 12 with Async

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

the class ProtonClientTest method testAnonymousSenderEnforcesMessageHasAddress.

@Test(timeout = 20000)
public void testAnonymousSenderEnforcesMessageHasAddress(TestContext context) {
    Async async = context.async();
    connect(context, connection -> {
        connection.open();
        ProtonSender sender = connection.createSender(null);
        Message messageWithNoAddress = Proton.message();
        try {
            sender.send(messageWithNoAddress);
            context.fail("Send should have thrown IAE due to lack of message address");
        } catch (IllegalArgumentException iae) {
            // Expected
            connection.disconnect();
            async.complete();
        }
    });
}

Example 13 with Async

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

the class ProtonClientTest method testReceiveMultipleMessagesWithLowerPrefetch.

@Test(timeout = 20000)
public void testReceiveMultipleMessagesWithLowerPrefetch(TestContext context) {
    Async async = context.async();
    connect(context, connection -> {
        connection.open();
        AtomicInteger counter = new AtomicInteger(0);
        ProtonReceiver receiver = connection.createReceiver(MockServer.Addresses.five_messages.toString());
        // Set prefetch to 2 credit. Test verifies receiver gets multiple messages, i.e credit is being replenished.
        receiver.setPrefetch(2).handler((d, m) -> {
            int count = counter.incrementAndGet();
            validateMessage(context, count, String.valueOf(count), m);
            if (count == 5) {
                // Got the last message, lets finish the test.
                LOG.trace("Got msg 5, completing async");
                async.complete();
                connection.disconnect();
            }
        }).open();
    });
}

Example 14 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 15 with Async

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

the class ProtonServerImplTest method testCustomAuthenticatorHasInitCalled.

@Test(timeout = 20000)
public void testCustomAuthenticatorHasInitCalled(TestContext context) {
    Async initCalledAsync = context.async();
    ProtonServer.create(vertx).saslAuthenticatorFactory(new ProtonSaslAuthenticatorFactory() {

        @Override
        public ProtonSaslAuthenticator create() {
            return new ProtonSaslAuthenticator() {

                @Override
                public void init(NetSocket socket, ProtonConnection protonConnection, Transport transport) {
                    initCalledAsync.complete();
                }

                @Override
                public void process(Handler<Boolean> completionHandler) {
                    completionHandler.handle(false);
                }

                @Override
                public boolean succeeded() {
                    return false;
                }
            };
        }
    }).connectHandler(protonConnection -> {
    }).listen(server -> ProtonClient.create(vertx).connect("localhost", server.result().actualPort(), protonConnectionAsyncResult -> {
    }));
}