public void sendText(String message) { try { producer.send(session.createTextMessage(message)); } catch (JMSException e) { throw bomb(e); } } }
try { queueConnection = connectionFactory.createConnection(); queueSession = queueConnection.createSession(transacted, Session.AUTO_ACKNOWLEDGE); TextMessage message = queueSession.createTextMessage(eventXml); message.setStringProperty("LogType", "Task"); producer = queueSession.createProducer(queue); producer.setPriority(priority); producer.send(message); } catch (Exception e) { throw new RuntimeException("Error when sending JMS message with working memory event", e);
@Test public void testBeforeTaskReleasedEvent() throws JMSException { logProducer.beforeTaskReleasedEvent(event); ArgumentCaptor<String> argument = ArgumentCaptor.forClass(String.class); verify(session).createTextMessage(argument.capture()); String messageContent = argument.getValue(); assertThat(messageContent) .isNotNull() .doesNotContain("<auditTask>") .contains("<org.jbpm.services.task.audit.impl.model.TaskEventImpl>") .contains("<type>RELEASED</type>"); verify(message, times(1)).setStringProperty(eq("LogType"), eq("Task")); verify(producer, times(1)).setPriority(eq(7)); verify(producer, times(1)).send(eq(message)); }
public void testCloseConsumer() throws Exception { Destination dest = session.createQueue(getSubject() + "?consumer.prefetchSize=0"); producer = session.createProducer(dest); beginTx(); producer.send(session.createTextMessage("message 1")); producer.send(session.createTextMessage("message 2")); commitTx(); beginTx(); consumer = session.createConsumer(dest); Message message1 = consumer.receive(1000); String text1 = ((TextMessage)message1).getText(); assertNotNull(message1); assertEquals("message 1", text1); consumer.close(); consumer = session.createConsumer(dest); Message message2 = consumer.receive(1000); String text2 = ((TextMessage)message2).getText(); assertNotNull(message2); assertEquals("message 2", text2); commitTx(); }
@Test public void processAndReply() throws JMSException { MessagingMessageListenerAdapter listener = createDefaultInstance(String.class); String body = "echo text"; String correlationId = "link-1234"; Destination replyDestination = new Destination() {}; TextMessage reply = mock(TextMessage.class); QueueSender queueSender = mock(QueueSender.class); Session session = mock(Session.class); given(session.createTextMessage(body)).willReturn(reply); given(session.createProducer(replyDestination)).willReturn(queueSender); listener.setDefaultResponseDestination(replyDestination); StubTextMessage inputMessage = createSimpleJmsTextMessage(body); inputMessage.setJMSCorrelationID(correlationId); listener.onMessage(inputMessage, session); assertDefaultListenerMethodInvocation(); verify(reply).setJMSCorrelationID(correlationId); verify(queueSender).send(reply); verify(queueSender).close(); }
/** * Sends a batch of messages and validates that the rollbacked message was * not consumed. * * @throws Exception */ public void testSendReceiveWithPrefetchOne() throws Exception { setPrefetchToOne(); Message[] outbound = new Message[] {session.createTextMessage("First Message"), session.createTextMessage("Second Message"), session.createTextMessage("Third Message"), session.createTextMessage("Fourth Message")}; beginTx(); for (int i = 0; i < outbound.length; i++) { // sends a message producer.send(outbound[i]); } commitTx(); // receives the first message beginTx(); for (int i = 0; i < outbound.length; i++) { LOG.info("About to consume message 1"); Message message = consumer.receive(1000); assertNotNull(message); LOG.info("Received: " + message); } // validates that the rollbacked was not consumed commitTx(); }
public TextMessage testReplyWithJackson(String methodName, String replyContent) throws JMSException { Queue replyDestination = mock(Queue.class); Session session = mock(Session.class); MessageProducer messageProducer = mock(MessageProducer.class); TextMessage responseMessage = mock(TextMessage.class); given(session.createTextMessage(replyContent)).willReturn(responseMessage); given(session.createProducer(replyDestination)).willReturn(messageProducer); MessagingMessageListenerAdapter listener = getPayloadInstance("Response", methodName, Message.class); MappingJackson2MessageConverter messageConverter = new MappingJackson2MessageConverter(); messageConverter.setTargetType(MessageType.TEXT); listener.setMessageConverter(messageConverter); listener.setDefaultResponseDestination(replyDestination); listener.onMessage(mock(javax.jms.Message.class), session); verify(session, times(0)).createQueue(anyString()); verify(session).createTextMessage(replyContent); verify(messageProducer).send(responseMessage); verify(messageProducer).close(); return responseMessage; }
public void testReRouteAllWithNullProducerExchange() throws Exception { final ActiveMQQueue queue = new ActiveMQQueue("Reroute.From."+topic.getTopicName()); final MessageInterceptorRegistry registry = MessageInterceptorRegistry.getInstance().get(BrokerRegistry.getInstance().findFirst()); registry.addMessageInterceptorForTopic(topic.getTopicName(), new MessageInterceptor() { @Override public void intercept(ProducerBrokerExchange producerExchange, Message message) { message.setDestination(queue); try { registry.injectMessage(producerExchange, message); } catch (Exception e) { e.printStackTrace(); } } }); final CountDownLatch latch = new CountDownLatch(messageCount); consumer = consumerSession.createConsumer(queue); consumer.setMessageListener(new MessageListener() { @Override public void onMessage(javax.jms.Message message) { latch.countDown(); } }); for (int i = 0; i < messageCount; i++){ javax.jms.Message message = producerSession.createTextMessage("test: " + i); producer.send(message); } latch.await(timeOutInSeconds, TimeUnit.SECONDS); assertEquals(0,latch.getCount()); }
final ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(url); final javax.jms.Connection connection = connectionFactory.createConnection(); connection.setClientID("12345"); connection.start(); final Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); final Topic temporaryTopic = session.createTemporaryTopic(); final MessageConsumer consumer1 = session.createConsumer(temporaryTopic); final MessageProducer producer = session.createProducer(temporaryTopic); producer.send(session.createTextMessage("Testmessage")); final TextMessage message = (TextMessage)consumer1.receiveNoWait(); Assert.assertNotNull(message); Assert.assertEquals("testing", message.getText());
public JmsAppenderTest() throws Exception { // this needs to set up before LoggerContextRule given(connectionFactory.createConnection()).willReturn(connection); given(connectionFactory.createConnection(anyString(), anyString())).willThrow(IllegalArgumentException.class); given(connection.createSession(eq(false), eq(Session.AUTO_ACKNOWLEDGE))).willReturn(session); given(session.createProducer(eq(destination))).willReturn(messageProducer); given(session.createTextMessage(anyString())).willReturn(textMessage); given(session.createObjectMessage(isA(Serializable.class))).willReturn(objectMessage); }
TextMessage[] outbound = new TextMessage[] {session.createTextMessage("First Message"), session.createTextMessage("Second Message")}; producer.send(outbound[0]); producer.send(outbound[1]); commitTx(); LOG.info("Sent 0: " + outbound[0]); TextMessage message = (TextMessage)consumer.receive(1000); assertEquals(outbound[0].getText(), message.getText()); message = (TextMessage)consumer.receive(1000); assertEquals(outbound[1].getText(), message.getText()); commitTx();
private void processAndReplyWithSendTo(MessagingMessageListenerAdapter listener, String replyDestinationName, boolean pubSubDomain, QosSettings replyQosSettings) throws JMSException { String body = "echo text"; String correlationId = "link-1234"; Destination replyDestination = new Destination() {}; DestinationResolver destinationResolver = mock(DestinationResolver.class); TextMessage reply = mock(TextMessage.class); QueueSender queueSender = mock(QueueSender.class); Session session = mock(Session.class); given(destinationResolver.resolveDestinationName(session, replyDestinationName, pubSubDomain)) .willReturn(replyDestination); given(session.createTextMessage(body)).willReturn(reply); given(session.createProducer(replyDestination)).willReturn(queueSender); listener.setDestinationResolver(destinationResolver); StubTextMessage inputMessage = createSimpleJmsTextMessage(body); inputMessage.setJMSCorrelationID(correlationId); listener.onMessage(inputMessage, session); verify(destinationResolver).resolveDestinationName(session, replyDestinationName, pubSubDomain); verify(reply).setJMSCorrelationID(correlationId); if (replyQosSettings != null) { verify(queueSender).send(reply, replyQosSettings.getDeliveryMode(), replyQosSettings.getPriority(), replyQosSettings.getTimeToLive()); } else { verify(queueSender).send(reply); } verify(queueSender).close(); }
try { queueConnection = connectionFactory.createConnection(); queueSession = queueConnection.createSession(transacted, Session.AUTO_ACKNOWLEDGE); TextMessage message = queueSession.createTextMessage(eventXml); message.setIntProperty("EventType", eventType); message.setStringProperty("LogType", "Process"); producer = queueSession.createProducer(queue); producer.setPriority(priority); producer.send(message); } catch (Exception e) { throw new RuntimeException("Error when sending JMS message with working memory event", e);
@Test public void testAfterTaskInputVariableChanged() throws JMSException { Map<String, Object> vars = new HashMap<>(); vars.put("test", "value"); logProducer.afterTaskInputVariableChangedEvent(event, vars); ArgumentCaptor<String> argument = ArgumentCaptor.forClass(String.class); verify(session).createTextMessage(argument.capture()); String messageContent = argument.getValue(); assertThat(messageContent) .isNotNull() .doesNotContain("<auditTask>") .doesNotContain("<org.jbpm.services.task.audit.impl.model.TaskEventImpl>") .contains("<taskInputs>"); verify(message, times(1)).setStringProperty(eq("LogType"), eq("Task")); verify(producer, times(1)).setPriority(eq(2)); verify(producer, times(1)).send(eq(message)); }
@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 public void testWithResponsiveMessageDelegateWithDefaultDestination_SendsReturnTextMessageWhenSessionSupplied() throws Exception { Queue destination = mock(Queue.class); TextMessage sentTextMessage = mock(TextMessage.class); // correlation ID is queried when response is being created... given(sentTextMessage.getJMSCorrelationID()).willReturn( CORRELATION_ID); // Reply-To is queried when response is being created... given(sentTextMessage.getJMSReplyTo()).willReturn(null); // we want to fall back to the default... TextMessage responseTextMessage = mock(TextMessage.class); QueueSender queueSender = mock(QueueSender.class); Session session = mock(Session.class); given(session.createTextMessage(RESPONSE_TEXT)).willReturn(responseTextMessage); given(session.createProducer(destination)).willReturn(queueSender); ResponsiveMessageDelegate delegate = mock(ResponsiveMessageDelegate.class); given(delegate.handleMessage(sentTextMessage)).willReturn(RESPONSE_TEXT); MessageListenerAdapter adapter = new MessageListenerAdapter(delegate) { @Override protected Object extractMessage(Message message) { return message; } }; adapter.setDefaultResponseDestination(destination); adapter.onMessage(sentTextMessage, session); verify(responseTextMessage).setJMSCorrelationID(CORRELATION_ID); verify(queueSender).send(responseTextMessage); verify(queueSender).close(); verify(delegate).handleMessage(sentTextMessage); }
Message[] outbound = new Message[] {session.createTextMessage("First Message"), session.createTextMessage("Second Message")}; producer.send(outbound[0]); commitTx(); producer.send(session.createTextMessage("I'm going to get rolled back.")); rollbackTx(); producer.send(outbound[1]); commitTx(); ArrayList<Message> messages = new ArrayList<Message>(); LOG.info("About to consume message 1"); Message message = consumer.receive(1000); messages.add(message); LOG.info("Received: " + message); message = consumer.receive(4000); messages.add(message); LOG.info("Received: " + message);
protected void doTestJmsException(JMSException original, Class<? extends JmsException> thrownExceptionClass) throws Exception { JmsTemplate template = createTemplate(); template.setConnectionFactory(this.connectionFactory); template.setMessageConverter(new SimpleMessageConverter()); String s = "Hello world"; MessageProducer messageProducer = mock(MessageProducer.class); TextMessage textMessage = mock(TextMessage.class); reset(this.session); given(this.session.createProducer(this.queue)).willReturn(messageProducer); given(this.session.createTextMessage("Hello world")).willReturn(textMessage); willThrow(original).given(messageProducer).send(textMessage); try { template.convertAndSend(this.queue, s); fail("Should have thrown JmsException"); } catch (JmsException wrappedEx) { // expected assertEquals(thrownExceptionClass, wrappedEx.getClass()); assertEquals(original, wrappedEx.getCause()); } verify(messageProducer).close(); verify(this.session).close(); verify(this.connection).close(); }
/** * Send a dummy message to probe if the JMS connection is healthy * @return true if connection is healthy, false otherwise */ protected boolean isConnectionHealthy() { try { Topic topic = createTopic(getTopicPrefix(getConf()) + "." + HEALTH_CHECK_TOPIC_SUFFIX); MessageProducer producer = createProducer(topic); Message msg = session.get().createTextMessage(HEALTH_CHECK_MSG); producer.send(msg, DeliveryMode.NON_PERSISTENT, 4, 0); } catch (Exception e) { return false; } return true; }
public void testReRouteAll() throws Exception { final ActiveMQQueue queue = new ActiveMQQueue("Reroute.From."+topic.getTopicName()); final MessageInterceptorRegistry registry = MessageInterceptorRegistry.getInstance().get(BrokerRegistry.getInstance().findFirst()); registry.addMessageInterceptorForTopic(topic.getTopicName(), new MessageInterceptor() { @Override public void intercept(ProducerBrokerExchange producerExchange, Message message) { message.setDestination(queue); try { registry.injectMessage(producerExchange, message); } catch (Exception e) { e.printStackTrace(); } } }); final CountDownLatch latch = new CountDownLatch(messageCount); consumer = consumerSession.createConsumer(queue); consumer.setMessageListener(new MessageListener() { @Override public void onMessage(javax.jms.Message message) { latch.countDown(); } }); for (int i = 0; i < messageCount; i++){ javax.jms.Message message = producerSession.createTextMessage("test: " + i); producer.send(message); } latch.await(timeOutInSeconds, TimeUnit.SECONDS); assertEquals(0,latch.getCount()); }