Example usage for org.springframework.amqp.rabbit.connection CachingConnectionFactory destroy

List of usage examples for org.springframework.amqp.rabbit.connection CachingConnectionFactory destroy

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.amqp.rabbit.connection.*
  5. CachingConnectionFactory
  6. destroy

Introduction

In this page you can find the example usage for org.springframework.amqp.rabbit.connection CachingConnectionFactory destroy.

Prototype

@Override
public final void destroy()

Source Link

Document

Close the underlying shared connection.

Usage

From source file:org.springframework.amqp.rabbit.listener.DirectMessageListenerContainerTests.java

@Test
public void testSimple() throws Exception {
    CachingConnectionFactory cf = new CachingConnectionFactory("localhost");
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setThreadNamePrefix("client-");
    executor.afterPropertiesSet();//from www. j  av a2s  .  co m
    cf.setExecutor(executor);
    DirectMessageListenerContainer container = new DirectMessageListenerContainer(cf);
    container.setQueueNames(Q1, Q2);
    container.setConsumersPerQueue(2);
    container.setMessageListener(new MessageListenerAdapter((ReplyingMessageListener<String, String>) in -> {
        if ("foo".equals(in) || "bar".equals(in)) {
            return in.toUpperCase();
        } else {
            return null;
        }
    }));
    container.setBeanName("simple");
    container.setConsumerTagStrategy(new Tag());
    container.afterPropertiesSet();
    container.start();
    RabbitTemplate template = new RabbitTemplate(cf);
    assertEquals("FOO", template.convertSendAndReceive(Q1, "foo"));
    assertEquals("BAR", template.convertSendAndReceive(Q2, "bar"));
    container.stop();
    assertTrue(consumersOnQueue(Q1, 0));
    assertTrue(consumersOnQueue(Q2, 0));
    assertTrue(activeConsumerCount(container, 0));
    assertEquals(0, TestUtils.getPropertyValue(container, "consumersByQueue", MultiValueMap.class).size());
    cf.destroy();
}

From source file:org.springframework.amqp.rabbit.listener.DirectMessageListenerContainerTests.java

@Test
public void testQueueManagement() throws Exception {
    CachingConnectionFactory cf = new CachingConnectionFactory("localhost");
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setThreadNamePrefix("client-");
    executor.afterPropertiesSet();// w ww.  j av  a 2s  .  com
    cf.setExecutor(executor);
    DirectMessageListenerContainer container = new DirectMessageListenerContainer(cf);
    container.setConsumersPerQueue(2);
    container.setMessageListener(new MessageListenerAdapter((ReplyingMessageListener<String, String>) in -> {
        if ("foo".equals(in) || "bar".equals(in)) {
            return in.toUpperCase();
        } else {
            return null;
        }
    }));
    container.setBeanName("qManage");
    container.setConsumerTagStrategy(new Tag());
    container.afterPropertiesSet();
    container.start();
    container.addQueueNames(Q1, Q2);
    assertTrue(consumersOnQueue(Q1, 2));
    assertTrue(consumersOnQueue(Q2, 2));
    RabbitTemplate template = new RabbitTemplate(cf);
    assertEquals("FOO", template.convertSendAndReceive(Q1, "foo"));
    assertEquals("BAR", template.convertSendAndReceive(Q2, "bar"));
    container.removeQueueNames(Q1, Q2, "junk");
    assertTrue(consumersOnQueue(Q1, 0));
    assertTrue(consumersOnQueue(Q2, 0));
    assertTrue(activeConsumerCount(container, 0));
    container.stop();
    assertTrue(consumersOnQueue(Q1, 0));
    assertTrue(consumersOnQueue(Q2, 0));
    assertTrue(activeConsumerCount(container, 0));
    assertEquals(0, TestUtils.getPropertyValue(container, "consumersByQueue", MultiValueMap.class).size());
    cf.destroy();
}

From source file:org.springframework.amqp.rabbit.listener.DirectMessageListenerContainerTests.java

@Test
public void testAddRemoveConsumers() throws Exception {
    CachingConnectionFactory cf = new CachingConnectionFactory("localhost");
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setThreadNamePrefix("client-");
    executor.afterPropertiesSet();// w w w  .  java 2s .  c  om
    cf.setExecutor(executor);
    DirectMessageListenerContainer container = new DirectMessageListenerContainer(cf);
    container.setQueueNames(Q1, Q2);
    container.setConsumersPerQueue(2);
    container.setMessageListener(new MessageListenerAdapter((ReplyingMessageListener<String, String>) in -> {
        if ("foo".equals(in) || "bar".equals(in)) {
            return in.toUpperCase();
        } else {
            return null;
        }
    }));
    container.setBeanName("qAddRemove");
    container.setConsumerTagStrategy(new Tag());
    container.afterPropertiesSet();
    container.start();
    RabbitTemplate template = new RabbitTemplate(cf);
    assertEquals("FOO", template.convertSendAndReceive(Q1, "foo"));
    assertEquals("BAR", template.convertSendAndReceive(Q2, "bar"));
    assertTrue(consumersOnQueue(Q1, 2));
    assertTrue(consumersOnQueue(Q2, 2));
    container.setConsumersPerQueue(1);
    assertTrue(consumersOnQueue(Q1, 1));
    assertTrue(consumersOnQueue(Q2, 1));
    container.setConsumersPerQueue(2);
    assertTrue(consumersOnQueue(Q1, 2));
    assertTrue(consumersOnQueue(Q2, 2));
    container.stop();
    assertTrue(consumersOnQueue(Q1, 0));
    assertTrue(consumersOnQueue(Q2, 0));
    assertTrue(activeConsumerCount(container, 0));
    assertEquals(0, TestUtils.getPropertyValue(container, "consumersByQueue", MultiValueMap.class).size());
    cf.destroy();
}

From source file:org.springframework.amqp.rabbit.listener.DirectMessageListenerContainerTests.java

@Test
public void testEvents() throws Exception {
    CachingConnectionFactory cf = new CachingConnectionFactory("localhost");
    DirectMessageListenerContainer container = new DirectMessageListenerContainer(cf);
    container.setQueueNames(EQ1, EQ2);/*from w ww.  ja va  2s.  c o  m*/
    final List<Long> times = new ArrayList<>();
    final CountDownLatch latch1 = new CountDownLatch(2);
    final AtomicReference<ApplicationEvent> failEvent = new AtomicReference<>();
    final CountDownLatch latch2 = new CountDownLatch(2);
    container.setApplicationEventPublisher(new ApplicationEventPublisher() {

        @Override
        public void publishEvent(Object event) {
        }

        @Override
        public void publishEvent(ApplicationEvent event) {
            if (event instanceof ListenerContainerIdleEvent) {
                times.add(System.currentTimeMillis());
                latch1.countDown();
            } else {
                failEvent.set(event);
                latch2.countDown();
            }
        }

    });
    container.setMessageListener(m -> {
    });
    container.setIdleEventInterval(50L);
    container.setBeanName("events");
    container.setConsumerTagStrategy(new Tag());
    container.afterPropertiesSet();
    container.start();
    assertTrue(latch1.await(10, TimeUnit.SECONDS));
    assertThat(times.get(1) - times.get(0), greaterThanOrEqualTo(50L));
    brokerRunning.getAdmin().deleteQueue(EQ1);
    brokerRunning.getAdmin().deleteQueue(EQ2);
    assertTrue(latch2.await(10, TimeUnit.SECONDS));
    assertNotNull(failEvent.get());
    assertThat(failEvent.get(), instanceOf(ListenerContainerConsumerTerminatedEvent.class));
    container.stop();
    cf.destroy();
}

From source file:org.springframework.amqp.rabbit.listener.DirectMessageListenerContainerTests.java

@Test
public void testErrorHandler() throws Exception {
    brokerRunning.getAdmin().deleteQueue(Q1);
    Queue q1 = new Queue(Q1, true, false, false, new ArgumentBuilder().put("x-dead-letter-exchange", "")
            .put("x-dead-letter-routing-key", DLQ1).get());
    brokerRunning.getAdmin().declareQueue(q1);
    CachingConnectionFactory cf = new CachingConnectionFactory("localhost");
    DirectMessageListenerContainer container = new DirectMessageListenerContainer(cf);
    container.setQueueNames(Q1);//from   www  .  j a v a 2 s.c om
    container.setConsumersPerQueue(2);
    final AtomicReference<Channel> channel = new AtomicReference<>();
    container.setMessageListener((ChannelAwareMessageListener) (m, c) -> {
        channel.set(c);
        throw new MessageConversionException(
                "intended - should be wrapped in an AmqpRejectAndDontRequeueException");
    });
    container.setBeanName("errorHandler");
    container.setConsumerTagStrategy(new Tag());
    container.afterPropertiesSet();
    container.start();
    RabbitTemplate template = new RabbitTemplate(cf);
    template.convertAndSend(Q1, "foo");
    assertNotNull(template.receive(DLQ1, 10000));
    container.stop();
    assertTrue(consumersOnQueue(Q1, 0));
    assertTrue(consumersOnQueue(Q2, 0));
    assertTrue(activeConsumerCount(container, 0));
    assertEquals(0, TestUtils.getPropertyValue(container, "consumersByQueue", MultiValueMap.class).size());
    assertFalse(channel.get().isOpen());
    cf.destroy();
}

From source file:org.springframework.amqp.rabbit.listener.DirectMessageListenerContainerTests.java

private void testRecoverDeletedQueueGuts(boolean autoDeclare) throws Exception {
    CachingConnectionFactory cf = new CachingConnectionFactory("localhost");
    DirectMessageListenerContainer container = new DirectMessageListenerContainer(cf);
    if (autoDeclare) {
        GenericApplicationContext context = new GenericApplicationContext();
        context.getBeanFactory().registerSingleton("foo", new Queue(Q1));
        RabbitAdmin admin = new RabbitAdmin(cf);
        admin.setApplicationContext(context);
        context.getBeanFactory().registerSingleton("admin", admin);
        context.refresh();/*from w ww  .  j a v a  2s.  co m*/
        container.setApplicationContext(context);
    }
    container.setAutoDeclare(autoDeclare);
    container.setQueueNames(Q1, Q2);
    container.setConsumersPerQueue(2);
    container.setConsumersPerQueue(2);
    container.setMessageListener(m -> {
    });
    container.setFailedDeclarationRetryInterval(500);
    container.setBeanName("deleteQauto=" + autoDeclare);
    container.setConsumerTagStrategy(new Tag());
    container.afterPropertiesSet();
    container.start();
    assertTrue(consumersOnQueue(Q1, 2));
    assertTrue(consumersOnQueue(Q2, 2));
    assertTrue(activeConsumerCount(container, 4));
    brokerRunning.getAdmin().deleteQueue(Q1);
    assertTrue(consumersOnQueue(Q2, 2));
    assertTrue(activeConsumerCount(container, 2));
    assertTrue(restartConsumerCount(container, 2));
    if (!autoDeclare) {
        Thread.sleep(2000);
        brokerRunning.getAdmin().declareQueue(new Queue(Q1));
    }
    assertTrue(consumersOnQueue(Q1, 2));
    assertTrue(consumersOnQueue(Q2, 2));
    assertTrue(activeConsumerCount(container, 4));
    container.stop();
    assertTrue(consumersOnQueue(Q1, 0));
    assertTrue(consumersOnQueue(Q2, 0));
    assertTrue(activeConsumerCount(container, 0));
    assertEquals(0, TestUtils.getPropertyValue(container, "consumersByQueue", MultiValueMap.class).size());
    cf.destroy();
}

From source file:org.springframework.amqp.rabbit.test.BrokerFederated.java

@SuppressWarnings("deprecation")
@Override//w w  w . ja  va 2s .c  om
public Statement apply(Statement base, FrameworkMethod method, Object target) {

    // Check at the beginning, so this can be used as a static field
    if (assumeOnline) {
        Assume.assumeTrue(brokerOnline.get(port));
    } else {
        Assume.assumeTrue(brokerOffline.get(port));
    }

    CachingConnectionFactory connectionFactory = new CachingConnectionFactory();

    try {

        connectionFactory.setPort(port);
        if (StringUtils.hasText(hostName)) {
            connectionFactory.setHost(hostName);
        }
        RabbitAdmin admin = new RabbitAdmin(connectionFactory);
        org.springframework.amqp.core.FederatedExchange exchange = new org.springframework.amqp.core.FederatedExchange(
                "fedDirectRuleTest");
        exchange.setBackingType("direct");
        exchange.setUpstreamSet("upstream-set");
        admin.declareExchange(exchange);
        admin.deleteExchange("fedDirectRuleTest");

        brokerOffline.put(port, false);

        if (!assumeOnline) {
            Assume.assumeTrue(brokerOffline.get(port));
        }

    } catch (Exception e) {
        logger.warn("Not executing tests because federated connectivity test failed", e);
        brokerOnline.put(port, false);
        if (assumeOnline) {
            Assume.assumeNoException(e);
        }
    } finally {
        connectionFactory.destroy();
    }

    return super.apply(base, method, target);

}

From source file:org.springframework.cloud.stream.binder.rabbit.RabbitBinderTests.java

@Test
public void testLateBinding() throws Exception {
    RabbitTestSupport.RabbitProxy proxy = new RabbitTestSupport.RabbitProxy();
    CachingConnectionFactory cf = new CachingConnectionFactory("localhost", proxy.getPort());

    RabbitMessageChannelBinder rabbitBinder = new RabbitMessageChannelBinder(cf, new RabbitProperties(),
            new RabbitExchangeQueueProvisioner(cf));
    RabbitTestBinder binder = new RabbitTestBinder(cf, rabbitBinder);

    ExtendedProducerProperties<RabbitProducerProperties> producerProperties = createProducerProperties();
    producerProperties.getExtension().setPrefix("latebinder.");
    producerProperties.getExtension().setAutoBindDlq(true);

    MessageChannel moduleOutputChannel = createBindableChannel("output",
            createProducerBindingProperties(producerProperties));
    Binding<MessageChannel> late0ProducerBinding = binder.bindProducer("late.0", moduleOutputChannel,
            producerProperties);/*from  w  w  w.j a v a2 s. c  o m*/

    QueueChannel moduleInputChannel = new QueueChannel();
    ExtendedConsumerProperties<RabbitConsumerProperties> rabbitConsumerProperties = createConsumerProperties();
    rabbitConsumerProperties.getExtension().setPrefix("latebinder.");
    Binding<MessageChannel> late0ConsumerBinding = binder.bindConsumer("late.0", "test", moduleInputChannel,
            rabbitConsumerProperties);

    producerProperties
            .setPartitionKeyExpression(spelExpressionParser.parseExpression("payload.equals('0') ? 0 : 1"));
    producerProperties.setPartitionSelectorExpression(spelExpressionParser.parseExpression("hashCode()"));
    producerProperties.setPartitionCount(2);

    MessageChannel partOutputChannel = createBindableChannel("output",
            createProducerBindingProperties(producerProperties));
    Binding<MessageChannel> partlate0ProducerBinding = binder.bindProducer("partlate.0", partOutputChannel,
            producerProperties);

    QueueChannel partInputChannel0 = new QueueChannel();
    QueueChannel partInputChannel1 = new QueueChannel();

    ExtendedConsumerProperties<RabbitConsumerProperties> partLateConsumerProperties = createConsumerProperties();
    partLateConsumerProperties.getExtension().setPrefix("latebinder.");
    partLateConsumerProperties.setPartitioned(true);
    partLateConsumerProperties.setInstanceIndex(0);
    Binding<MessageChannel> partlate0Consumer0Binding = binder.bindConsumer("partlate.0", "test",
            partInputChannel0, partLateConsumerProperties);
    partLateConsumerProperties.setInstanceIndex(1);
    Binding<MessageChannel> partlate0Consumer1Binding = binder.bindConsumer("partlate.0", "test",
            partInputChannel1, partLateConsumerProperties);

    ExtendedProducerProperties<RabbitProducerProperties> noDlqProducerProperties = createProducerProperties();
    noDlqProducerProperties.getExtension().setPrefix("latebinder.");
    MessageChannel noDLQOutputChannel = createBindableChannel("output",
            createProducerBindingProperties(noDlqProducerProperties));
    Binding<MessageChannel> noDlqProducerBinding = binder.bindProducer("lateNoDLQ.0", noDLQOutputChannel,
            noDlqProducerProperties);

    QueueChannel noDLQInputChannel = new QueueChannel();
    ExtendedConsumerProperties<RabbitConsumerProperties> noDlqConsumerProperties = createConsumerProperties();
    noDlqConsumerProperties.getExtension().setPrefix("latebinder.");
    Binding<MessageChannel> noDlqConsumerBinding = binder.bindConsumer("lateNoDLQ.0", "test", noDLQInputChannel,
            noDlqConsumerProperties);

    MessageChannel outputChannel = createBindableChannel("output",
            createProducerBindingProperties(noDlqProducerProperties));
    Binding<MessageChannel> pubSubProducerBinding = binder.bindProducer("latePubSub", outputChannel,
            noDlqProducerProperties);
    QueueChannel pubSubInputChannel = new QueueChannel();
    noDlqConsumerProperties.getExtension().setDurableSubscription(false);
    Binding<MessageChannel> nonDurableConsumerBinding = binder.bindConsumer("latePubSub", "lategroup",
            pubSubInputChannel, noDlqConsumerProperties);
    QueueChannel durablePubSubInputChannel = new QueueChannel();
    noDlqConsumerProperties.getExtension().setDurableSubscription(true);
    Binding<MessageChannel> durableConsumerBinding = binder.bindConsumer("latePubSub", "lateDurableGroup",
            durablePubSubInputChannel, noDlqConsumerProperties);

    proxy.start();

    moduleOutputChannel.send(new GenericMessage<>("foo"));
    Message<?> message = moduleInputChannel.receive(10000);
    assertThat(message).isNotNull();
    assertThat(message.getPayload()).isNotNull();

    noDLQOutputChannel.send(new GenericMessage<>("bar"));
    message = noDLQInputChannel.receive(10000);
    assertThat(message);
    assertThat(message.getPayload()).isEqualTo("bar");

    outputChannel.send(new GenericMessage<>("baz"));
    message = pubSubInputChannel.receive(10000);
    assertThat(message);
    assertThat(message.getPayload()).isEqualTo("baz");
    message = durablePubSubInputChannel.receive(10000);
    assertThat(message).isNotNull();
    assertThat(message.getPayload()).isEqualTo("baz");

    partOutputChannel.send(new GenericMessage<>("0"));
    partOutputChannel.send(new GenericMessage<>("1"));
    message = partInputChannel0.receive(10000);
    assertThat(message).isNotNull();
    assertThat(message.getPayload()).isEqualTo("0");
    message = partInputChannel1.receive(10000);
    assertThat(message).isNotNull();
    assertThat(message.getPayload()).isEqualTo("1");

    late0ProducerBinding.unbind();
    late0ConsumerBinding.unbind();
    partlate0ProducerBinding.unbind();
    partlate0Consumer0Binding.unbind();
    partlate0Consumer1Binding.unbind();
    noDlqProducerBinding.unbind();
    noDlqConsumerBinding.unbind();
    pubSubProducerBinding.unbind();
    nonDurableConsumerBinding.unbind();
    durableConsumerBinding.unbind();

    binder.cleanup();

    proxy.stop();
    cf.destroy();

    this.rabbitAvailableRule.getResource().destroy();
}

From source file:org.springframework.integration.amqp.outbound.AsyncAmqpGatewayTests.java

@Test
public void testConfirmsAndReturns() throws Exception {
    CachingConnectionFactory ccf = new CachingConnectionFactory("localhost");
    ccf.setPublisherConfirms(true);/*from  ww w .j a  v  a 2  s. c o  m*/
    ccf.setPublisherReturns(true);
    RabbitTemplate template = new RabbitTemplate(ccf);
    SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(ccf);
    container.setBeanName("replyContainer");
    container.setQueueNames("asyncRQ1");
    container.afterPropertiesSet();
    container.start();
    AsyncRabbitTemplate asyncTemplate = new AsyncRabbitTemplate(template, container);
    asyncTemplate.setEnableConfirms(true);
    asyncTemplate.setMandatory(true);

    SimpleMessageListenerContainer receiver = new SimpleMessageListenerContainer(ccf);
    receiver.setBeanName("receiver");
    receiver.setQueueNames("asyncQ1");
    final CountDownLatch waitForAckBeforeReplying = new CountDownLatch(1);
    MessageListenerAdapter messageListener = new MessageListenerAdapter(
            (ReplyingMessageListener<String, String>) foo -> {
                try {
                    waitForAckBeforeReplying.await(10, TimeUnit.SECONDS);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                return foo.toUpperCase();
            });
    receiver.setMessageListener(messageListener);
    receiver.afterPropertiesSet();
    receiver.start();

    AsyncAmqpOutboundGateway gateway = new AsyncAmqpOutboundGateway(asyncTemplate);
    Log logger = spy(TestUtils.getPropertyValue(gateway, "logger", Log.class));
    given(logger.isDebugEnabled()).willReturn(true);
    final CountDownLatch replyTimeoutLatch = new CountDownLatch(1);
    willAnswer(invocation -> {
        invocation.callRealMethod();
        replyTimeoutLatch.countDown();
        return null;
    }).given(logger).debug(startsWith("Reply not required and async timeout for"));
    new DirectFieldAccessor(gateway).setPropertyValue("logger", logger);
    QueueChannel outputChannel = new QueueChannel();
    outputChannel.setBeanName("output");
    QueueChannel returnChannel = new QueueChannel();
    returnChannel.setBeanName("returns");
    QueueChannel ackChannel = new QueueChannel();
    ackChannel.setBeanName("acks");
    QueueChannel errorChannel = new QueueChannel();
    errorChannel.setBeanName("errors");
    gateway.setOutputChannel(outputChannel);
    gateway.setReturnChannel(returnChannel);
    gateway.setConfirmAckChannel(ackChannel);
    gateway.setConfirmNackChannel(ackChannel);
    gateway.setConfirmCorrelationExpressionString("#this");
    gateway.setExchangeName("");
    gateway.setRoutingKey("asyncQ1");
    gateway.setBeanFactory(mock(BeanFactory.class));
    gateway.afterPropertiesSet();
    gateway.start();

    Message<?> message = MessageBuilder.withPayload("foo").setErrorChannel(errorChannel).build();

    gateway.handleMessage(message);

    Message<?> ack = ackChannel.receive(10000);
    assertNotNull(ack);
    assertEquals("foo", ack.getPayload());
    assertEquals(true, ack.getHeaders().get(AmqpHeaders.PUBLISH_CONFIRM));
    waitForAckBeforeReplying.countDown();

    Message<?> received = outputChannel.receive(10000);
    assertNotNull(received);
    assertEquals("FOO", received.getPayload());

    // timeout tests
    asyncTemplate.setReceiveTimeout(10);

    receiver.setMessageListener(message1 -> {
    });
    // reply timeout with no requiresReply
    message = MessageBuilder.withPayload("bar").setErrorChannel(errorChannel).build();
    gateway.handleMessage(message);
    assertTrue(replyTimeoutLatch.await(10, TimeUnit.SECONDS));

    // reply timeout with requiresReply
    gateway.setRequiresReply(true);
    message = MessageBuilder.withPayload("baz").setErrorChannel(errorChannel).build();
    gateway.handleMessage(message);

    received = errorChannel.receive(10000);
    assertThat(received, instanceOf(ErrorMessage.class));
    ErrorMessage error = (ErrorMessage) received;
    assertThat(error.getPayload(), instanceOf(MessagingException.class));
    assertThat(error.getPayload().getCause(), instanceOf(AmqpReplyTimeoutException.class));
    asyncTemplate.setReceiveTimeout(30000);
    receiver.setMessageListener(messageListener);

    // error on sending result
    DirectChannel errorForce = new DirectChannel();
    errorForce.setBeanName("errorForce");
    errorForce.subscribe(message1 -> {
        throw new RuntimeException("intentional");
    });
    gateway.setOutputChannel(errorForce);
    message = MessageBuilder.withPayload("qux").setErrorChannel(errorChannel).build();
    gateway.handleMessage(message);
    received = errorChannel.receive(10000);
    assertThat(received, instanceOf(ErrorMessage.class));
    error = (ErrorMessage) received;
    assertThat(error.getPayload(), instanceOf(MessagingException.class));
    assertEquals("QUX", ((MessagingException) error.getPayload()).getFailedMessage().getPayload());

    gateway.setRoutingKey(UUID.randomUUID().toString());
    message = MessageBuilder.withPayload("fiz").setErrorChannel(errorChannel).build();
    gateway.handleMessage(message);
    Message<?> returned = returnChannel.receive(10000);
    assertNotNull(returned);
    assertEquals("fiz", returned.getPayload());
    ackChannel.receive(10000);
    ackChannel.purge(null);

    asyncTemplate = mock(AsyncRabbitTemplate.class);
    RabbitMessageFuture future = asyncTemplate.new RabbitMessageFuture(null, null);
    willReturn(future).given(asyncTemplate).sendAndReceive(anyString(), anyString(),
            any(org.springframework.amqp.core.Message.class));
    DirectFieldAccessor dfa = new DirectFieldAccessor(future);
    dfa.setPropertyValue("nackCause", "nacknack");
    SettableListenableFuture<Boolean> confirmFuture = new SettableListenableFuture<Boolean>();
    confirmFuture.set(false);
    dfa.setPropertyValue("confirm", confirmFuture);
    new DirectFieldAccessor(gateway).setPropertyValue("template", asyncTemplate);

    message = MessageBuilder.withPayload("buz").setErrorChannel(errorChannel).build();
    gateway.handleMessage(message);

    ack = ackChannel.receive(10000);
    assertNotNull(ack);
    assertEquals("buz", ack.getPayload());
    assertEquals("nacknack", ack.getHeaders().get(AmqpHeaders.PUBLISH_CONFIRM_NACK_CAUSE));
    assertEquals(false, ack.getHeaders().get(AmqpHeaders.PUBLISH_CONFIRM));

    asyncTemplate.stop();
    receiver.stop();
    ccf.destroy();
}

From source file:org.springframework.integration.amqp.rule.BrokerRunning.java

@Override
public Statement apply(Statement base, Description description) {
    CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
    connectionFactory.setHost("localhost");

    try {/*  ww  w .j ava 2 s  .c o  m*/

        connectionFactory.setPort(PORT);

        RabbitAdmin admin = new RabbitAdmin(connectionFactory);

        for (Queue queue : queues) {
            String queueName = queue.getName();
            logger.info("Deleting queue: " + queueName);
            // Delete completely - gets rid of consumers and bindings as well
            admin.deleteQueue(queueName);

            if (!DEFAULT_QUEUE_NAME.getName().equals(queueName)) {
                admin.declareQueue(queue);
            }
        }

    } catch (final Exception e) {
        logger.warn("Not executing tests because basic connectivity test failed", e);
        Assume.assumeNoException(e);
    } finally {
        connectionFactory.destroy();
    }

    return super.apply(base, description);
}