Examples with Handler io.vertx.core.Handler used on opensource projects

Example 56 with Handler

use of io.vertx.core.Handler in project hono by eclipse.

the class EventConsumerImplTest method testCreateRegistersBiConsumerAsMessageHandler.

/**
 * Verifies that the message delivery for a received event is forwarded to the
 * registered event consumer.
 *
 * @param ctx The test context.
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
@Test
public void testCreateRegistersBiConsumerAsMessageHandler(final TestContext ctx) {
    // GIVEN an event consumer that releases all messages
    final Async consumerCreation = ctx.async();
    final BiConsumer<ProtonDelivery, Message> eventConsumer = (delivery, message) -> {
        ProtonHelper.released(delivery, true);
    };
    final RecordImpl attachments = new RecordImpl();
    final Source source = mock(Source.class);
    when(source.toString()).thenReturn("event/tenant");
    final ProtonReceiver receiver = mock(ProtonReceiver.class);
    when(receiver.getSource()).thenReturn(source);
    when(receiver.attachments()).thenReturn(attachments);
    when(receiver.getRemoteQoS()).thenReturn(ProtonQoS.AT_LEAST_ONCE);
    when(receiver.open()).then(answer -> {
        consumerCreation.complete();
        return receiver;
    });
    final ProtonConnection con = mock(ProtonConnection.class);
    when(con.createReceiver(anyString())).thenReturn(receiver);
    when(receiver.openHandler(any(Handler.class))).thenAnswer(invocation -> {
        final Handler handler = invocation.getArgument(0);
        handler.handle(Future.succeededFuture(receiver));
        return receiver;
    });
    final ArgumentCaptor<ProtonMessageHandler> messageHandler = ArgumentCaptor.forClass(ProtonMessageHandler.class);
    EventConsumerImpl.create(vertx.getOrCreateContext(), new ClientConfigProperties(), con, "tenant", eventConsumer, open -> {
    }, remoteDetach -> {
    });
    consumerCreation.await();
    verify(receiver).handler(messageHandler.capture());
    // WHEN an event is received
    final ProtonDelivery delivery = mock(ProtonDelivery.class);
    final Message msg = mock(Message.class);
    messageHandler.getValue().handle(delivery, msg);
    // THEN the message is released and settled
    verify(delivery).disposition(any(Released.class), eq(Boolean.TRUE));
}

Example 57 with Handler

use of io.vertx.core.Handler in project hono by eclipse.

the class HonoClientUnitTestHelper method mockContext.

/**
 * Creates a mocked vert.x Context which immediately invokes any handler that is passed to its runOnContext method.
 *
 * @param vertx The vert.x instance that the mock of the context is created for.
 * @return The mocked context.
 */
@SuppressWarnings("unchecked")
public static final Context mockContext(final Vertx vertx) {
    final Context context = mock(Context.class);
    when(context.owner()).thenReturn(vertx);
    doAnswer(invocation -> {
        Handler<Void> handler = invocation.getArgument(0);
        handler.handle(null);
        return null;
    }).when(context).runOnContext(any(Handler.class));
    return context;
}

Example 58 with Handler

use of io.vertx.core.Handler in project hono by eclipse.

the class TelemetrySenderImplTest method testSendMessageDoesNotWaitForAcceptedOutcome.

/**
 * Verifies that the sender does not wait for the peer to settle and
 * accept a message before succeeding.
 *
 * @param ctx The vert.x test context.
 */
@SuppressWarnings({ "unchecked" })
@Test
public void testSendMessageDoesNotWaitForAcceptedOutcome(final TestContext ctx) {
    // GIVEN a sender that has credit
    when(sender.sendQueueFull()).thenReturn(Boolean.FALSE);
    MessageSender messageSender = new TelemetrySenderImpl(config, sender, "tenant", "telemetry/tenant", context);
    final AtomicReference<Handler<ProtonDelivery>> handlerRef = new AtomicReference<>();
    doAnswer(invocation -> {
        handlerRef.set(invocation.getArgument(1));
        return mock(ProtonDelivery.class);
    }).when(sender).send(any(Message.class), any(Handler.class));
    // WHEN trying to send a message
    final Future<ProtonDelivery> result = messageSender.send("device", "some payload", "application/text", "token");
    // which gets rejected by the peer
    ProtonDelivery rejected = mock(ProtonDelivery.class);
    when(rejected.remotelySettled()).thenReturn(Boolean.TRUE);
    when(rejected.getRemoteState()).thenReturn(new Rejected());
    handlerRef.get().handle(rejected);
    // THEN the resulting future is succeeded nevertheless
    assertTrue(result.succeeded());
    // and the message has been sent
    verify(sender).send(any(Message.class), eq(handlerRef.get()));
}

Example 59 with Handler

use of io.vertx.core.Handler in project hono by eclipse.

the class ConnectionFactoryImpl method handleConnectionAttemptResult.

private void handleConnectionAttemptResult(final AsyncResult<ProtonConnection> conAttempt, final ProtonClientOptions clientOptions, final Handler<AsyncResult<ProtonConnection>> closeHandler, final Handler<ProtonConnection> disconnectHandler, final Handler<AsyncResult<ProtonConnection>> connectionResultHandler) {
    if (conAttempt.failed()) {
        logger.debug("can't connect to AMQP 1.0 container [{}://{}:{}]: {}", clientOptions.isSsl() ? "amqps" : "amqp", config.getHost(), config.getPort(), conAttempt.cause().getMessage());
        connectionResultHandler.handle(Future.failedFuture(conAttempt.cause()));
    } else {
        // at this point the SASL exchange has completed successfully
        logger.debug("connected to AMQP 1.0 container [{}://{}:{}], opening connection ...", clientOptions.isSsl() ? "amqps" : "amqp", config.getHost(), config.getPort());
        ProtonConnection downstreamConnection = conAttempt.result();
        downstreamConnection.setContainer(String.format("%s-%s", config.getName(), UUID.randomUUID())).setHostname(config.getAmqpHostname()).openHandler(openCon -> {
            if (openCon.succeeded()) {
                logger.debug("connection to container [{}] at [{}://{}:{}] open", downstreamConnection.getRemoteContainer(), clientOptions.isSsl() ? "amqps" : "amqp", config.getHost(), config.getPort());
                downstreamConnection.disconnectHandler(disconnectHandler);
                downstreamConnection.closeHandler(closeHandler);
                connectionResultHandler.handle(Future.succeededFuture(downstreamConnection));
            } else {
                final ErrorCondition error = downstreamConnection.getRemoteCondition();
                if (error == null) {
                    logger.warn("can't open connection to container [{}] at [{}://{}:{}]", downstreamConnection.getRemoteContainer(), clientOptions.isSsl() ? "amqps" : "amqp", config.getHost(), config.getPort(), openCon.cause());
                } else {
                    logger.warn("can't open connection to container [{}] at [{}://{}:{}]: {} -{}", downstreamConnection.getRemoteContainer(), clientOptions.isSsl() ? "amqps" : "amqp", config.getHost(), config.getPort(), error.getCondition(), error.getDescription());
                }
                connectionResultHandler.handle(Future.failedFuture(openCon.cause()));
            }
        }).open();
    }
}

Example 60 with Handler

use of io.vertx.core.Handler in project hono by eclipse.

the class ConnectionFactoryImplTest method testConnectInvokesHandlerOnfailureToConnect.

/**
 * Verifies that the given result handler is invoked if a connection attempt fails.
 *
 * @param ctx The vert.x test context.
 */
@Test
public void testConnectInvokesHandlerOnfailureToConnect(final TestContext ctx) {
    // GIVEN a factory configured to connect to a non-existing server
    ConnectionFactoryImpl factory = new ConnectionFactoryImpl(vertx, props);
    // WHEN trying to connect to the server
    final Async handlerInvocation = ctx.async();
    ProtonClientOptions options = new ProtonClientOptions().setConnectTimeout(100);
    factory.connect(options, null, null, ctx.asyncAssertFailure(t -> {
        handlerInvocation.complete();
    }));
    // THEN the connection attempt fails and the given handler is invoked
    handlerInvocation.await(2000);
}