@Test public void testWithMessageContentsDelegateForTextMessage() throws Exception { TextMessage textMessage = mock(TextMessage.class); // TextMessage contents must be unwrapped... given(textMessage.getText()).willReturn(TEXT); MessageContentsDelegate delegate = mock(MessageContentsDelegate.class); MessageListenerAdapter adapter = new MessageListenerAdapter(delegate); adapter.onMessage(textMessage); verify(delegate).handleMessage(TEXT); }
@Test public void testWithMessageContentsDelegateForObjectMessage() throws Exception { ObjectMessage objectMessage = mock(ObjectMessage.class); given(objectMessage.getObject()).willReturn(NUMBER); MessageContentsDelegate delegate = mock(MessageContentsDelegate.class); MessageListenerAdapter adapter = new MessageListenerAdapter(delegate); adapter.onMessage(objectMessage); verify(delegate).handleMessage(NUMBER); }
@Test public void testWithMessageContentsDelegateForObjectMessageWithPlainObject() throws Exception { ObjectMessage objectMessage = mock(ObjectMessage.class); given(objectMessage.getObject()).willReturn(OBJECT); MessageContentsDelegate delegate = mock(MessageContentsDelegate.class); MessageListenerAdapter adapter = new MessageListenerAdapter(delegate); adapter.onMessage(objectMessage); verify(delegate).handleMessage(OBJECT); }
@Test public void testThatAnExceptionThrownFromTheHandlingMethodIsSimplySwallowedByDefault() throws Exception { final IllegalArgumentException exception = new IllegalArgumentException(); TextMessage textMessage = mock(TextMessage.class); MessageDelegate delegate = mock(MessageDelegate.class); willThrow(exception).given(delegate).handleMessage(textMessage); MessageListenerAdapter adapter = new MessageListenerAdapter(delegate) { @Override protected void handleListenerException(Throwable ex) { assertNotNull("The Throwable passed to the handleListenerException(..) method must never be null.", ex); assertTrue("The Throwable passed to the handleListenerException(..) method must be of type [ListenerExecutionFailedException].", ex instanceof ListenerExecutionFailedException); ListenerExecutionFailedException lefx = (ListenerExecutionFailedException) ex; Throwable cause = lefx.getCause(); assertNotNull("The cause of a ListenerExecutionFailedException must be preserved.", cause); assertSame(exception, cause); } }; // we DON'T want the default SimpleMessageConversion happening... adapter.setMessageConverter(null); adapter.onMessage(textMessage); }
@Test public void testWithMessageDelegate() throws Exception { TextMessage textMessage = mock(TextMessage.class); MessageDelegate delegate = mock(MessageDelegate.class); MessageListenerAdapter adapter = new MessageListenerAdapter(delegate); // we DON'T want the default SimpleMessageConversion happening... adapter.setMessageConverter(null); adapter.onMessage(textMessage); verify(delegate).handleMessage(textMessage); }
@Test public void testWithResponsiveMessageDelegateDoesNotSendReturnTextMessageWhenSessionSupplied_AndListenerMethodThrowsException() throws Exception { final TextMessage message = mock(TextMessage.class); final QueueSession session = mock(QueueSession.class); ResponsiveMessageDelegate delegate = mock(ResponsiveMessageDelegate.class); willThrow(new IllegalArgumentException("Doe!")).given(delegate).handleMessage(message); final MessageListenerAdapter adapter = new MessageListenerAdapter(delegate) { @Override protected Object extractMessage(Message message) { return message; } }; try { adapter.onMessage(message, session); fail("expected ListenerExecutionFailedException"); } catch (ListenerExecutionFailedException ex) { /* expected */ } }
@Test public void testWithMessageContentsDelegateForBytesMessage() throws Exception { BytesMessage bytesMessage = mock(BytesMessage.class); // BytesMessage contents must be unwrapped... given(bytesMessage.getBodyLength()).willReturn(new Long(TEXT.getBytes().length)); given(bytesMessage.readBytes(any(byte[].class))).willAnswer(new Answer<Integer>() { @Override public Integer answer(InvocationOnMock invocation) throws Throwable { byte[] bytes = (byte[]) invocation.getArguments()[0]; ByteArrayInputStream inputStream = new ByteArrayInputStream(TEXT.getBytes()); return inputStream.read(bytes); } }); MessageContentsDelegate delegate = mock(MessageContentsDelegate.class); MessageListenerAdapter adapter = new MessageListenerAdapter(delegate); adapter.onMessage(bytesMessage); verify(delegate).handleMessage(TEXT.getBytes()); }
@Test public void testWithResponsiveMessageDelegate_DoesNotSendReturnTextMessageIfNoSessionSupplied() throws Exception { TextMessage textMessage = mock(TextMessage.class); ResponsiveMessageDelegate delegate = mock(ResponsiveMessageDelegate.class); given(delegate.handleMessage(textMessage)).willReturn(TEXT); MessageListenerAdapter adapter = new MessageListenerAdapter(delegate); // we DON'T want the default SimpleMessageConversion happening... adapter.setMessageConverter(null); adapter.onMessage(textMessage); }
@Test public void testWithResponsiveMessageDelegateWhenReturnTypeIsNotAJMSMessageAndNoMessageConverterIsSupplied() throws Exception { final TextMessage sentTextMessage = mock(TextMessage.class); final Session session = mock(Session.class); ResponsiveMessageDelegate delegate = mock(ResponsiveMessageDelegate.class); given(delegate.handleMessage(sentTextMessage)).willReturn(RESPONSE_TEXT); final MessageListenerAdapter adapter = new MessageListenerAdapter(delegate) { @Override protected Object extractMessage(Message message) { return message; } }; adapter.setMessageConverter(null); try { adapter.onMessage(sentTextMessage, session); fail("expected CouldNotSendReplyException with MessageConversionException"); } catch (ReplyFailureException ex) { assertEquals(MessageConversionException.class, ex.getCause().getClass()); } }
@Test public void testWithResponsiveMessageDelegateNoDefaultDestination_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(null); given(sentTextMessage.getJMSMessageID()).willReturn(CORRELATION_ID); // Reply-To is queried when response is being created... given(sentTextMessage.getJMSReplyTo()).willReturn(destination); TextMessage responseTextMessage = mock(TextMessage.class); MessageProducer messageProducer = mock(MessageProducer.class); Session session = mock(Session.class); given(session.createTextMessage(RESPONSE_TEXT)).willReturn(responseTextMessage); given(session.createProducer(destination)).willReturn(messageProducer); 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.onMessage(sentTextMessage, session); verify(responseTextMessage).setJMSCorrelationID(CORRELATION_ID); verify(messageProducer).send(responseTextMessage); verify(messageProducer).close(); verify(delegate).handleMessage(sentTextMessage); }
adapter.onMessage(sentTextMessage, session); fail("expected CouldNotSendReplyException with JMSException");
@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); }
@Test public void testWithResponsiveMessageDelegateNoDefaultDestinationAndNoReplyToDestination_SendsReturnTextMessageWhenSessionSupplied() throws Exception { final 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); TextMessage responseTextMessage = mock(TextMessage.class); final QueueSession session = mock(QueueSession.class); given(session.createTextMessage(RESPONSE_TEXT)).willReturn(responseTextMessage); ResponsiveMessageDelegate delegate = mock(ResponsiveMessageDelegate.class); given(delegate.handleMessage(sentTextMessage)).willReturn(RESPONSE_TEXT); final MessageListenerAdapter adapter = new MessageListenerAdapter(delegate) { @Override protected Object extractMessage(Message message) { return message; } }; try { adapter.onMessage(sentTextMessage, session); fail("expected CouldNotSendReplyException with InvalidDestinationException"); } catch (ReplyFailureException ex) { assertEquals(InvalidDestinationException.class, ex.getCause().getClass()); } verify(responseTextMessage).setJMSCorrelationID(CORRELATION_ID); verify(delegate).handleMessage(sentTextMessage); }
@Test public void testWithResponsiveMessageDelegateWhenReturnTypeIsAJMSMessageAndNoMessageConverterIsSupplied() throws Exception { Queue destination = mock(Queue.class); final 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(destination); TextMessage responseMessage = mock(TextMessage.class); QueueSender queueSender = mock(QueueSender.class); Session session = mock(Session.class); given(session.createProducer(destination)).willReturn(queueSender); ResponsiveJmsTextMessageReturningMessageDelegate delegate = mock(ResponsiveJmsTextMessageReturningMessageDelegate.class); given(delegate.handleMessage(sentTextMessage)).willReturn(responseMessage); final MessageListenerAdapter adapter = new MessageListenerAdapter(delegate) { @Override protected Object extractMessage(Message message) { return message; } }; adapter.setMessageConverter(null); adapter.onMessage(sentTextMessage, session); verify(responseMessage).setJMSCorrelationID(CORRELATION_ID); verify(queueSender).send(responseMessage); verify(queueSender).close(); }
/** * Standard JMS {@link MessageListener} entry point. * <p>Delegates the message to the target listener method, with appropriate * conversion of the message argument. In case of an exception, the * {@link #handleListenerException(Throwable)} method will be invoked. * <p><b>Note:</b> Does not support sending response messages based on * result objects returned from listener methods. Use the * {@link SessionAwareMessageListener} entry point (typically through a Spring * message listener container) for handling result objects as well. * @param message the incoming JMS message * @see #handleListenerException * @see #onMessage(javax.jms.Message, javax.jms.Session) */ public void onMessage(Message message) { try { onMessage(message, null); } catch (Throwable ex) { handleListenerException(ex); } }