@Test
 public void testParseWithQueues() throws Exception {
   SimpleMessageListenerContainer container =
       beanFactory.getBean("container2", SimpleMessageListenerContainer.class);
   Queue queue = beanFactory.getBean("bar", Queue.class);
   assertEquals(
       "[foo, " + queue.getName() + "]", Arrays.asList(container.getQueueNames()).toString());
   assertTrue(TestUtils.getPropertyValue(container, "missingQueuesFatal", Boolean.class));
   assertFalse(TestUtils.getPropertyValue(container, "autoDeclare", Boolean.class));
 }
 private void verifyFooRequestProducer(AbstractEndpoint endpoint) {
   List<?> requestMatchers =
       TestUtils.getPropertyValue(
           endpoint, "handler.delegate.headerMapper.requestHeaderMatcher.strategies", List.class);
   assertEquals(1, requestMatchers.size());
   assertEquals(
       "foo",
       TestUtils.getPropertyValue(requestMatchers.get(0), "patterns", Collection.class)
           .iterator()
           .next());
 }
 private void verifyBarReplyConsumer(AbstractEndpoint endpoint) {
   List<?> replyMatchers;
   replyMatchers =
       TestUtils.getPropertyValue(
           endpoint, "headerMapper.replyHeaderMatcher.strategies", List.class);
   assertEquals(1, replyMatchers.size());
   assertEquals(
       "bar",
       TestUtils.getPropertyValue(replyMatchers.get(0), "patterns", Collection.class)
           .iterator()
           .next());
 }
  @Test
  public void testPublisherConfirmReceived() throws Exception {
    final CountDownLatch latch = new CountDownLatch(10000);
    final AtomicInteger acks = new AtomicInteger();
    templateWithConfirmsEnabled.setConfirmCallback(
        new ConfirmCallback() {

          @Override
          public void confirm(CorrelationData correlationData, boolean ack, String cause) {
            acks.incrementAndGet();
            latch.countDown();
          }
        });
    ExecutorService exec = Executors.newCachedThreadPool();
    for (int i = 0; i < 100; i++) {
      exec.submit(
          new Runnable() {

            @Override
            public void run() {
              try {
                for (int i = 0; i < 100; i++) {
                  templateWithConfirmsEnabled.convertAndSend(
                      ROUTE, (Object) "message", new CorrelationData("abc"));
                }
              } catch (Throwable t) {
                t.printStackTrace();
              }
            }
          });
    }
    exec.shutdown();
    assertTrue(exec.awaitTermination(300, TimeUnit.SECONDS));
    assertTrue("" + latch.getCount(), latch.await(60, TimeUnit.SECONDS));
    assertNull(templateWithConfirmsEnabled.getUnconfirmed(-1));
    this.templateWithConfirmsEnabled.execute(
        new ChannelCallback<Void>() {

          @Override
          public Void doInRabbit(Channel channel) throws Exception {
            Map<?, ?> listenerMap =
                TestUtils.getPropertyValue(
                    ((ChannelProxy) channel).getTargetChannel(), "listenerForSeq", Map.class);
            int n = 0;
            while (n++ < 100 && listenerMap.size() > 0) {
              Thread.sleep(100);
            }
            assertEquals(0, listenerMap.size());
            return null;
          }
        });

    Log logger =
        spy(TestUtils.getPropertyValue(connectionFactoryWithConfirmsEnabled, "logger", Log.class));
    new DirectFieldAccessor(connectionFactoryWithConfirmsEnabled)
        .setPropertyValue("logger", logger);
    cleanUp();
    verify(logger, never()).error(any());
  }
 @Test
 public void testParseWithAdviceChain() throws Exception {
   SimpleMessageListenerContainer container =
       beanFactory.getBean("container3", SimpleMessageListenerContainer.class);
   Object adviceChain = ReflectionTestUtils.getField(container, "adviceChain");
   assertNotNull(adviceChain);
   assertEquals(3, ((Advice[]) adviceChain).length);
   assertTrue(TestUtils.getPropertyValue(container, "exclusive", Boolean.class));
 }
 @Test
 public void testParseWithQueueNames() throws Exception {
   SimpleMessageListenerContainer container =
       beanFactory.getBean("container1", SimpleMessageListenerContainer.class);
   assertEquals(AcknowledgeMode.MANUAL, container.getAcknowledgeMode());
   assertEquals(beanFactory.getBean(ConnectionFactory.class), container.getConnectionFactory());
   assertEquals(MessageListenerAdapter.class, container.getMessageListener().getClass());
   DirectFieldAccessor listenerAccessor = new DirectFieldAccessor(container.getMessageListener());
   assertEquals(
       beanFactory.getBean(TestBean.class), listenerAccessor.getPropertyValue("delegate"));
   assertEquals("handle", listenerAccessor.getPropertyValue("defaultListenerMethod"));
   Queue queue = beanFactory.getBean("bar", Queue.class);
   assertEquals(
       "[foo, " + queue.getName() + "]", Arrays.asList(container.getQueueNames()).toString());
   assertEquals(5, ReflectionTestUtils.getField(container, "concurrentConsumers"));
   assertEquals(6, ReflectionTestUtils.getField(container, "maxConcurrentConsumers"));
   assertEquals(1234L, ReflectionTestUtils.getField(container, "startConsumerMinInterval"));
   assertEquals(2345L, ReflectionTestUtils.getField(container, "stopConsumerMinInterval"));
   assertEquals(12, ReflectionTestUtils.getField(container, "consecutiveActiveTrigger"));
   assertEquals(34, ReflectionTestUtils.getField(container, "consecutiveIdleTrigger"));
   assertEquals(9876L, ReflectionTestUtils.getField(container, "receiveTimeout"));
   Map<?, ?> consumerArgs = TestUtils.getPropertyValue(container, "consumerArgs", Map.class);
   assertEquals(1, consumerArgs.size());
   Object xPriority = consumerArgs.get("x-priority");
   assertNotNull(xPriority);
   assertEquals(10, xPriority);
   assertEquals(
       Long.valueOf(5555),
       TestUtils.getPropertyValue(container, "recoveryBackOff.interval", Long.class));
   assertFalse(TestUtils.getPropertyValue(container, "exclusive", Boolean.class));
   assertFalse(TestUtils.getPropertyValue(container, "missingQueuesFatal", Boolean.class));
   assertTrue(TestUtils.getPropertyValue(container, "autoDeclare", Boolean.class));
   assertEquals(5, TestUtils.getPropertyValue(container, "declarationRetries"));
   assertEquals(1000L, TestUtils.getPropertyValue(container, "failedDeclarationRetryInterval"));
   assertEquals(30000L, TestUtils.getPropertyValue(container, "retryDeclarationInterval"));
   assertEquals(
       beanFactory.getBean("tagger"),
       TestUtils.getPropertyValue(container, "consumerTagStrategy"));
   Collection<?> group = beanFactory.getBean("containerGroup", Collection.class);
   assertEquals(3, group.size());
   assertThat(
       group,
       Matchers.contains(
           beanFactory.getBean("container1"),
           beanFactory.getBean("testListener1"),
           beanFactory.getBean("testListener2")));
   assertEquals(1235L, ReflectionTestUtils.getField(container, "idleEventInterval"));
   assertEquals("container1", container.getListenerId());
 }
 @After
 public void closeBeanFactory() throws Exception {
   if (this.context != null) {
     CachingConnectionFactory cf = this.context.getBean(CachingConnectionFactory.class);
     this.context.close();
     assertTrue(
         TestUtils.getPropertyValue(cf, "deferredCloseExecutor", ThreadPoolExecutor.class)
             .isTerminated());
   }
 }
 @Override
 protected void verifyDynamicProperties(MessageBus bus, String type) {
   @SuppressWarnings("unchecked")
   List<Binding> bindings = TestUtils.getPropertyValue(bus, "messageBus.bindings", List.class);
   for (Binding binding : bindings) {
     if (binding.getEndpoint().getComponentName().equals("outbound." + type + ":x")) {
       assertEquals(
           MessageDeliveryMode.PERSISTENT,
           TestUtils.getPropertyValue(
               binding.getEndpoint(),
               "handler.delegate.defaultDeliveryMode",
               MessageDeliveryMode.class));
     } else if (binding.getEndpoint().getComponentName().matches("outbound." + type + ":(y|z)")) {
       assertEquals(
           MessageDeliveryMode.NON_PERSISTENT,
           TestUtils.getPropertyValue(
               binding.getEndpoint(),
               "handler.delegate.defaultDeliveryMode",
               MessageDeliveryMode.class));
     }
   }
 }
Exemplo n.º 9
0
  @Test
  public void addCustomConverter() {
    List<?> customMessageConverters = context.getBean("customMessageConverters", List.class);

    assertEquals(1, customMessageConverters.size());

    ModuleTypeConversionPlugin plugin = context.getBean(ModuleTypeConversionPlugin.class);

    CompositeMessageConverterFactory factory =
        (CompositeMessageConverterFactory) TestUtils.getPropertyValue(plugin, "converterFactory");
    CompositeMessageConverter converters =
        factory.newInstance(MimeType.valueOf("application/x-xd-foo"));
    assertEquals(1, converters.getConverters().size());
    assertTrue(converters.getConverters().iterator().next() instanceof StubPojoToStringConverter);
  }
  @Test
  public void testNackForBadExchange() throws Exception {
    final AtomicBoolean nack = new AtomicBoolean(true);
    final AtomicReference<CorrelationData> correlation = new AtomicReference<CorrelationData>();
    final AtomicReference<String> reason = new AtomicReference<String>();
    final CountDownLatch latch = new CountDownLatch(2);
    this.templateWithConfirmsEnabled.setConfirmCallback(
        new ConfirmCallback() {

          @Override
          public void confirm(CorrelationData correlationData, boolean ack, String cause) {
            nack.set(ack);
            correlation.set(correlationData);
            reason.set(cause);
            latch.countDown();
          }
        });
    Log logger =
        spy(TestUtils.getPropertyValue(connectionFactoryWithConfirmsEnabled, "logger", Log.class));
    new DirectFieldAccessor(connectionFactoryWithConfirmsEnabled)
        .setPropertyValue("logger", logger);
    final AtomicReference<String> log = new AtomicReference<String>();
    doAnswer(
            new Answer<Object>() {

              @Override
              public Object answer(InvocationOnMock invocation) throws Throwable {
                log.set((String) invocation.getArguments()[0]);
                invocation.callRealMethod();
                latch.countDown();
                return null;
              }
            })
        .when(logger)
        .error(any());

    CorrelationData correlationData = new CorrelationData("bar");
    String exchange = UUID.randomUUID().toString();
    this.templateWithConfirmsEnabled.convertAndSend(exchange, "key", "foo", correlationData);
    assertTrue(latch.await(10, TimeUnit.SECONDS));
    assertFalse(nack.get());
    assertEquals(correlationData.toString(), correlation.get().toString());
    assertThat(reason.get(), containsString("NOT_FOUND - no exchange '" + exchange));
    assertThat(log.get(), containsString("NOT_FOUND - no exchange '" + exchange));
  }
Exemplo n.º 11
0
 @Override
 protected String getPubSubEndpointRouting(AbstractEndpoint endpoint) {
   return TestUtils.getPropertyValue(
           endpoint, "handler.delegate.exchangeNameExpression", SpelExpression.class)
       .getExpressionString();
 }
Exemplo n.º 12
0
  private SimpleMessageListenerContainer verifyContainer(AbstractEndpoint endpoint) {
    SimpleMessageListenerContainer container;
    Advice retry;
    container =
        TestUtils.getPropertyValue(
            endpoint, "messageListenerContainer", SimpleMessageListenerContainer.class);
    assertEquals(AcknowledgeMode.NONE, container.getAcknowledgeMode());
    assertThat(container.getQueueNames()[0], startsWith("foo.props.0"));
    assertFalse(TestUtils.getPropertyValue(container, "transactional", Boolean.class));
    assertEquals(2, TestUtils.getPropertyValue(container, "concurrentConsumers"));
    assertEquals(3, TestUtils.getPropertyValue(container, "maxConcurrentConsumers"));
    assertFalse(TestUtils.getPropertyValue(container, "defaultRequeueRejected", Boolean.class));
    assertEquals(20, TestUtils.getPropertyValue(container, "prefetchCount"));
    assertEquals(10, TestUtils.getPropertyValue(container, "txSize"));
    retry = TestUtils.getPropertyValue(container, "adviceChain", Advice[].class)[0];
    assertEquals(23, TestUtils.getPropertyValue(retry, "retryOperations.retryPolicy.maxAttempts"));
    assertEquals(
        2000L, TestUtils.getPropertyValue(retry, "retryOperations.backOffPolicy.initialInterval"));
    assertEquals(
        20000L, TestUtils.getPropertyValue(retry, "retryOperations.backOffPolicy.maxInterval"));
    assertEquals(
        5.0, TestUtils.getPropertyValue(retry, "retryOperations.backOffPolicy.multiplier"));

    List<?> requestMatchers =
        TestUtils.getPropertyValue(
            endpoint, "headerMapper.requestHeaderMatcher.strategies", List.class);
    assertEquals(1, requestMatchers.size());
    assertEquals(
        "foo",
        TestUtils.getPropertyValue(requestMatchers.get(0), "patterns", Collection.class)
            .iterator()
            .next());

    return container;
  }
Exemplo n.º 13
0
  @SuppressWarnings("unchecked")
  @Test
  public void testBatchingAndCompression() throws Exception {
    RabbitTemplate template = new RabbitTemplate(this.rabbitAvailableRule.getResource());
    MessageBus bus = getMessageBus();
    Properties properties = new Properties();
    properties.put("deliveryMode", "NON_PERSISTENT");
    properties.put("batchingEnabled", "true");
    properties.put("batchSize", "2");
    properties.put("batchBufferLimit", "100000");
    properties.put("batchTimeout", "30000");
    properties.put("compress", "true");

    DirectChannel output = new DirectChannel();
    output.setBeanName("batchingProducer");
    bus.bindProducer("batching.0", output, properties);

    while (template.receive("xdbus.batching.0") != null) {}

    Log logger =
        spy(
            TestUtils.getPropertyValue(
                bus, "messageBus.compressingPostProcessor.logger", Log.class));
    new DirectFieldAccessor(TestUtils.getPropertyValue(bus, "messageBus.compressingPostProcessor"))
        .setPropertyValue("logger", logger);
    when(logger.isTraceEnabled()).thenReturn(true);

    assertEquals(
        Deflater.BEST_SPEED,
        TestUtils.getPropertyValue(bus, "messageBus.compressingPostProcessor.level"));

    output.send(new GenericMessage<>("foo".getBytes()));
    output.send(new GenericMessage<>("bar".getBytes()));

    Object out = spyOn("batching.0").receive(false);
    assertThat(out, instanceOf(byte[].class));
    assertEquals(
        "\u0000\u0000\u0000\u0003foo\u0000\u0000\u0000\u0003bar", new String((byte[]) out));

    ArgumentCaptor<Object> captor = ArgumentCaptor.forClass(Object.class);
    verify(logger).trace(captor.capture());
    assertThat(captor.getValue().toString(), containsString("Compressed 14 to "));

    QueueChannel input = new QueueChannel();
    input.setBeanName("batchingConsumer");
    bus.bindConsumer("batching.0", input, null);

    output.send(new GenericMessage<>("foo".getBytes()));
    output.send(new GenericMessage<>("bar".getBytes()));

    Message<byte[]> in = (Message<byte[]>) input.receive(10000);
    assertNotNull(in);
    assertEquals("foo", new String(in.getPayload()));
    in = (Message<byte[]>) input.receive(10000);
    assertNotNull(in);
    assertEquals("bar", new String(in.getPayload()));
    assertNull(in.getHeaders().get(AmqpHeaders.DELIVERY_MODE));

    bus.unbindProducers("batching.0");
    bus.unbindConsumers("batching.0");
  }
Exemplo n.º 14
0
  @Test
  public void testRequestReplyReplierProperties() throws Exception {
    MessageBus bus = getMessageBus();
    Properties properties = new Properties();
    properties.put("prefix", "foo.");
    properties.put("deliveryMode", "NON_PERSISTENT");

    properties.put("requestHeaderPatterns", "foo");
    properties.put("replyHeaderPatterns", "bar");

    properties.put("ackMode", "NONE");
    properties.put("backOffInitialInterval", "2000");
    properties.put("backOffMaxInterval", "20000");
    properties.put("backOffMultiplier", "5.0");
    properties.put("concurrency", "2");
    properties.put("maxAttempts", "23");
    properties.put("maxConcurrency", "3");
    properties.put("prefix", "foo.");
    properties.put("prefetch", "20");
    properties.put("requeue", "false");
    properties.put("txSize", "10");

    bus.bindReplier("props.0", new DirectChannel(), new DirectChannel(), properties);
    @SuppressWarnings("unchecked")
    List<Binding> bindings = TestUtils.getPropertyValue(bus, "messageBus.bindings", List.class);

    assertEquals(2, bindings.size());
    AbstractEndpoint endpoint = bindings.get(1).getEndpoint(); // producer
    assertEquals(
        "headers['amqp_replyTo']",
        TestUtils.getPropertyValue(
                endpoint, "handler.delegate.routingKeyExpression", SpelExpression.class)
            .getExpressionString());
    MessageDeliveryMode mode =
        TestUtils.getPropertyValue(
            endpoint, "handler.delegate.defaultDeliveryMode", MessageDeliveryMode.class);
    assertEquals(MessageDeliveryMode.NON_PERSISTENT, mode);

    verifyFooRequestBarReplyProducer(endpoint);

    endpoint = bindings.get(0).getEndpoint(); // consumer

    verifyContainer(endpoint);

    verifyBarReplyConsumer(endpoint);

    properties.put("partitionKeyExpression", "'foo'");
    properties.put("partitionKeyExtractorClass", "foo");
    properties.put("partitionSelectorExpression", "0");
    properties.put("partitionSelectorClass", "foo");
    properties.put(BusProperties.NEXT_MODULE_COUNT, "1");
    properties.put("partitionIndex", "0");
    try {
      bus.bindReplier("dummy", null, null, properties);
      fail("Expected exception");
    } catch (IllegalArgumentException e) {
      assertThat(
          e.getMessage(),
          allOf(
              containsString("RabbitMessageBus does not support consumer properties: "),
              containsString("partitionSelectorExpression"),
              containsString("partitionKeyExtractorClass"),
              containsString("partitionKeyExpression"),
              containsString("partitionSelectorClass")));
      assertThat(
          e.getMessage(), allOf(containsString("partitionIndex"), containsString("for dummy.")));
    }

    bus.unbindConsumers("props.0");
    bus.unbindProducers("props.0");
    assertEquals(0, bindings.size());
  }
Exemplo n.º 15
0
  @Test
  public void testProducerProperties() throws Exception {
    MessageBus bus = getMessageBus();
    bus.bindProducer("props.0", new DirectChannel(), null);
    @SuppressWarnings("unchecked")
    List<Binding> bindings = TestUtils.getPropertyValue(bus, "messageBus.bindings", List.class);
    assertEquals(1, bindings.size());
    AbstractEndpoint endpoint = bindings.get(0).getEndpoint();
    assertEquals(
        "xdbus.props.0", TestUtils.getPropertyValue(endpoint, "handler.delegate.routingKey"));
    MessageDeliveryMode mode =
        TestUtils.getPropertyValue(
            endpoint, "handler.delegate.defaultDeliveryMode", MessageDeliveryMode.class);
    assertEquals(MessageDeliveryMode.PERSISTENT, mode);
    List<?> requestHeaders =
        TestUtils.getPropertyValue(
            endpoint, "handler.delegate.headerMapper.requestHeaderMatcher.strategies", List.class);
    assertEquals(2, requestHeaders.size());
    bus.unbindProducers("props.0");
    assertEquals(0, bindings.size());

    Properties properties = new Properties();
    properties.put("prefix", "foo.");
    properties.put("deliveryMode", "NON_PERSISTENT");
    properties.put("requestHeaderPatterns", "foo");
    properties.put("partitionKeyExpression", "'foo'");
    properties.put("partitionKeyExtractorClass", "foo");
    properties.put("partitionSelectorExpression", "0");
    properties.put("partitionSelectorClass", "foo");
    properties.put(BusProperties.NEXT_MODULE_COUNT, "2");

    bus.bindProducer("props.0", new DirectChannel(), properties);
    assertEquals(1, bindings.size());
    endpoint = bindings.get(0).getEndpoint();
    assertEquals(
        "'foo.props.0-' + headers['partition']",
        TestUtils.getPropertyValue(
                endpoint, "handler.delegate.routingKeyExpression", SpelExpression.class)
            .getExpressionString());
    mode =
        TestUtils.getPropertyValue(
            endpoint, "handler.delegate.defaultDeliveryMode", MessageDeliveryMode.class);
    assertEquals(MessageDeliveryMode.NON_PERSISTENT, mode);
    verifyFooRequestProducer(endpoint);

    try {
      bus.bindPubSubProducer("dummy", new DirectChannel(), properties);
      fail("Expected exception");
    } catch (IllegalArgumentException e) {
      assertThat(
          e.getMessage(),
          allOf(
              containsString("RabbitMessageBus does not support producer properties: "),
              containsString("partitionSelectorExpression"),
              containsString("partitionKeyExtractorClass"),
              containsString("partitionKeyExpression"),
              containsString("partitionSelectorClass")));
      assertThat(e.getMessage(), containsString("for dummy."));
    }
    try {
      bus.bindProducer("queue:dummy", new DirectChannel(), properties);
      fail("Expected exception");
    } catch (IllegalArgumentException e) {
      assertThat(
          e.getMessage(),
          allOf(
              containsString("RabbitMessageBus does not support producer properties: "),
              containsString("partitionSelectorExpression"),
              containsString("partitionKeyExtractorClass"),
              containsString("partitionKeyExpression"),
              containsString("partitionSelectorClass")));
      assertThat(e.getMessage(), containsString("for queue:dummy."));
    }

    bus.unbindProducers("props.0");
    assertEquals(0, bindings.size());
  }
Exemplo n.º 16
0
  @Test
  public void testConsumerProperties() throws Exception {
    MessageBus bus = getMessageBus();
    Properties properties = new Properties();
    properties.put(
        "transacted", "true"); // test transacted with defaults; not allowed with ackmode NONE
    bus.bindConsumer("props.0", new DirectChannel(), properties);
    @SuppressWarnings("unchecked")
    List<Binding> bindings = TestUtils.getPropertyValue(bus, "messageBus.bindings", List.class);
    assertEquals(1, bindings.size());
    AbstractEndpoint endpoint = bindings.get(0).getEndpoint();
    SimpleMessageListenerContainer container =
        TestUtils.getPropertyValue(
            endpoint, "messageListenerContainer", SimpleMessageListenerContainer.class);
    assertEquals(AcknowledgeMode.AUTO, container.getAcknowledgeMode());
    assertEquals("xdbus.props.0", container.getQueueNames()[0]);
    assertTrue(TestUtils.getPropertyValue(container, "transactional", Boolean.class));
    assertEquals(1, TestUtils.getPropertyValue(container, "concurrentConsumers"));
    assertNull(TestUtils.getPropertyValue(container, "maxConcurrentConsumers"));
    assertTrue(TestUtils.getPropertyValue(container, "defaultRequeueRejected", Boolean.class));
    assertEquals(1, TestUtils.getPropertyValue(container, "prefetchCount"));
    assertEquals(1, TestUtils.getPropertyValue(container, "txSize"));
    Advice retry = TestUtils.getPropertyValue(container, "adviceChain", Advice[].class)[0];
    assertEquals(3, TestUtils.getPropertyValue(retry, "retryOperations.retryPolicy.maxAttempts"));
    assertEquals(
        1000L, TestUtils.getPropertyValue(retry, "retryOperations.backOffPolicy.initialInterval"));
    assertEquals(
        10000L, TestUtils.getPropertyValue(retry, "retryOperations.backOffPolicy.maxInterval"));
    assertEquals(
        2.0, TestUtils.getPropertyValue(retry, "retryOperations.backOffPolicy.multiplier"));
    bus.unbindConsumers("props.0");
    assertEquals(0, bindings.size());

    properties = new Properties();
    properties.put("ackMode", "NONE");
    properties.put("backOffInitialInterval", "2000");
    properties.put("backOffMaxInterval", "20000");
    properties.put("backOffMultiplier", "5.0");
    properties.put("concurrency", "2");
    properties.put("maxAttempts", "23");
    properties.put("maxConcurrency", "3");
    properties.put("prefix", "foo.");
    properties.put("prefetch", "20");
    properties.put("requestHeaderPatterns", "foo");
    properties.put("requeue", "false");
    properties.put("txSize", "10");
    properties.put("partitionIndex", 0);
    bus.bindConsumer("props.0", new DirectChannel(), properties);

    @SuppressWarnings("unchecked")
    List<Binding> bindingsNow = TestUtils.getPropertyValue(bus, "messageBus.bindings", List.class);
    assertEquals(1, bindingsNow.size());
    endpoint = bindingsNow.get(0).getEndpoint();
    container = verifyContainer(endpoint);

    assertEquals("foo.props.0", container.getQueueNames()[0]);

    try {
      bus.bindPubSubConsumer("dummy", null, properties);
      fail("Expected exception");
    } catch (IllegalArgumentException e) {
      assertThat(
          e.getMessage(),
          allOf(
              containsString("RabbitMessageBus does not support consumer properties: "),
              containsString("partitionIndex"),
              containsString("concurrency"),
              containsString(" for dummy.")));
    }
    try {
      bus.bindConsumer("queue:dummy", null, properties);
      fail("Expected exception");
    } catch (IllegalArgumentException e) {
      assertEquals(
          "RabbitMessageBus does not support consumer property: partitionIndex for queue:dummy.",
          e.getMessage());
    }

    bus.unbindConsumers("props.0");
    assertEquals(0, bindingsNow.size());
  }