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

Example 6 with Async

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

the class ProtonClientTest method testDrainWithNoCredit.

@Test(timeout = 20000)
public void testDrainWithNoCredit(TestContext context) {
    Async async = context.async();
    connect(context, connection -> {
        connection.open();
        // Create receiver [with prefetch disabled] against address that will send no messages
        ProtonReceiver receiver = connection.createReceiver(MockServer.Addresses.no_messages.toString());
        // Turn off automatic prefetch / credit handling
        receiver.setPrefetch(0).open();
        // Explicitly drain, granting no credit first, should no-op
        receiver.drain(0, result -> {
            context.assertTrue(result.succeeded(), "Drain should have succeeded");
            async.complete();
            connection.disconnect();
        });
    });
}

Example 7 with Async

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

the class ProtonClientTest method doOpenLinkWithQosTestImpl.

public void doOpenLinkWithQosTestImpl(TestContext context, boolean clientSender, ProtonQoS qos) throws Exception {
    server.close();
    Async serverAsync = context.async();
    Async clientAsync = context.async();
    ProtonServer protonServer = null;
    try {
        protonServer = createServer((serverConnection) -> {
            serverConnection.openHandler(result -> {
                serverConnection.open();
            });
            serverConnection.sessionOpenHandler(session -> session.open());
            if (clientSender) {
                serverConnection.receiverOpenHandler(receiver -> {
                    context.assertEquals(qos, receiver.getRemoteQoS(), "unexpected remote qos value");
                    LOG.trace("Server receiver opened");
                    receiver.open();
                    serverAsync.complete();
                });
            } else {
                serverConnection.senderOpenHandler(sender -> {
                    context.assertEquals(qos, sender.getRemoteQoS(), "unexpected remote qos value");
                    LOG.trace("Server sender opened");
                    sender.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<?> link;
                if (clientSender) {
                    link = connection.createSender(null);
                } else {
                    link = connection.createReceiver("some-address");
                }
                link.setQoS(qos);
                link.openHandler(y -> {
                    LOG.trace("Client link opened");
                    context.assertEquals(qos, link.getRemoteQoS(), "unexpected remote qos value");
                    clientAsync.complete();
                });
                link.open();
            }).open();
        });
        serverAsync.awaitSuccess();
        clientAsync.awaitSuccess();
    } finally {
        if (protonServer != null) {
            protonServer.close();
        }
    }
}

Example 8 with Async

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

the class ProtonClientTest method testLinkPropertiesAndCapabilities.

@Test(timeout = 20000)
public void testLinkPropertiesAndCapabilities(TestContext context) throws Exception {
    server.close();
    Async serverAsync = context.async();
    Async clientAsync = context.async();
    Map<Symbol, Object> clientProperties = Collections.singletonMap(Symbol.valueOf("client"), true);
    Map<Symbol, Object> serverProperties = Collections.singletonMap(Symbol.valueOf("server"), true);
    Symbol cap1 = Symbol.valueOf("1");
    Symbol cap2 = Symbol.valueOf("1");
    Symbol cap3 = Symbol.valueOf("1");
    Symbol cap4 = Symbol.valueOf("1");
    Symbol[] clientDesired = { cap1, cap2 };
    Symbol[] clientOffered = { cap3 };
    Symbol[] serverDesried = { cap3, cap4 };
    Symbol[] serverOffered = { cap2 };
    ProtonServer protonServer = null;
    try {
        protonServer = createServer((serverConnection) -> {
            serverConnection.openHandler(result -> {
                serverConnection.open();
            });
            serverConnection.sessionOpenHandler(session -> {
                session.open();
            });
            serverConnection.senderOpenHandler(serverSender -> {
                context.assertEquals(clientProperties, serverSender.getRemoteProperties());
                context.assertTrue(Arrays.equals(clientDesired, serverSender.getRemoteDesiredCapabilities()));
                context.assertTrue(Arrays.equals(clientOffered, serverSender.getRemoteOfferedCapabilities()));
                LOG.trace("Server sender opened");
                serverSender.setProperties(serverProperties);
                serverSender.setDesiredCapabilities(serverDesried);
                serverSender.setOfferedCapabilities(serverOffered);
                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");
                receiver.setProperties(clientProperties);
                receiver.setDesiredCapabilities(clientDesired);
                receiver.setOfferedCapabilities(clientOffered);
                receiver.openHandler(y -> {
                    LOG.trace("Client link opened");
                    context.assertEquals(serverProperties, receiver.getRemoteProperties(), "Unexpected value for link properties");
                    context.assertTrue(Arrays.equals(serverDesried, receiver.getRemoteDesiredCapabilities()));
                    context.assertTrue(Arrays.equals(serverOffered, receiver.getRemoteOfferedCapabilities()));
                    clientAsync.complete();
                });
                receiver.open();
            }).open();
        });
        serverAsync.awaitSuccess();
        clientAsync.awaitSuccess();
    } finally {
        if (protonServer != null) {
            protonServer.close();
        }
    }
}

Example 9 with Async

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

the class ProtonClientTest method doDrainWithSomeCreditUsedTestImpl.

private void doDrainWithSomeCreditUsedTestImpl(TestContext context, boolean autoDrainedSender) throws Exception {
    server.close();
    int credits = 5;
    int messages = 2;
    // Set up server that will send 2 messages, and either automatically or explicitly set the link drained after.
    MockServer protonServer = doDrainTestServerSetup(context, autoDrainedSender, !autoDrainedSender, messages);
    Async async = context.async();
    AtomicInteger counter = new AtomicInteger(0);
    AtomicBoolean drainComplete = new AtomicBoolean();
    ProtonClient client = ProtonClient.create(vertx);
    client.connect("localhost", protonServer.actualPort(), res -> {
        context.assertTrue(res.succeeded());
        ProtonConnection connection = res.result();
        connection.open();
        // Create receiver [with prefetch disabled] against the mock server sending 2 messages
        ProtonReceiver receiver = connection.createReceiver("some-address");
        receiver.handler((d, m) -> {
            int count = counter.incrementAndGet();
            switch(count) {
                // fall through
                case 1:
                case 2:
                    validateMessage(context, count, String.valueOf(count), m);
                    context.assertFalse(drainComplete.get(), "Drain should not yet be completed!");
                    break;
                default:
                    context.fail("Should only get 2 messages");
                    break;
            }
        }).setPrefetch(// Turn off automatic prefetch / credit handling
        0).open();
        // Explicitly drain, granting 5 credits first, so not all are used (we only expect 2 messages).
        receiver.flow(credits);
        receiver.drain(10000, result -> {
            context.assertTrue(result.succeeded(), "Drain should have succeeded");
            context.assertEquals(2, counter.get(), "Drain should not yet be completed! Unexpected message count");
            drainComplete.set(true);
            async.complete();
            connection.disconnect();
        });
    });
}

Example 10 with Async

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

the class ProtonClientTest method testClientIdentification.

@Test(timeout = 20000)
public void testClientIdentification(TestContext context) {
    Async async = context.async();
    connect(context, connection -> {
        connection.setContainer("foo").openHandler(x -> {
            context.assertEquals("foo", connection.getContainer());
            // Our mock server responds with a pong container id
            context.assertEquals("pong: foo", connection.getRemoteContainer());
            connection.disconnect();
            async.complete();
        }).open();
    });
}