org.apache.activemq.broker.jmx.QueueViewMBean Java Examples

@Test(timeout = 40000)
public void testBrowseAllInQueueTxSession() throws Exception {
    connection = createAmqpConnection();
    connection.start();

    Session session = connection.createSession(true, Session.SESSION_TRANSACTED);
    assertNotNull(session);
    Queue queue = session.createQueue(getDestinationName());
    sendToAmqQueue(5);

    QueueViewMBean proxy = getProxyToQueue(getDestinationName());
    assertEquals(5, proxy.getQueueSize());

    QueueBrowser browser = session.createBrowser(queue);
    assertNotNull(browser);
    Enumeration enumeration = browser.getEnumeration();
    int count = 0;
    while (enumeration.hasMoreElements()) {
        Message msg = (Message) enumeration.nextElement();
        assertNotNull(msg);
        LOG.debug("Recv: {}", msg);
        count++;
    }
    assertFalse(enumeration.hasMoreElements());
    assertEquals(5, count);
}
 

@Test(timeout = 60000)
public void testAckedMessageAreConsumed() throws Exception {
    connection = createAmqpConnection();
    connection.start();

    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    assertNotNull(session);
    Queue queue = session.createQueue(name.getMethodName());
    MessageConsumer consumer = session.createConsumer(queue);

    sendToAmqQueue(1);

    final QueueViewMBean proxy = getProxyToQueue(name.getMethodName());
    assertEquals(1, proxy.getQueueSize());

    assertNotNull("Failed to receive any message.", consumer.receive(3000));

    assertTrue("Queued message not consumed.", Wait.waitFor(new Wait.Condition() {

        @Override
        public boolean isSatisfied() throws Exception {
            return proxy.getQueueSize() == 0;
        }
    }));
}
 

public void testPurgeLargeQueueWithConsumer() throws Exception {
   applyBrokerSpoolingPolicy();
   createProducerAndSendMessages(NUM_TO_SEND);
   QueueViewMBean proxy = getProxyToQueueViewMBean();
   createConsumer();
   long start = System.currentTimeMillis();
   LOG.info("purging..");
   proxy.purge();
   LOG.info("purge done: " + (System.currentTimeMillis() - start) + "ms");
   assertEquals("Queue size is not zero, it's " + proxy.getQueueSize(), 0, proxy.getQueueSize());
   assertEquals("usage goes to duck", 0, proxy.getMemoryPercentUsage());
   Message msg;
   do {
      msg = consumer.receive(1000);
      if (msg != null) {
         msg.acknowledge();
      }
   } while (msg != null);
   assertEquals("Queue size not valid", 0, proxy.getQueueSize());
}
 

@Test(timeout=60000)
public void testCloseSessionRollsBack() throws Exception {
    connection = createAmqpConnection();
    connection.start();

    sendToAmqQueue(2);

    QueueViewMBean proxy = getProxyToQueue(name.getMethodName());
    assertEquals(2, proxy.getQueueSize());

    Session session = connection.createSession(true, Session.SESSION_TRANSACTED);
    Queue queue = session.createQueue(name.getMethodName());
    MessageConsumer consumer = session.createConsumer(queue);
    Message message = consumer.receive(5000);
    assertNotNull(message);
    message = consumer.receive(5000);
    assertNotNull(message);

    assertEquals(2, proxy.getQueueSize());
    session.close();
    assertEquals(2, proxy.getQueueSize());
}
 

@Test(timeout = 60000)
public void testTXProducerRollbacksNotQueued() throws Exception {
    final int MSG_COUNT = 10;
    connection = createAmqpConnection();
    connection.start();
    Session session = connection.createSession(true, Session.SESSION_TRANSACTED);
    Queue queue = session.createQueue(name.getMethodName());
    MessageProducer producer = session.createProducer(queue);

    for (int i = 0; i < MSG_COUNT; ++i) {
        producer.send(session.createTextMessage());
    }

    QueueViewMBean proxy = getProxyToQueue(name.getMethodName());
    session.rollback();
    assertEquals(0, proxy.getQueueSize());
}
 

/**
 * This test ensures that the queueViewMbean will work.
 *
 * @throws Exception
 */
public void testQueueViewMbean() throws Exception {

   try {
      addMessages();

      validateCounts(MESSAGE_COUNT, MESSAGE_COUNT, MESSAGE_COUNT * 2);

      List<String> tokens = Arrays.asList(new String[]{"*"});
      for (String token : tokens) {
         List<ObjectInstance> queueList = JmxMBeansUtil.queryMBeans(createJmxConnection(), "type=Broker,brokerName=localbroker,destinationType=Queue,destinationName=" + token);

         for (ObjectInstance queue : queueList) {
            ObjectName queueName = queue.getObjectName();
            QueueViewMBean proxy = MBeanServerInvocationHandler.newProxyInstance(createJmxConnection(), queueName, QueueViewMBean.class, true);
            int removed = proxy.removeMatchingMessages(MSG_SEL_WITH_PROPERTY);
            LOG.info("Removed: " + removed);
         }
      }

      validateCounts(0, MESSAGE_COUNT, MESSAGE_COUNT);

   } finally {
      purgeAllMessages();
   }
}
 

@Test(timeout = 40000)
public void testNoMessagesBrowserHasNoElements() throws Exception {
    connection = createAmqpConnection();
    connection.start();

    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    assertNotNull(session);
    Queue queue = session.createQueue(getDestinationName());
    session.createConsumer(queue).close();

    QueueBrowser browser = session.createBrowser(queue);
    assertNotNull(browser);

    QueueViewMBean proxy = getProxyToQueue(getDestinationName());
    assertEquals(0, proxy.getQueueSize());

    Enumeration enumeration = browser.getEnumeration();
    assertFalse(enumeration.hasMoreElements());
}
 

@Test
public void testCreateQueueSender() throws Exception {
    JmsConnectionFactory factory = new JmsConnectionFactory(getBrokerAmqpConnectionURI());
    QueueConnection connection = factory.createQueueConnection();
    assertNotNull(connection);

    QueueSession session = connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
    assertNotNull(session);
    Queue queue = session.createQueue(name.getMethodName());
    QueueSender sender = session.createSender(queue);
    assertNotNull(sender);

    QueueViewMBean proxy = getProxyToQueue(name.getMethodName());
    assertEquals(0, proxy.getQueueSize());
    connection.close();
}
 

private Object[] browseQueueWithJmx(BrokerService broker) throws Exception {
   Hashtable<String, String> params = new Hashtable<>();
   params.put("brokerName", broker.getBrokerName());
   params.put("type", "Broker");
   params.put("destinationType", "Queue");
   params.put("destinationName", queueName);
   ObjectName queueObjectName = ObjectName.getInstance(amqDomain, params);

   ManagementContext mgmtCtx = broker.getManagementContext();
   QueueViewMBean queueView = (QueueViewMBean) mgmtCtx.newProxyInstance(queueObjectName, QueueViewMBean.class, true);

   Object[] messages = queueView.browse();

   LOG.info("+Browsed with JMX: " + messages.length);

   return messages;
}
 

public void testBrowseExpiredMessages() throws Exception {
   JMXServiceURL url = new JMXServiceURL("service:jmx:rmi:///jndi/rmi://localhost:1199/jmxrmi");
   JMXConnector connector = JMXConnectorFactory.connect(url, null);
   connector.connect();
   MBeanServerConnection connection = connector.getMBeanServerConnection();
   ObjectName name = new ObjectName("org.apache.activemq:type=Broker,brokerName=localhost," + "destinationType=Queue,destinationName=TEST.Q");
   QueueViewMBean queueMbean = MBeanServerInvocationHandler.newProxyInstance(connection, name, QueueViewMBean.class, true);
   HashMap<String, String> headers = new HashMap<>();
   headers.put("timeToLive", Long.toString(2000));
   headers.put("JMSDeliveryMode", Integer.toString(DeliveryMode.PERSISTENT));
   queueMbean.sendTextMessage(headers, "test", "system", "manager");
   // allow message to expire on the queue
   TimeUnit.SECONDS.sleep(4);

   Connection c = new ActiveMQConnectionFactory("vm://localhost").createConnection("system", "manager");
   c.start();

   // browser consumer will force expiration check on addConsumer
   QueueBrowser browser = c.createSession(false, Session.AUTO_ACKNOWLEDGE).createBrowser(new ActiveMQQueue("TEST.Q"));
   assertTrue("no message in the q", !browser.getEnumeration().hasMoreElements());

   // verify dlq got the message, no security exception as brokers context is now used
   browser = c.createSession(false, Session.AUTO_ACKNOWLEDGE).createBrowser(new ActiveMQQueue("ActiveMQ.DLQ"));
   assertTrue("one message in the dlq", browser.getEnumeration().hasMoreElements());
}
 

@Test(timeout = 60000)
public void testSyncConsumeFromQueue() throws Exception {
    connection = createAmqpConnection();
    connection.start();

    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    assertNotNull(session);
    Queue queue = session.createQueue(name.getMethodName());
    MessageConsumer consumer = session.createConsumer(queue);

    sendToAmqQueue(1);

    final QueueViewMBean proxy = getProxyToQueue(name.getMethodName());
    assertEquals(1, proxy.getQueueSize());

    assertNotNull("Failed to receive any message.", consumer.receive(3000));

    assertTrue("Queued message not consumed.", Wait.waitFor(new Wait.Condition() {

        @Override
        public boolean isSatisfied() throws Exception {
            return proxy.getQueueSize() == 0;
        }
    }));
}
 

@Test(timeout = 60000)
public void testSendJMSBytesMessage() throws Exception {
    connection = createAmqpConnection();
    connection.start();

    String payload = "TEST";

    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    assertNotNull(session);
    Queue queue = session.createQueue(name.getMethodName());
    MessageProducer producer = session.createProducer(queue);
    BytesMessage message = session.createBytesMessage();
    message.writeUTF(payload);
    producer.send(message);
    QueueViewMBean proxy = getProxyToQueue(name.getMethodName());
    assertEquals(1, proxy.getQueueSize());

    MessageConsumer consumer = session.createConsumer(queue);
    Message received = consumer.receive(5000);
    assertNotNull(received);
    assertTrue(received instanceof BytesMessage);
    BytesMessage bytes = (BytesMessage) received;
    assertEquals(payload, bytes.readUTF());
}
 

@Test(timeout = 60000)
public void testTXProducerReusesMessage() throws Exception {
    final int MSG_COUNT = 10;
    connection = createAmqpConnection();
    connection.start();
    Session session = connection.createSession(true, Session.SESSION_TRANSACTED);
    Session nonTxSession = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    Queue queue = session.createQueue(name.getMethodName());
    MessageConsumer consumer = nonTxSession.createConsumer(queue);
    MessageProducer producer = session.createProducer(queue);

    TextMessage message = session.createTextMessage();
    for (int i = 0; i < MSG_COUNT; ++i) {
        message.setText("Sequence: " + i);
        producer.send(message);
    }

    Message msg = consumer.receive(1000);
    assertNull(msg);

    QueueViewMBean proxy = getProxyToQueue(name.getMethodName());
    session.commit();
    assertEquals(MSG_COUNT, proxy.getQueueSize());
}
 

@Test(timeout = 60000)
public void testSendJMSMapMessage() throws Exception {
    connection = createAmqpConnection();
    connection.start();

    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    assertNotNull(session);
    Queue queue = session.createQueue(name.getMethodName());
    MessageProducer producer = session.createProducer(queue);
    MapMessage message = session.createMapMessage();
    message.setBoolean("Boolean", false);
    message.setString("STRING", "TEST");
    producer.send(message);
    QueueViewMBean proxy = getProxyToQueue(name.getMethodName());
    assertEquals(1, proxy.getQueueSize());

    MessageConsumer consumer = session.createConsumer(queue);
    Message received = consumer.receive(5000);
    assertNotNull(received);
    assertTrue(received instanceof MapMessage);
    MapMessage map = (MapMessage) received;
    assertEquals("TEST", map.getString("STRING"));
    assertEquals(false, map.getBooleanProperty("Boolean"));
}
 

@Test(timeout = 60000)
public void testSendJMSStreamMessage() throws Exception {
    connection = createAmqpConnection();
    connection.start();

    String payload = "TEST";

    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    assertNotNull(session);
    Queue queue = session.createQueue(name.getMethodName());
    MessageProducer producer = session.createProducer(queue);
    StreamMessage message = session.createStreamMessage();
    message.writeString(payload);
    producer.send(message);
    QueueViewMBean proxy = getProxyToQueue(name.getMethodName());
    assertEquals(1, proxy.getQueueSize());

    MessageConsumer consumer = session.createConsumer(queue);
    Message received = consumer.receive(5000);
    assertNotNull(received);
    assertTrue(received instanceof StreamMessage);
    StreamMessage stream = (StreamMessage) received;
    assertEquals(payload, stream.readString());
}
 

@Test
public void oneConsumedForProfile() throws Exception {
    connection = createAmqpConnection();
    connection.start();

    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    Queue queue = session.createQueue(getDestinationName());
    MessageProducer producer = session.createProducer(queue);
    producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);

    TextMessage message = session.createTextMessage();
    message.setText("hello");
    producer.send(message);
    producer.close();

    QueueViewMBean queueView = getProxyToQueue(getDestinationName());
    assertEquals("Queue should have a message", 1, queueView.getQueueSize());

    MessageConsumer consumer = session.createConsumer(queue);
    Message received = consumer.receive(7000);
    assertNotNull(received);
    consumer.close();

    assertEquals("Queue should have ano messages", 0, queueView.getQueueSize());
}
 

@Test(timeout = 60000)
public void testSendJMSTextMessage() throws Exception {
    connection = createAmqpConnection();
    connection.start();

    String payload = "TEST";

    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    assertNotNull(session);
    Queue queue = session.createQueue(name.getMethodName());
    MessageProducer producer = session.createProducer(queue);
    TextMessage message = session.createTextMessage("TEST");
    producer.send(message);
    QueueViewMBean proxy = getProxyToQueue(name.getMethodName());
    assertEquals(1, proxy.getQueueSize());

    MessageConsumer consumer = session.createConsumer(queue);
    Message received = consumer.receive(5000);
    assertNotNull(received);
    assertTrue(received instanceof TextMessage);
    TextMessage text = (TextMessage) received;
    assertEquals(payload, text.getText());
}
 

@Test(timeout = 20000)
public void testProducerWithNoTTLSendsMessagesWithoutTTL() throws Exception {
    connection = createAmqpConnection();
    assertNotNull(connection);
    connection.start();

    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    assertNotNull(session);
    Queue queue = session.createQueue(name.getMethodName());
    MessageProducer producer = session.createProducer(queue);

    QueueViewMBean proxy = getProxyToQueue(name.getMethodName());
    assertEquals(0, proxy.getQueueSize());

    Message message = session.createMessage();
    producer.send(message);

    assertEquals(1, proxy.getQueueSize());

    MessageConsumer consumer = session.createConsumer(queue);
    message = consumer.receive(5000);
    assertNotNull(message);
    assertEquals(0, message.getJMSExpiration());
}
 

@Test
public void testSendNonPersistentQueueMessagesAMQP() throws Exception {
    connection = createAmqpConnection();
    Session session = connection.createSession(true, Session.SESSION_TRANSACTED);
    Destination destination = session.createQueue(getDestinationName());
    MessageProducer producer = session.createProducer(destination);
    QueueViewMBean queueView = getProxyToQueue(getDestinationName());

    // Warm
    produceMessages(session, producer);

    long totalCycleTime = 0;
    for (int i = 0; i < ITERATIONS; i++) {
        totalCycleTime += produceMessages(session, producer);
        queueView.purge();
    }

    long smoothedTime = totalCycleTime / ITERATIONS;

    LOG.info("Total time for QPid client = {}", TimeUnit.NANOSECONDS.toMillis(smoothedTime));
}
 

@Test
public void testProduceRateToQueue() throws Exception {

    connection = createAmqpConnection();
    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    Queue queue = session.createQueue(getDestinationName());

    // Warm Up the broker.
    produceMessages(queue, MSG_COUNT);

    QueueViewMBean queueView = getProxyToQueue(getDestinationName());
    queueView.purge();

    List<Long> sendTimes = new ArrayList<Long>();
    long cumulative = 0;

    for (int i = 0; i < NUM_RUNS; ++i) {
        long result = produceMessages(queue, MSG_COUNT);
        sendTimes.add(result);
        cumulative += result;
        LOG.info("Time to send {} queue messages: {} ms", MSG_COUNT, result);
        queueView.purge();
    }

    long smoothed = cumulative / NUM_RUNS;
    LOG.info("Smoothed send time for {} messages: {}", MSG_COUNT, smoothed);
    TimeUnit.SECONDS.sleep(1);
}
 

protected QueueViewMBean getProxyToQueue(BrokerService broker, String name) throws MalformedObjectNameException, JMSException {
    ObjectName queueViewMBeanName = new ObjectName(
        broker.getBrokerObjectName() + ",destinationType=Queue,destinationName=" + name);
    QueueViewMBean proxy = (QueueViewMBean) brokerService.getManagementContext()
            .newProxyInstance(queueViewMBeanName, QueueViewMBean.class, true);
    return proxy;
}
 

@Test(timeout = 60000)
public void testBlockingReceivesUnBlocksOnMessageSend() throws Exception {
    connection = createAmqpConnection();
    connection.start();

    final Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    Queue queue = session.createQueue(getDestinationName());

    final MessageProducer producer = session.createProducer(queue);

    Thread producerThread = new Thread(new Runnable() {

        @Override
        public void run() {
            try {
                Thread.sleep(1500);
                producer.send(session.createTextMessage("Hello World! 1"));
            } catch (Exception e) {
            }
        }
    });
    producerThread.start();

    MessageConsumer consumer = session.createConsumer(queue);
    Message answer = consumer.receive();
    assertNotNull("Should have received a message!", answer);

    final QueueViewMBean queueView = getProxyToQueue(getDestinationName());

    // Assert that we only pulled one message and that we didn't cause
    // the other message to be dispatched.
    assertTrue(Wait.waitFor(new Wait.Condition() {

        @Override
        public boolean isSatisfied() throws Exception {
            return queueView.getQueueSize() == 0;
        }
    }));
}
 

protected QueueViewMBean getProxyToTemporaryQueue(BrokerService broker, String name) throws MalformedObjectNameException, JMSException {
    name = JMXSupport.encodeObjectNamePart(name);
    ObjectName queueViewMBeanName = new ObjectName(
        broker.getBrokerObjectName() + ",destinationType=TempQueue,destinationName=" + name);
    QueueViewMBean proxy = (QueueViewMBean) brokerService.getManagementContext()
            .newProxyInstance(queueViewMBeanName, QueueViewMBean.class, true);
    return proxy;
}
 

@Test
public void testConsumeRateFromQueue() throws Exception {
    connection = createAmqpConnection();
    connection.start();

    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    Queue queue = session.createQueue(getDestinationName());

    // Warm Up the broker.
    produceMessages(queue, MSG_COUNT);
    consumerMessages(queue, MSG_COUNT);
    QueueViewMBean queueView = getProxyToQueue(getDestinationName());
    queueView.purge();

    List<Long> sendTimes = new ArrayList<Long>();
    long cumulative = 0;

    for (int i = 0; i < NUM_RUNS; ++i) {
        produceMessages(queue, MSG_COUNT);
        long result = consumerMessages(queue, MSG_COUNT);
        sendTimes.add(result);
        cumulative += result;
        LOG.info("Time to send {} topic messages: {} ms", MSG_COUNT, result);
        queueView.purge();
    }

    long smoothed = cumulative / NUM_RUNS;
    LOG.info("Smoothed send time for {} messages: {}", MSG_COUNT, smoothed);
}
 

@Test(timeout = 60000)
public void testReceiveTwoThenCloseSessionToRollback() throws Exception {
    connection = createAmqpConnection();
    connection.start();

    sendToAmqQueue(2);

    QueueViewMBean proxy = getProxyToQueue(name.getMethodName());
    assertEquals(2, proxy.getQueueSize());

    Session session = connection.createSession(true, Session.SESSION_TRANSACTED);
    Queue queue = session.createQueue(name.getMethodName());
    MessageConsumer consumer = session.createConsumer(queue);

    Message message = consumer.receive(3000);
    assertNotNull(message);
    message = consumer.receive(3000);
    assertNotNull(message);
    session.rollback();

    assertEquals(2, proxy.getQueueSize());

    // Consume again.. the prev message should get redelivered.
    message = consumer.receive(5000);
    assertNotNull("Should have re-received the message again!", message);
    message = consumer.receive(5000);
    assertNotNull("Should have re-received the message again!", message);

    session.close();

    assertEquals(2, proxy.getQueueSize());
}
 

@Test(timeout=45000)
public void testSelectorsWithJMSType() throws Exception {
    connection = createAmqpConnection();
    connection.start();
    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    Queue queue = session.createQueue(name.getMethodName());
    MessageProducer producer = session.createProducer(queue);

    TextMessage message = session.createTextMessage();
    message.setText("text");
    producer.send(message, DeliveryMode.NON_PERSISTENT, Message.DEFAULT_PRIORITY, Message.DEFAULT_TIME_TO_LIVE);

    TextMessage message2 = session.createTextMessage();
    String type = "myJMSType";
    message2.setJMSType(type);
    message2.setText("text + type");
    producer.send(message2, DeliveryMode.NON_PERSISTENT, Message.DEFAULT_PRIORITY, Message.DEFAULT_TIME_TO_LIVE);

    producer.close();

    final QueueViewMBean proxy = getProxyToQueue(name.getMethodName());
    assertTrue("Queue did not get all expected messages", Wait.waitFor(new Wait.Condition() {

        @Override
        public boolean isSatisfied() throws Exception {
            return proxy.getQueueSize() == 2;
        }
    }));

    MessageConsumer consumer = session.createConsumer(queue, "JMSType = '" + type + "'");
    Message msg = consumer.receive(5000);
    assertNotNull("No message was recieved", msg);
    assertTrue(msg instanceof TextMessage);
    assertEquals("Unexpected JMSType value", type, msg.getJMSType());
    assertEquals("Unexpected message content", "text + type", ((TextMessage) msg).getText());
}
 

@Test(timeout = 60000)
public void testMessagesAreAckedAMQPProducer() throws Exception {
    int messagesSent = 3;

    connection = createAmqpConnection();
    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    Queue queue = session.createQueue(name.getMethodName());
    MessageProducer producer = session.createProducer(queue);
    producer.setDeliveryMode(DeliveryMode.PERSISTENT);
    TextMessage message = null;
    for (int i=0; i < messagesSent; i++) {
        message = session.createTextMessage();
        String messageText = "Hello " + i + " sent at " + new java.util.Date().toString();
        message.setText(messageText);
        LOG.debug(">>>> Sent [{}]", messageText);
        producer.send(message);
    }

    connection.close();

    // After the first restart we should get all messages sent above
    restartPrimaryBroker();
    QueueViewMBean proxy = getProxyToQueue(name.getMethodName());
    assertEquals(messagesSent, proxy.getQueueSize());
    int messagesReceived = readAllMessages();
    assertEquals(messagesSent, messagesReceived);

    // This time there should be no messages on this queue
    restartPrimaryBroker();
    proxy = getProxyToQueue(name.getMethodName());
    assertEquals(0, proxy.getQueueSize());
}
 

@Test(timeout = 60000)
public void testMessagesAreAckedAMQProducer() throws Exception {
    int messagesSent = 3;
    assertTrue(brokerService.isPersistent());

    connection = createActiveMQConnection();
    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    Queue queue = session.createQueue(name.getMethodName());
    MessageProducer p = session.createProducer(queue);
    TextMessage message = null;
    for (int i=0; i < messagesSent; i++) {
        message = session.createTextMessage();
        String messageText = "Hello " + i + " sent at " + new java.util.Date().toString();
        message.setText(messageText);
        LOG.debug(">>>> Sent [{}]", messageText);
        p.send(message);
    }
    connection.close();

    // After the first restart we should get all messages sent above
    restartPrimaryBroker();
    QueueViewMBean proxy = getProxyToQueue(name.getMethodName());
    assertEquals(messagesSent, proxy.getQueueSize());
    int messagesReceived = readAllMessages();
    assertEquals(messagesSent, messagesReceived);

    // This time there should be no messages on this queue
    restartPrimaryBroker();
    proxy = getProxyToQueue(name.getMethodName());
    assertEquals(0, proxy.getQueueSize());
}
 

@Test(timeout = 60000)
public void testCreateMessageConsumer() throws Exception {
    connection = createAmqpConnection();
    connection.start();

    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    assertNotNull(session);
    Queue queue = session.createQueue(name.getMethodName());
    session.createConsumer(queue);

    QueueViewMBean proxy = getProxyToQueue(name.getMethodName());
    assertEquals(0, proxy.getQueueSize());
}
 

@Test(timeout = 20000)
public void testSendForeignMessage() throws Exception {
    connection = createAmqpConnection();
    assertNotNull(connection);
    connection.start();

    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    assertNotNull(session);
    Queue queue = session.createQueue(name.getMethodName());
    MessageProducer producer = session.createProducer(queue);

    QueueViewMBean proxy = getProxyToQueue(name.getMethodName());
    assertEquals(0, proxy.getQueueSize());

    String foreignPropKey = "myForeignMessageProp";
    String foreignPropValue = "ABC456XYZ";

    Connection activeMQConnection = createActiveMQConnection();
    try {
        Session activeMQSession = activeMQConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);

        Message foreignMessage = activeMQSession.createMessage();
        foreignMessage.setStringProperty(foreignPropKey, foreignPropValue);

        producer.send(foreignMessage);
    } finally {
        activeMQConnection.close();
    }

    assertEquals(1, proxy.getQueueSize());

    MessageConsumer consumer = session.createConsumer(queue);
    Message receivedMessage = consumer.receive(5000);
    assertNotNull("Did not receive message as expected", receivedMessage);
    assertEquals("Unexpected property value", foreignPropValue, receivedMessage.getStringProperty(foreignPropKey));
}