Example usage for com.rabbitmq.client ConnectionFactory newConnection

Introduction

In this page you can find the example usage for com.rabbitmq.client ConnectionFactory newConnection.

Prototype

public Connection newConnection(ExecutorService executor) throws IOException, TimeoutException 

Source Link

Document

Create a new broker connection.

Usage

From source file:org.springframework.amqp.rabbit.core.RabbitTemplatePublisherCallbacksIntegrationTests.java

License:Apache License

/**
 * Tests that piggy-backed confirms (multiple=true) are distributed to the proper
 * template./*w w w . ja v a2  s .c om*/
 * @throws Exception
 */
@Test
public void testPublisherConfirmMultipleWithTwoListeners() throws Exception {
    ConnectionFactory mockConnectionFactory = mock(ConnectionFactory.class);
    Connection mockConnection = mock(Connection.class);
    Channel mockChannel = mock(Channel.class);

    when(mockConnectionFactory.newConnection((ExecutorService) null)).thenReturn(mockConnection);
    when(mockConnection.isOpen()).thenReturn(true);
    PublisherCallbackChannelImpl callbackChannel = new PublisherCallbackChannelImpl(mockChannel);
    when(mockConnection.createChannel()).thenReturn(callbackChannel);

    final AtomicInteger count = new AtomicInteger();
    doAnswer(new Answer<Object>() {
        @Override
        public Object answer(InvocationOnMock invocation) throws Throwable {
            return count.incrementAndGet();
        }
    }).when(mockChannel).getNextPublishSeqNo();

    final RabbitTemplate template1 = new RabbitTemplate(new SingleConnectionFactory(mockConnectionFactory));

    final Set<String> confirms = new HashSet<String>();
    final CountDownLatch latch1 = new CountDownLatch(1);
    template1.setConfirmCallback(new ConfirmCallback() {

        @Override
        public void confirm(CorrelationData correlationData, boolean ack, String cause) {
            if (ack) {
                confirms.add(correlationData.getId() + "1");
                latch1.countDown();
            }
        }
    });
    final RabbitTemplate template2 = new RabbitTemplate(new SingleConnectionFactory(mockConnectionFactory));

    final CountDownLatch latch2 = new CountDownLatch(1);
    template2.setConfirmCallback(new ConfirmCallback() {

        @Override
        public void confirm(CorrelationData correlationData, boolean ack, String cause) {
            if (ack) {
                confirms.add(correlationData.getId() + "2");
                latch2.countDown();
            }
        }
    });
    template1.convertAndSend(ROUTE, (Object) "message", new CorrelationData("abc"));
    template2.convertAndSend(ROUTE, (Object) "message", new CorrelationData("def"));
    template2.convertAndSend(ROUTE, (Object) "message", new CorrelationData("ghi"));
    callbackChannel.handleAck(3, true);
    assertTrue(latch1.await(1000, TimeUnit.MILLISECONDS));
    assertTrue(latch2.await(1000, TimeUnit.MILLISECONDS));
    Collection<CorrelationData> unconfirmed1 = template1.getUnconfirmed(0);
    assertNull(unconfirmed1);
    Collection<CorrelationData> unconfirmed2 = template2.getUnconfirmed(0);
    assertNull(unconfirmed2);
    assertTrue(confirms.contains("abc1"));
    assertTrue(confirms.contains("def2"));
    assertTrue(confirms.contains("ghi2"));
    assertEquals(3, confirms.size());
}

---

From source file:org.springframework.amqp.rabbit.core.RabbitTemplatePublisherCallbacksIntegrationTests.java

License:Apache License

/**
 * AMQP-262/*from  ww  w. j  a  v a  2s .  c  om*/
 * Sets up a situation where we are processing 'multi' acks at the same
 * time as adding a new pending ack to the map. Test verifies we don't
 * get a {@link ConcurrentModificationException}.
 */
@SuppressWarnings({ "rawtypes", "unchecked", "deprecation" })
@Test
public void testConcurrentConfirms() throws Exception {
    ConnectionFactory mockConnectionFactory = mock(ConnectionFactory.class);
    Connection mockConnection = mock(Connection.class);
    Channel mockChannel = mock(Channel.class);
    when(mockChannel.getNextPublishSeqNo()).thenReturn(1L, 2L, 3L, 4L);

    when(mockConnectionFactory.newConnection((ExecutorService) null)).thenReturn(mockConnection);
    when(mockConnection.isOpen()).thenReturn(true);
    final PublisherCallbackChannelImpl channel = new PublisherCallbackChannelImpl(mockChannel);
    when(mockConnection.createChannel()).thenReturn(channel);

    final RabbitTemplate template = new RabbitTemplate(new SingleConnectionFactory(mockConnectionFactory));

    final CountDownLatch first2SentOnThread1Latch = new CountDownLatch(1);
    final CountDownLatch delayAckProcessingLatch = new CountDownLatch(1);
    final CountDownLatch startedProcessingMultiAcksLatch = new CountDownLatch(1);
    final CountDownLatch waitForAll3AcksLatch = new CountDownLatch(3);
    final CountDownLatch allSentLatch = new CountDownLatch(1);
    final AtomicInteger acks = new AtomicInteger();
    template.setConfirmCallback(new ConfirmCallback() {

        @Override
        public void confirm(CorrelationData correlationData, boolean ack, String cause) {
            try {
                startedProcessingMultiAcksLatch.countDown();
                // delay processing here; ensures thread 2 put would be concurrent
                delayAckProcessingLatch.await(2, TimeUnit.SECONDS);
                // only delay first time through
                delayAckProcessingLatch.countDown();
                waitForAll3AcksLatch.countDown();
                acks.incrementAndGet();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
    Executors.newSingleThreadExecutor().execute(new Runnable() {
        @Override
        public void run() {
            template.convertAndSend(ROUTE, (Object) "message", new CorrelationData("abc"));
            template.convertAndSend(ROUTE, (Object) "message", new CorrelationData("def"));
            first2SentOnThread1Latch.countDown();
        }
    });
    Executors.newSingleThreadExecutor().execute(new Runnable() {
        @Override
        public void run() {
            try {
                startedProcessingMultiAcksLatch.await();
                template.convertAndSend(ROUTE, (Object) "message", new CorrelationData("ghi"));
                allSentLatch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
    assertTrue(first2SentOnThread1Latch.await(10, TimeUnit.SECONDS));
    // there should be no concurrent execution exception here
    channel.handleAck(2, true);
    assertTrue(allSentLatch.await(10, TimeUnit.SECONDS));
    channel.handleAck(3, false);
    assertTrue(waitForAll3AcksLatch.await(10, TimeUnit.SECONDS));
    assertEquals(3, acks.get());

    // 3.3.1 client
    channel.basicConsume("foo", false, (Map) null, (Consumer) null);
    verify(mockChannel).basicConsume("foo", false, (Map) null, (Consumer) null);

    channel.basicQos(3, false);
    verify(mockChannel).basicQos(3, false);

    doReturn(true).when(mockChannel).flowBlocked();
    assertTrue(channel.flowBlocked());

    try {
        channel.flow(true);
        fail("Expected exception");
    } catch (UnsupportedOperationException e) {
    }

    try {
        channel.getFlow();
        fail("Expected exception");
    } catch (UnsupportedOperationException e) {
    }

    // 3.2.4 client
    /*
          try {
             channel.basicConsume("foo", false, (Map) null, (Consumer) null);
             fail("Expected exception");
          }
          catch (UnsupportedOperationException e) {}
            
          try {
             channel.basicQos(3, false);
             fail("Expected exception");
          }
          catch (UnsupportedOperationException e) {}
            
          try {
             channel.flowBlocked();
             fail("Expected exception");
          }
          catch (UnsupportedOperationException e) {}
            
          channel.flow(true);
          verify(mockChannel).flow(true);
            
          channel.getFlow();
          verify(mockChannel).getFlow();
    */
}

---

From source file:org.springframework.amqp.rabbit.core.RabbitTemplateTests.java

License:Apache License

@Test
public void returnConnectionAfterCommit() throws Exception {
    @SuppressWarnings("serial")
    TransactionTemplate txTemplate = new TransactionTemplate(new AbstractPlatformTransactionManager() {

        @Override//w ww  .j  a v  a 2  s.com
        protected Object doGetTransaction() throws TransactionException {
            return new Object();
        }

        @Override
        protected void doBegin(Object transaction, TransactionDefinition definition)
                throws TransactionException {
        }

        @Override
        protected void doCommit(DefaultTransactionStatus status) throws TransactionException {
        }

        @Override
        protected void doRollback(DefaultTransactionStatus status) throws TransactionException {
        }
    });
    ConnectionFactory mockConnectionFactory = mock(ConnectionFactory.class);
    Connection mockConnection = mock(Connection.class);
    Channel mockChannel = mock(Channel.class);

    when(mockConnectionFactory.newConnection((ExecutorService) null)).thenReturn(mockConnection);
    when(mockConnection.isOpen()).thenReturn(true);
    when(mockConnection.createChannel()).thenReturn(mockChannel);

    when(mockChannel.isOpen()).thenReturn(true);

    final RabbitTemplate template = new RabbitTemplate(new CachingConnectionFactory(mockConnectionFactory));
    template.setChannelTransacted(true);

    txTemplate.execute(new TransactionCallback<Object>() {
        @Override
        public Object doInTransaction(TransactionStatus status) {
            template.convertAndSend("foo", "bar");
            return null;
        }
    });
    txTemplate.execute(new TransactionCallback<Object>() {
        @Override
        public Object doInTransaction(TransactionStatus status) {
            template.convertAndSend("baz", "qux");
            return null;
        }
    });
    verify(mockConnectionFactory, Mockito.times(1)).newConnection(Mockito.any(ExecutorService.class));
    // ensure we used the same channel
    verify(mockConnection, Mockito.times(1)).createChannel();
}

---

From source file:org.springframework.amqp.rabbit.core.RabbitTemplateTests.java

License:Apache License

@SuppressWarnings("unchecked")
@Test // AMQP-249
public void dontHangConsumerThread() throws Exception {
    ConnectionFactory mockConnectionFactory = mock(ConnectionFactory.class);
    Connection mockConnection = mock(Connection.class);
    Channel mockChannel = mock(Channel.class);

    when(mockConnectionFactory.newConnection((ExecutorService) null)).thenReturn(mockConnection);
    when(mockConnection.isOpen()).thenReturn(true);
    when(mockConnection.createChannel()).thenReturn(mockChannel);

    when(mockChannel.queueDeclare()).thenReturn(new AMQImpl.Queue.DeclareOk("foo", 0, 0));

    final AtomicReference<Consumer> consumer = new AtomicReference<Consumer>();
    doAnswer(new Answer<Object>() {
        @Override/*from  w ww .j a  v a  2s  .  c  o m*/
        public Object answer(InvocationOnMock invocation) throws Throwable {
            consumer.set((Consumer) invocation.getArguments()[6]);
            return null;
        }
    }).when(mockChannel).basicConsume(Mockito.anyString(), Mockito.anyBoolean(), Mockito.anyString(),
            Mockito.anyBoolean(), Mockito.anyBoolean(), Mockito.anyMap(), Mockito.any(Consumer.class));
    RabbitTemplate template = new RabbitTemplate(new SingleConnectionFactory(mockConnectionFactory));
    template.setReplyTimeout(1);
    Message input = new Message("Hello, world!".getBytes(), new MessageProperties());
    template.doSendAndReceiveWithTemporary("foo", "bar", input);
    Envelope envelope = new Envelope(1, false, "foo", "bar");
    // used to hang here because of the SynchronousQueue and doSendAndReceive() already exited
    consumer.get().handleDelivery("foo", envelope, new AMQP.BasicProperties(), new byte[0]);
}

---

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

License:Apache License

/**
 * Verifies that an up-stack RabbitTemplate uses the listener's
 * channel (MessageListener)./*from   w w  w . j  a v  a2 s.  co  m*/
 */
@SuppressWarnings("unchecked")
@Test
public void testMessageListener() throws Exception {
    ConnectionFactory mockConnectionFactory = mock(ConnectionFactory.class);
    Connection mockConnection = mock(Connection.class);
    final Channel onlyChannel = mock(Channel.class);
    when(onlyChannel.isOpen()).thenReturn(true);

    final CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory(
            mockConnectionFactory);

    when(mockConnectionFactory.newConnection((ExecutorService) null)).thenReturn(mockConnection);
    when(mockConnection.isOpen()).thenReturn(true);

    final AtomicReference<Exception> tooManyChannels = new AtomicReference<Exception>();

    doAnswer(new Answer<Channel>() {
        boolean done;

        @Override
        public Channel answer(InvocationOnMock invocation) throws Throwable {
            if (!done) {
                done = true;
                return onlyChannel;
            }
            tooManyChannels.set(new Exception("More than one channel requested"));
            Channel channel = mock(Channel.class);
            when(channel.isOpen()).thenReturn(true);
            return channel;
        }
    }).when(mockConnection).createChannel();

    final AtomicReference<Consumer> consumer = new AtomicReference<Consumer>();

    doAnswer(new Answer<String>() {

        @Override
        public String answer(InvocationOnMock invocation) throws Throwable {
            consumer.set((Consumer) invocation.getArguments()[6]);
            return null;
        }
    }).when(onlyChannel).basicConsume(anyString(), anyBoolean(), anyString(), anyBoolean(), anyBoolean(),
            anyMap(), any(Consumer.class));

    final CountDownLatch commitLatch = new CountDownLatch(1);
    doAnswer(new Answer<String>() {

        @Override
        public String answer(InvocationOnMock invocation) throws Throwable {
            commitLatch.countDown();
            return null;
        }
    }).when(onlyChannel).txCommit();

    final CountDownLatch latch = new CountDownLatch(1);
    SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(cachingConnectionFactory);
    container.setMessageListener(new MessageListener() {
        @Override
        public void onMessage(Message message) {
            RabbitTemplate rabbitTemplate = new RabbitTemplate(cachingConnectionFactory);
            rabbitTemplate.setChannelTransacted(true);
            // should use same channel as container
            rabbitTemplate.convertAndSend("foo", "bar", "baz");
            latch.countDown();
        }
    });
    container.setQueueNames("queue");
    container.setChannelTransacted(true);
    container.setShutdownTimeout(100);
    container.setTransactionManager(new DummyTxManager());
    container.afterPropertiesSet();
    container.start();

    consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(),
            new byte[] { 0 });

    assertTrue(latch.await(10, TimeUnit.SECONDS));

    Exception e = tooManyChannels.get();
    if (e != null) {
        throw e;
    }

    verify(mockConnection, Mockito.times(1)).createChannel();
    assertTrue(commitLatch.await(10, TimeUnit.SECONDS));
    verify(onlyChannel).txCommit();
    verify(onlyChannel).basicPublish(Mockito.anyString(), Mockito.anyString(), Mockito.anyBoolean(),
            Mockito.any(BasicProperties.class), Mockito.any(byte[].class));

    // verify close() was never called on the channel
    DirectFieldAccessor dfa = new DirectFieldAccessor(cachingConnectionFactory);
    List<?> channels = (List<?>) dfa.getPropertyValue("cachedChannelsTransactional");
    assertEquals(0, channels.size());

    container.stop();

}

---

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

License:Apache License

/**
 * Verifies that an up-stack RabbitTemplate does not use the listener's
 * channel when it has its own connection factory.
 *//*from   w ww  . j  a  v  a2s.  c o m*/
@SuppressWarnings("unchecked")
@Test
public void testMessageListenerTemplateUsesDifferentConnectionFactory() throws Exception {
    ConnectionFactory listenerConnectionFactory = mock(ConnectionFactory.class);
    ConnectionFactory templateConnectionFactory = mock(ConnectionFactory.class);
    Connection listenerConnection = mock(Connection.class);
    Connection templateConnection = mock(Connection.class);
    final Channel listenerChannel = mock(Channel.class);
    Channel templateChannel = mock(Channel.class);
    when(listenerChannel.isOpen()).thenReturn(true);
    when(templateChannel.isOpen()).thenReturn(true);

    final CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory(
            listenerConnectionFactory);
    final CachingConnectionFactory cachingTemplateConnectionFactory = new CachingConnectionFactory(
            templateConnectionFactory);

    when(listenerConnectionFactory.newConnection((ExecutorService) null)).thenReturn(listenerConnection);
    when(listenerConnection.isOpen()).thenReturn(true);
    when(templateConnectionFactory.newConnection((ExecutorService) null)).thenReturn(templateConnection);
    when(templateConnection.isOpen()).thenReturn(true);
    when(templateConnection.createChannel()).thenReturn(templateChannel);

    final AtomicReference<Exception> tooManyChannels = new AtomicReference<Exception>();

    doAnswer(new Answer<Channel>() {
        boolean done;

        @Override
        public Channel answer(InvocationOnMock invocation) throws Throwable {
            if (!done) {
                done = true;
                return listenerChannel;
            }
            tooManyChannels.set(new Exception("More than one channel requested"));
            Channel channel = mock(Channel.class);
            when(channel.isOpen()).thenReturn(true);
            return channel;
        }
    }).when(listenerConnection).createChannel();

    final AtomicReference<Consumer> consumer = new AtomicReference<Consumer>();

    doAnswer(new Answer<String>() {

        @Override
        public String answer(InvocationOnMock invocation) throws Throwable {
            consumer.set((Consumer) invocation.getArguments()[6]);
            return null;
        }
    }).when(listenerChannel).basicConsume(anyString(), anyBoolean(), anyString(), anyBoolean(), anyBoolean(),
            anyMap(), any(Consumer.class));

    final CountDownLatch commitLatch = new CountDownLatch(2);
    doAnswer(new Answer<String>() {

        @Override
        public String answer(InvocationOnMock invocation) throws Throwable {
            commitLatch.countDown();
            return null;
        }
    }).when(listenerChannel).txCommit();
    doAnswer(new Answer<String>() {

        @Override
        public String answer(InvocationOnMock invocation) throws Throwable {
            commitLatch.countDown();
            return null;
        }
    }).when(templateChannel).txCommit();

    final CountDownLatch latch = new CountDownLatch(1);
    SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(cachingConnectionFactory);
    container.setMessageListener(new MessageListener() {
        @Override
        public void onMessage(Message message) {
            RabbitTemplate rabbitTemplate = new RabbitTemplate(cachingTemplateConnectionFactory);
            rabbitTemplate.setChannelTransacted(true);
            // should use same channel as container
            rabbitTemplate.convertAndSend("foo", "bar", "baz");
            latch.countDown();
        }
    });
    container.setQueueNames("queue");
    container.setChannelTransacted(true);
    container.setShutdownTimeout(100);
    container.setTransactionManager(new DummyTxManager());
    container.afterPropertiesSet();
    container.start();

    consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(),
            new byte[] { 0 });

    assertTrue(latch.await(10, TimeUnit.SECONDS));

    Exception e = tooManyChannels.get();
    if (e != null) {
        throw e;
    }

    verify(listenerConnection, Mockito.times(1)).createChannel();
    verify(templateConnection, Mockito.times(1)).createChannel();
    assertTrue(commitLatch.await(10, TimeUnit.SECONDS));
    verify(listenerChannel).txCommit();
    verify(templateChannel).basicPublish(Mockito.anyString(), Mockito.anyString(), Mockito.anyBoolean(),
            Mockito.any(BasicProperties.class), Mockito.any(byte[].class));
    verify(templateChannel).txCommit();

    // verify close() was never called on the channel
    DirectFieldAccessor dfa = new DirectFieldAccessor(cachingConnectionFactory);
    List<?> channels = (List<?>) dfa.getPropertyValue("cachedChannelsTransactional");
    assertEquals(0, channels.size());

    container.stop();

}

---

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

License:Apache License

/**
 * Verifies that an up-stack RabbitTemplate uses the listener's
 * channel (ChannelAwareMessageListener).
 *//*  w w w  .  j a  v  a2  s  .  co  m*/
@SuppressWarnings("unchecked")
@Test
public void testChannelAwareMessageListener() throws Exception {
    ConnectionFactory mockConnectionFactory = mock(ConnectionFactory.class);
    Connection mockConnection = mock(Connection.class);
    final Channel onlyChannel = mock(Channel.class);
    when(onlyChannel.isOpen()).thenReturn(true);

    final SingleConnectionFactory singleConnectionFactory = new SingleConnectionFactory(mockConnectionFactory);

    when(mockConnectionFactory.newConnection((ExecutorService) null)).thenReturn(mockConnection);
    when(mockConnection.isOpen()).thenReturn(true);

    final AtomicReference<Exception> tooManyChannels = new AtomicReference<Exception>();

    doAnswer(new Answer<Channel>() {
        boolean done;

        @Override
        public Channel answer(InvocationOnMock invocation) throws Throwable {
            if (!done) {
                done = true;
                return onlyChannel;
            }
            tooManyChannels.set(new Exception("More than one channel requested"));
            Channel channel = mock(Channel.class);
            when(channel.isOpen()).thenReturn(true);
            return channel;
        }
    }).when(mockConnection).createChannel();

    final AtomicReference<Consumer> consumer = new AtomicReference<Consumer>();

    doAnswer(new Answer<String>() {

        @Override
        public String answer(InvocationOnMock invocation) throws Throwable {
            consumer.set((Consumer) invocation.getArguments()[6]);
            return null;
        }
    }).when(onlyChannel).basicConsume(anyString(), anyBoolean(), anyString(), anyBoolean(), anyBoolean(),
            anyMap(), any(Consumer.class));

    final CountDownLatch commitLatch = new CountDownLatch(1);
    doAnswer(new Answer<String>() {

        @Override
        public String answer(InvocationOnMock invocation) throws Throwable {
            commitLatch.countDown();
            return null;
        }
    }).when(onlyChannel).txCommit();

    final CountDownLatch latch = new CountDownLatch(1);
    final AtomicReference<Channel> exposed = new AtomicReference<Channel>();
    SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(singleConnectionFactory);
    container.setMessageListener(new ChannelAwareMessageListener() {
        @Override
        public void onMessage(Message message, Channel channel) {
            exposed.set(channel);
            RabbitTemplate rabbitTemplate = new RabbitTemplate(singleConnectionFactory);
            rabbitTemplate.setChannelTransacted(true);
            // should use same channel as container
            rabbitTemplate.convertAndSend("foo", "bar", "baz");
            latch.countDown();
        }

    });
    container.setQueueNames("queue");
    container.setChannelTransacted(true);
    container.setShutdownTimeout(100);
    container.setTransactionManager(new DummyTxManager());
    container.afterPropertiesSet();
    container.start();

    consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(),
            new byte[] { 0 });

    assertTrue(latch.await(10, TimeUnit.SECONDS));

    Exception e = tooManyChannels.get();
    if (e != null) {
        throw e;
    }

    verify(mockConnection, Mockito.times(1)).createChannel();
    assertTrue(commitLatch.await(10, TimeUnit.SECONDS));
    verify(onlyChannel).txCommit();
    verify(onlyChannel).basicPublish(Mockito.anyString(), Mockito.anyString(), Mockito.anyBoolean(),
            Mockito.any(BasicProperties.class), Mockito.any(byte[].class));

    // verify close() was never called on the channel
    verify(onlyChannel, Mockito.never()).close();

    container.stop();

    assertSame(onlyChannel, exposed.get());
}

---

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

License:Apache License

/**
 * Verifies that an up-stack RabbitTemplate uses the listener's
 * channel (ChannelAwareMessageListener). exposeListenerChannel=false
 * is ignored (ChannelAwareMessageListener).
 *//*from  w w w.  ja  v a2  s  .  com*/
@SuppressWarnings("unchecked")
@Test
public void testChannelAwareMessageListenerDontExpose() throws Exception {
    ConnectionFactory mockConnectionFactory = mock(ConnectionFactory.class);
    Connection mockConnection = mock(Connection.class);
    final Channel onlyChannel = mock(Channel.class);
    when(onlyChannel.isOpen()).thenReturn(true);

    final SingleConnectionFactory singleConnectionFactory = new SingleConnectionFactory(mockConnectionFactory);

    when(mockConnectionFactory.newConnection((ExecutorService) null)).thenReturn(mockConnection);
    when(mockConnection.isOpen()).thenReturn(true);

    final AtomicReference<Exception> tooManyChannels = new AtomicReference<Exception>();

    doAnswer(new Answer<Channel>() {
        boolean done;

        @Override
        public Channel answer(InvocationOnMock invocation) throws Throwable {
            if (!done) {
                done = true;
                return onlyChannel;
            }
            tooManyChannels.set(new Exception("More than one channel requested"));
            Channel channel = mock(Channel.class);
            when(channel.isOpen()).thenReturn(true);
            return channel;
        }
    }).when(mockConnection).createChannel();

    final AtomicReference<Consumer> consumer = new AtomicReference<Consumer>();

    doAnswer(new Answer<String>() {

        @Override
        public String answer(InvocationOnMock invocation) throws Throwable {
            consumer.set((Consumer) invocation.getArguments()[6]);
            return null;
        }
    }).when(onlyChannel).basicConsume(anyString(), anyBoolean(), anyString(), anyBoolean(), anyBoolean(),
            anyMap(), any(Consumer.class));

    final CountDownLatch commitLatch = new CountDownLatch(1);
    doAnswer(new Answer<String>() {

        @Override
        public String answer(InvocationOnMock invocation) throws Throwable {
            commitLatch.countDown();
            return null;
        }
    }).when(onlyChannel).txCommit();

    final CountDownLatch latch = new CountDownLatch(1);
    final AtomicReference<Channel> exposed = new AtomicReference<Channel>();
    SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(singleConnectionFactory);
    container.setMessageListener(new ChannelAwareMessageListener() {
        @Override
        public void onMessage(Message message, Channel channel) {
            exposed.set(channel);
            RabbitTemplate rabbitTemplate = new RabbitTemplate(singleConnectionFactory);
            rabbitTemplate.setChannelTransacted(true);
            // should use same channel as container
            rabbitTemplate.convertAndSend("foo", "bar", "baz");
            latch.countDown();
        }

    });
    container.setQueueNames("queue");
    container.setChannelTransacted(true);
    container.setExposeListenerChannel(false);
    container.setShutdownTimeout(100);
    container.setTransactionManager(new DummyTxManager());
    container.afterPropertiesSet();
    container.start();

    consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(),
            new byte[] { 0 });

    assertTrue(latch.await(10, TimeUnit.SECONDS));

    Exception e = tooManyChannels.get();
    if (e != null) {
        throw e;
    }

    verify(mockConnection, Mockito.times(1)).createChannel();
    assertTrue(commitLatch.await(10, TimeUnit.SECONDS));
    verify(onlyChannel).txCommit();
    verify(onlyChannel).basicPublish(Mockito.anyString(), Mockito.anyString(), Mockito.anyBoolean(),
            Mockito.any(BasicProperties.class), Mockito.any(byte[].class));

    // verify close() was never called on the channel
    verify(onlyChannel, Mockito.never()).close();

    container.stop();

    assertSame(onlyChannel, exposed.get());
}

---

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

License:Apache License

/**
 * Verifies the proper channel is bound when using a RabbitTransactionManager.
 * Previously, the wrong channel was bound. See AMQP-260.
 * @throws Exception/*  w ww.j  a v  a 2 s .  co m*/
 */
@SuppressWarnings("unchecked")
@Test
public void testMessageListenerWithRabbitTxManager() throws Exception {
    ConnectionFactory mockConnectionFactory = mock(ConnectionFactory.class);
    Connection mockConnection = mock(Connection.class);
    final Channel onlyChannel = mock(Channel.class);
    when(onlyChannel.isOpen()).thenReturn(true);

    final CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory(
            mockConnectionFactory);

    when(mockConnectionFactory.newConnection((ExecutorService) null)).thenReturn(mockConnection);
    when(mockConnection.isOpen()).thenReturn(true);

    final AtomicReference<Exception> tooManyChannels = new AtomicReference<Exception>();

    doAnswer(new Answer<Channel>() {
        boolean done;

        @Override
        public Channel answer(InvocationOnMock invocation) throws Throwable {
            if (!done) {
                done = true;
                return onlyChannel;
            }
            tooManyChannels.set(new Exception("More than one channel requested"));
            Channel channel = mock(Channel.class);
            when(channel.isOpen()).thenReturn(true);
            return channel;
        }
    }).when(mockConnection).createChannel();

    final AtomicReference<Consumer> consumer = new AtomicReference<Consumer>();

    doAnswer(new Answer<String>() {

        @Override
        public String answer(InvocationOnMock invocation) throws Throwable {
            consumer.set((Consumer) invocation.getArguments()[6]);
            return null;
        }
    }).when(onlyChannel).basicConsume(anyString(), anyBoolean(), anyString(), anyBoolean(), anyBoolean(),
            anyMap(), any(Consumer.class));

    final CountDownLatch commitLatch = new CountDownLatch(1);
    doAnswer(new Answer<String>() {

        @Override
        public String answer(InvocationOnMock invocation) throws Throwable {
            commitLatch.countDown();
            return null;
        }
    }).when(onlyChannel).txCommit();

    final CountDownLatch latch = new CountDownLatch(1);
    SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(cachingConnectionFactory);
    container.setMessageListener(new MessageListener() {
        @Override
        public void onMessage(Message message) {
            RabbitTemplate rabbitTemplate = new RabbitTemplate(cachingConnectionFactory);
            rabbitTemplate.setChannelTransacted(true);
            // should use same channel as container
            rabbitTemplate.convertAndSend("foo", "bar", "baz");
            latch.countDown();
        }
    });
    container.setQueueNames("queue");
    container.setChannelTransacted(true);
    container.setShutdownTimeout(100);
    container.setTransactionManager(new RabbitTransactionManager(cachingConnectionFactory));
    container.afterPropertiesSet();
    container.start();

    consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(),
            new byte[] { 0 });

    assertTrue(latch.await(10, TimeUnit.SECONDS));

    Exception e = tooManyChannels.get();
    if (e != null) {
        throw e;
    }

    verify(mockConnection, Mockito.times(1)).createChannel();
    assertTrue(commitLatch.await(10, TimeUnit.SECONDS));
    verify(onlyChannel).txCommit();
    verify(onlyChannel).basicPublish(Mockito.anyString(), Mockito.anyString(), Mockito.anyBoolean(),
            Mockito.any(BasicProperties.class), Mockito.any(byte[].class));

    // verify close() was never called on the channel
    DirectFieldAccessor dfa = new DirectFieldAccessor(cachingConnectionFactory);
    List<?> channels = (List<?>) dfa.getPropertyValue("cachedChannelsTransactional");
    assertEquals(0, channels.size());

    container.stop();
}

---

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

License:Apache License

/**
 * Verifies that an up-stack RabbitTemplate uses the listener's
 * channel (MessageListener).//from  w w w .  j  a  va  2  s. c  o  m
 */
@SuppressWarnings("unchecked")
@Test
public void testMessageListener() throws Exception {
    ConnectionFactory mockConnectionFactory = mock(ConnectionFactory.class);
    Connection mockConnection = mock(Connection.class);
    final Channel onlyChannel = mock(Channel.class);
    when(onlyChannel.isOpen()).thenReturn(true);

    final CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory(
            mockConnectionFactory);

    when(mockConnectionFactory.newConnection((ExecutorService) null)).thenReturn(mockConnection);
    when(mockConnection.isOpen()).thenReturn(true);

    final AtomicReference<Exception> tooManyChannels = new AtomicReference<Exception>();

    doAnswer(new Answer<Channel>() {
        boolean done;

        @Override
        public Channel answer(InvocationOnMock invocation) throws Throwable {
            if (!done) {
                done = true;
                return onlyChannel;
            }
            tooManyChannels.set(new Exception("More than one channel requested"));
            Channel channel = mock(Channel.class);
            when(channel.isOpen()).thenReturn(true);
            return channel;
        }
    }).when(mockConnection).createChannel();

    final AtomicReference<Consumer> consumer = new AtomicReference<Consumer>();

    doAnswer(new Answer<String>() {

        @Override
        public String answer(InvocationOnMock invocation) throws Throwable {
            consumer.set((Consumer) invocation.getArguments()[6]);
            return null;
        }
    }).when(onlyChannel).basicConsume(anyString(), anyBoolean(), anyString(), anyBoolean(), anyBoolean(),
            anyMap(), any(Consumer.class));

    final CountDownLatch commitLatch = new CountDownLatch(1);
    doAnswer(new Answer<String>() {

        @Override
        public String answer(InvocationOnMock invocation) throws Throwable {
            commitLatch.countDown();
            return null;
        }
    }).when(onlyChannel).txCommit();

    final CountDownLatch latch = new CountDownLatch(1);
    SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(cachingConnectionFactory);
    container.setMessageListener(new MessageListener() {
        @Override
        public void onMessage(Message message) {
            RabbitTemplate rabbitTemplate = new RabbitTemplate(cachingConnectionFactory);
            rabbitTemplate.setChannelTransacted(true);
            // should use same channel as container
            rabbitTemplate.convertAndSend("foo", "bar", "baz");
            latch.countDown();
        }
    });
    container.setQueueNames("queue");
    container.setChannelTransacted(true);
    container.setShutdownTimeout(100);
    container.afterPropertiesSet();
    container.start();

    consumer.get().handleDelivery("qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(),
            new byte[] { 0 });

    assertTrue(latch.await(10, TimeUnit.SECONDS));

    Exception e = tooManyChannels.get();
    if (e != null) {
        throw e;
    }

    verify(mockConnection, Mockito.times(1)).createChannel();
    assertTrue(commitLatch.await(10, TimeUnit.SECONDS));
    verify(onlyChannel).txCommit();
    verify(onlyChannel).basicPublish(Mockito.anyString(), Mockito.anyString(), Mockito.anyBoolean(),
            Mockito.any(BasicProperties.class), Mockito.any(byte[].class));

    // verify close() was never called on the channel
    DirectFieldAccessor dfa = new DirectFieldAccessor(cachingConnectionFactory);
    List<?> channels = (List<?>) dfa.getPropertyValue("cachedChannelsTransactional");
    assertEquals(0, channels.size());

    container.stop();

}

---

• «
• 1
• 2
• 3
• 4
• 5
• »