@Test public void testAutoSend() throws Exception { connection.start(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); Queue queue = session.createQueue(queueName); MessageConsumer consumer = session.createConsumer(queue); MessageProducer producer = session.createProducer(queue); for (int i = 0; i < 10; i++) { producer.send(session.createTextMessage("testXX" + i)); } connection.start(); for (int i = 0; i < 10; i++) { TextMessage txt = (TextMessage) consumer.receive(5000); Assert.assertEquals("testXX" + i, txt.getText()); } }
@Test @Ignore("ignored for now") public void testKeepAlive() throws Exception { connection.start(); Thread.sleep(30000); connection.createSession(false, 1); }
public void testMessageListenerWithConsumer() throws Exception { final AtomicInteger counter = new AtomicInteger(0); final CountDownLatch done = new CountDownLatch(1); // Receive a message with the JMS API connection.start(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); ActiveMQDestination destination = createDestination(session, destinationType); MessageConsumer consumer = session.createConsumer(destination); consumer.setMessageListener(new MessageListener() { @Override public void onMessage(Message m) { counter.incrementAndGet(); if (counter.get() == 4) { done.countDown(); } } }); // Send the messages sendMessages(session, destination, 4); assertTrue(done.await(1000, TimeUnit.MILLISECONDS)); Thread.sleep(200); // Make sure only 4 messages were delivered. assertEquals(4, counter.get()); }
@Override @Before public void setUp() throws Exception { super.setUp(); if (durable) { connection.setClientID(getClass().getName()); } System.out.println("Created connection: " + connection); session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); System.out.println("Created session: " + session); if (topic) { consumerDestination = this.createDestination(session, ActiveMQDestination.TOPIC_TYPE); producerDestination = this.createDestination(session, ActiveMQDestination.TOPIC_TYPE); } else { consumerDestination = this.createDestination(session, ActiveMQDestination.QUEUE_TYPE); producerDestination = this.createDestination(session, ActiveMQDestination.QUEUE_TYPE); } System.out.println("Created consumer destination: " + consumerDestination + " of type: " + consumerDestination.getClass()); System.out.println("Created producer destination: " + producerDestination + " of type: " + producerDestination.getClass()); producer = session.createProducer(producerDestination); producer.setDeliveryMode(deliveryMode); System.out.println("Created producer: " + producer + " delivery mode = " + (deliveryMode == DeliveryMode.PERSISTENT ? "PERSISTENT" : "NON_PERSISTENT")); connection.start(); }
@Test public void testInvalidDestinationExceptionWhenNoQueueExistsOnCreateProducer() throws Exception { connection.start(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); Queue queue = session.createQueue("foo"); try { session.createProducer(queue); fail("Should have thrown an exception creating a producer here"); } catch (JMSException expected) { } session.close(); }
@Test public void testPassMessageListenerIntoCreateConsumer() throws Exception { final AtomicInteger counter = new AtomicInteger(0); final CountDownLatch done = new CountDownLatch(1); // Receive a message with the JMS API connection.start(); ActiveMQSession session = (ActiveMQSession) connection.createSession(false, Session.AUTO_ACKNOWLEDGE); ActiveMQDestination destination = createDestination(session, destinationType); MessageConsumer consumer = session.createConsumer(destination, new MessageListener() { @Override public void onMessage(Message m) { counter.incrementAndGet(); if (counter.get() == 4) { done.countDown(); } } }); assertNotNull(consumer); // Send the messages sendMessages(session, destination, 4); assertTrue(done.await(1000, TimeUnit.MILLISECONDS)); Thread.sleep(200); // Make sure only 4 messages were delivered. assertEquals(4, counter.get()); }
@Override @Before public void setUp() throws Exception { super.setUp(); initRedeliveryDelay = connection.getRedeliveryPolicy().getInitialRedeliveryDelay(); if (durable) { connection.setClientID(getClass().getName()); } System.out.println("Created connection: " + connection); session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE); consumeSession = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE); System.out.println("Created session: " + session); System.out.println("Created consumeSession: " + consumeSession); producer = session.createProducer(null); // producer.setRoutingType(deliveryMode); System.out.println("Created producer: " + producer); if (topic) { consumerDestination = this.createDestination(session, ActiveMQDestination.TOPIC_TYPE); producerDestination = this.createDestination(session, ActiveMQDestination.TOPIC_TYPE); } else { consumerDestination = this.createDestination(session, ActiveMQDestination.QUEUE_TYPE); producerDestination = this.createDestination(session, ActiveMQDestination.QUEUE_TYPE); } System.out.println("Created consumer destination: " + consumerDestination + " of type: " + consumerDestination.getClass()); System.out.println("Created producer destination: " + producerDestination + " of type: " + producerDestination.getClass()); consumer = createConsumer(getName()); connection.start(); System.out.println("Created connection: " + connection); }
@Test public void testAckedMessageAreConsumed() throws Exception { connection.start(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); Queue queue = session.createQueue(queueName); MessageProducer producer = session.createProducer(queue); producer.send(session.createTextMessage("Hello")); // Consume the message... MessageConsumer consumer = session.createConsumer(queue); consumer.setMessageListener(this); latch.await(10, TimeUnit.SECONDS); session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); // Attempt to Consume the message...check if message was acknowledge consumer = session.createConsumer(queue); Message msg = consumer.receive(1000); assertNull(msg); session.close(); }
@Override @Before public void setUp() throws Exception { super.setUp(); if (durable) { connection.setClientID(getClass().getName()); } System.out.println("Created connection: " + connection); session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); consumeSession = createConsumerSession(); System.out.println("Created session: " + session); producer = session.createProducer(null); producer.setDeliveryMode(deliveryMode); System.out.println("Created producer: " + producer + " delivery mode = " + (deliveryMode == DeliveryMode.PERSISTENT ? "PERSISTENT" : "NON_PERSISTENT")); if (topic) { consumerDestination = createDestination(session, ActiveMQDestination.TOPIC_TYPE, getConsumerSubject()); producerDestination = createDestination(session, ActiveMQDestination.TOPIC_TYPE, getProducerSubject()); } else { consumerDestination = createDestination(session, ActiveMQDestination.QUEUE_TYPE, getConsumerSubject()); producerDestination = createDestination(session, ActiveMQDestination.QUEUE_TYPE, getConsumerSubject()); } System.out.println("Created consumer destination: " + consumerDestination + " of type: " + consumerDestination.getClass()); System.out.println("Created producer destination: " + producerDestination + " of type: " + producerDestination.getClass()); consumer = createConsumer(); consumer.setMessageListener(this); connection.start(); // log.info("Created connection: " + connection); }
@Test(timeout = 10000) public void testAutoCreatedQueue() throws JMSException { connection.start(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); Queue queue = session.createQueue("autoCreated"); // Reset the session. session.close(); session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); session.createConsumer(queue); session.close(); connection.close(); //Happens more than once because of advisories verifier.validatePluginMethodsAtLeast(2, BEFORE_ADD_ADDRESS, AFTER_ADD_ADDRESS, BEFORE_REMOVE_ADDRESS, AFTER_REMOVE_ADDRESS); }
/** * Tests if acknowledged messages are being consumed. * * @throws javax.jms.JMSException */ @Test public void testAckedMessageAreConsumed() throws JMSException { connection.start(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); Queue queue = session.createQueue(queueName); MessageProducer producer = session.createProducer(queue); producer.send(session.createTextMessage("Hello")); // Consume the message... MessageConsumer consumer = session.createConsumer(queue); Message msg = consumer.receive(1000); assertNotNull(msg); // Reset the session. session.close(); session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); // Attempt to Consume the message... consumer = session.createConsumer(queue); msg = consumer.receive(1000); assertNull(msg); session.close(); }
@Test public void testSimpleQueue() throws Exception { connection.start(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); System.out.println("creating queue: " + queueName); Destination dest = new ActiveMQQueue(queueName); System.out.println("creating producer..."); MessageProducer producer = session.createProducer(dest); final int num = 1; final String msgBase = "MfromAMQ-"; for (int i = 0; i < num; i++) { TextMessage msg = session.createTextMessage("MfromAMQ-" + i); producer.send(msg); System.out.println("sent: "); } //receive MessageConsumer consumer = session.createConsumer(dest); System.out.println("receiving messages..."); for (int i = 0; i < num; i++) { TextMessage msg = (TextMessage) consumer.receive(5000); System.out.println("received: " + msg); String content = msg.getText(); System.out.println("content: " + content); assertEquals(msgBase + i, content); } assertNull(consumer.receive(1000)); session.close(); }
@Test public void testSendReceive() throws Exception { // Send a message to the broker. connection.start(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); ActiveMQDestination destination = createDestination(session, destinationType); System.out.println("destionation: " + destination); MessageProducer producer = session.createProducer(destination); producer.setDeliveryMode(this.deliveryMode); MessageConsumer consumer = session.createConsumer(destination); ActiveMQMessage message = new ActiveMQMessage(); producer.send(message); // Make sure only 1 message was delivered. assertNotNull(consumer.receive(1000)); assertNull(consumer.receiveNoWait()); }
@Test public void testStartAfterSend() throws Exception { Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); ActiveMQDestination destination = createDestination(session, destinationType); MessageConsumer consumer = session.createConsumer(destination); // Send the messages sendMessages(session, destination, 1); // Start the conncection after the message was sent. connection.start(); // Make sure only 1 message was delivered. assertNotNull(consumer.receive(1000)); assertNull(consumer.receiveNoWait()); }
/** * Tests if acknowledged messages are being consumed. * * @throws JMSException */ @Test public void testAckedMessageAreConsumed() throws JMSException { connection.start(); Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE); Queue queue = session.createQueue(getQueueName()); MessageProducer producer = session.createProducer(queue); producer.send(session.createTextMessage("Hello")); // Consume the message... MessageConsumer consumer = session.createConsumer(queue); Message msg = consumer.receive(1000); assertNotNull(msg); msg.acknowledge(); // Reset the session. session.close(); session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE); // Attempt to Consume the message... consumer = session.createConsumer(queue); msg = consumer.receive(1000); assertNull(msg); session.close(); }
/** * Tests if acknowledged messages are being consumed. * * @throws JMSException */ @Test public void testAckedMessageAreConsumed() throws JMSException { connection.start(); Session session = connection.createSession(false, ActiveMQSession.INDIVIDUAL_ACKNOWLEDGE); Queue queue = (Queue) this.createDestination(session, ActiveMQDestination.QUEUE_TYPE); MessageProducer producer = session.createProducer(queue); producer.send(session.createTextMessage("Hello")); // Consume the message... MessageConsumer consumer = session.createConsumer(queue); Message msg = consumer.receive(5000); assertNotNull(msg); msg.acknowledge(); // Reset the session. session.close(); session = connection.createSession(false, ActiveMQSession.INDIVIDUAL_ACKNOWLEDGE); // Attempt to Consume the message... consumer = session.createConsumer(queue); msg = consumer.receive(1000); assertNull(msg); session.close(); }
/** * Tests if unacknowledged messages are being re-delivered when the consumer connects again. * * @throws JMSException */ @Test public void testUnAckedMessageAreNotConsumedOnSessionClose() throws JMSException { connection.start(); Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE); Queue queue = session.createQueue(getQueueName()); MessageProducer producer = session.createProducer(queue); producer.send(session.createTextMessage("Hello")); // Consume the message... MessageConsumer consumer = session.createConsumer(queue); Message msg = consumer.receive(1000); assertNotNull(msg); // Don't ack the message. // Reset the session. This should cause the unacknowledged message to be // re-delivered. session.close(); session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE); // Attempt to Consume the message... consumer = session.createConsumer(queue); msg = consumer.receive(2000); assertNotNull(msg); msg.acknowledge(); session.close(); }
/** * Tests if unacknowledged messages are being re-delivered when the consumer * connects again. * * @throws JMSException */ @Test public void testUnAckedMessageAreNotConsumedOnSessionClose() throws JMSException { connection.start(); Session session = connection.createSession(false, ActiveMQSession.INDIVIDUAL_ACKNOWLEDGE); Queue queue = (Queue) this.createDestination(session, ActiveMQDestination.QUEUE_TYPE); MessageProducer producer = session.createProducer(queue); producer.send(session.createTextMessage("Hello")); // Consume the message... MessageConsumer consumer = session.createConsumer(queue); Message msg = consumer.receive(1000); assertNotNull(msg); // Don't ack the message. // Reset the session. This should cause the unacknowledged message to be // re-delivered. session.close(); session = connection.createSession(false, ActiveMQSession.INDIVIDUAL_ACKNOWLEDGE); // Attempt to Consume the message... consumer = session.createConsumer(queue); msg = consumer.receive(2000); assertNotNull(msg); msg.acknowledge(); session.close(); }
@Test public void testAutoDestinationCreationOnProducerSend() throws JMSException { AddressSettings addressSetting = new AddressSettings(); addressSetting.setAutoCreateQueues(true); addressSetting.setAutoCreateAddresses(true); String address = "foo"; server.getAddressSettingsRepository().addMatch(address, addressSetting); connection.start(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); TextMessage message = session.createTextMessage("bar"); Queue queue = new ActiveMQQueue(address); MessageProducer producer = session.createProducer(null); producer.send(queue, message); MessageConsumer consumer = session.createConsumer(queue); TextMessage message1 = (TextMessage) consumer.receive(1000); assertTrue(message1.getText().equals(message.getText())); }
@Test public void testTextMessage() throws Exception { // Receive a message with the JMS API connection.start(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); destination = createDestination(session, destinationType); MessageConsumer consumer = session.createConsumer(destination); MessageProducer producer = session.createProducer(destination); // Send the message. { TextMessage message = session.createTextMessage(); message.setText("Hi"); producer.send(message); } // Check the Message { TextMessage message = (TextMessage) consumer.receive(1000); assertNotNull(message); assertEquals("Hi", message.getText()); } assertNull(consumer.receiveNoWait()); }