@Test public void testINT2858RetryAdviceAsFirstInAdviceChain() { final AtomicInteger counter = new AtomicInteger(3); AbstractReplyProducingMessageHandler handler = new AbstractReplyProducingMessageHandler() { @Override protected Object handleRequestMessage(Message<?> requestMessage) { return "foo"; } }; List<Advice> adviceChain = new ArrayList<>(); adviceChain.add(new RequestHandlerRetryAdvice()); adviceChain.add((MethodInterceptor) invocation -> { counter.getAndDecrement(); throw new RuntimeException("intentional"); }); handler.setBeanFactory(mock(BeanFactory.class)); handler.setAdviceChain(adviceChain); handler.afterPropertiesSet(); try { handler.handleMessage(new GenericMessage<>("test")); } catch (Exception e) { Throwable cause = e.getCause(); assertEquals(RuntimeException.class, cause.getClass()); assertEquals("intentional", cause.getMessage()); } assertTrue(counter.get() == 0); }
@Test public void testMessagingExceptionNoErrorChannel() throws Exception { Message<String> message = MessageBuilder.withPayload("foo") .build(); this.handler.handleMessage(message); assertNull(this.output.receive(0)); this.whichTest = 2; this.latch.countDown(); assertTrue(this.exceptionLatch.await(10, TimeUnit.SECONDS)); assertNotNull(this.failedCallbackException); assertThat(this.failedCallbackMessage, containsString("no 'errorChannel' header")); }
@Test public void errorMessageShouldContainChannelName() { this.handler.setOutputChannel(this.channel); given(this.channel.send(this.message)).willReturn(false); given(this.channel.toString()).willReturn("testChannel"); try { this.handler.handleMessage(this.message); fail("Expected a MessagingException"); } catch (MessagingException e) { assertThat(e.getMessage(), containsString("'testChannel'")); } }
private void defaultStatefulRetryRecoverAfterThirdTryGuts(final AtomicInteger counter, AbstractReplyProducingMessageHandler handler, QueueChannel replies, RequestHandlerRetryAdvice advice) { advice.setRecoveryCallback(context -> "baz"); List<Advice> adviceChain = new ArrayList<>(); adviceChain.add(advice); handler.setAdviceChain(adviceChain); handler.setBeanFactory(mock(BeanFactory.class)); handler.afterPropertiesSet(); Message<String> message = new GenericMessage<>("Hello, world!"); for (int i = 0; i < 4; i++) { try { handler.handleMessage(message); } catch (Exception e) { } } assertTrue(counter.get() == 0); Message<?> reply = replies.receive(10000); assertNotNull(reply); assertEquals("baz", reply.getPayload()); }
@Test public void testRuntimeException() { QueueChannel errorChannel = new QueueChannel(); Message<String> message = MessageBuilder.withPayload("foo") .setErrorChannel(errorChannel) .build(); this.handler.handleMessage(message); assertNull(this.output.receive(0)); this.whichTest = 1; this.latch.countDown(); Message<?> received = errorChannel.receive(10000); assertNotNull(received); assertThat(received.getPayload(), instanceOf(MessageHandlingException.class)); assertEquals("foo", ((Throwable) received.getPayload()).getCause().getMessage()); assertSame(message, ((MessagingException) received.getPayload()).getFailedMessage()); assertNull(this.failedCallbackException); }
@Test public void testGoodResult() { this.whichTest = 0; this.handler.handleMessage(new GenericMessage<>("foo")); assertNull(this.output.receive(0)); this.latch.countDown(); Message<?> received = this.output.receive(10000); assertNotNull(received); assertEquals("reply", received.getPayload()); assertNull(this.failedCallbackException); }
@Test public void testCustomFunction() { QueueChannel outputChannel = new QueueChannel(); barHandler.setOutputChannel(outputChannel); barHandler.handleMessage(new GenericMessage<String>("foo")); Message<?> reply = outputChannel.receive(0); assertNotNull(reply); assertEquals("bar", reply.getPayload()); }
@Test @SuppressWarnings("unchecked") public void testNotPropagateAddWhenNonExist() { AbstractReplyProducingMessageHandler handler = new AbstractReplyProducingMessageHandler() { @Override protected Object handleRequestMessage(Message<?> requestMessage) { return new GenericMessage<>("world", Collections.singletonMap("bar", "RAB")); } }; handler.addNotPropagatedHeaders("boom"); assertThat(handler.getNotPropagatedHeaders(), containsInAnyOrder("boom")); handler.setOutputChannel(this.channel); ArgumentCaptor<Message<?>> captor = ArgumentCaptor.forClass(Message.class); willReturn(true).given(this.channel).send(captor.capture()); handler.handleMessage(MessageBuilder.withPayload("hello") .setHeader("boom", "FOO") .setHeader("bar", "BAR") .setHeader("baz", "BAZ") .build()); Message<?> out = captor.getValue(); assertThat(out, notNullValue()); assertThat(out.getHeaders().get("boom"), nullValue()); assertThat(out.getHeaders().get("bar"), equalTo("RAB")); assertThat(out.getHeaders().get("baz"), equalTo("BAZ")); }
@Test public void testCustomAccessor() { QueueChannel outputChannel = new QueueChannel(); fooHandler.setOutputChannel(outputChannel); Foo foo = new Foo("baz"); fooHandler.handleMessage(new GenericMessage<Foo>(foo)); Message<?> reply = outputChannel.receive(0); assertNotNull(reply); assertTrue(reply.getPayload() instanceof String); assertEquals("baz", reply.getPayload()); assertEquals(3, TestUtils.getPropertyValue(this.evaluationContextFactoryBean, "propertyAccessors", Map.class).size()); }
@Test public void errorMessageSendingRecovererTests() { AbstractReplyProducingMessageHandler handler = new AbstractReplyProducingMessageHandler() { @Override protected Object handleRequestMessage(Message<?> requestMessage) { throw new RuntimeException("fooException"); } }; QueueChannel errors = new QueueChannel(); RequestHandlerRetryAdvice advice = new RequestHandlerRetryAdvice(); ErrorMessageSendingRecoverer recoverer = new ErrorMessageSendingRecoverer(errors); advice.setRecoveryCallback(recoverer); List<Advice> adviceChain = new ArrayList<>(); adviceChain.add(advice); handler.setAdviceChain(adviceChain); handler.setBeanFactory(mock(BeanFactory.class)); handler.afterPropertiesSet(); Message<String> message = new GenericMessage<>("Hello, world!"); handler.handleMessage(message); Message<?> error = errors.receive(10000); assertNotNull(error); assertEquals("fooException", ((Exception) error.getPayload()).getCause().getMessage()); }
@Test public void testGoodResultWithNoReplyChannelHeaderNoOutput() { this.whichTest = 0; this.handler.setOutputChannel(null); QueueChannel errorChannel = new QueueChannel(); Message<String> message = MessageBuilder.withPayload("foo").setErrorChannel(errorChannel).build(); this.handler.handleMessage(message); assertNull(this.output.receive(0)); this.latch.countDown(); Message<?> errorMessage = errorChannel.receive(10000); assertNotNull(errorMessage); assertThat(errorMessage.getPayload(), instanceOf(DestinationResolutionException.class)); assertEquals("no output-channel or replyChannel header available", ((Throwable) errorMessage.getPayload()).getMessage()); assertNull(((MessagingException) errorMessage.getPayload()).getFailedMessage()); assertNotNull(this.failedCallbackException); assertThat(this.failedCallbackException.getMessage(), containsString("or replyChannel header")); }
@Test public void defaultRetrySucceedOnThirdTry() { final AtomicInteger counter = new AtomicInteger(2); AbstractReplyProducingMessageHandler handler = new AbstractReplyProducingMessageHandler() { @Override protected Object handleRequestMessage(Message<?> requestMessage) { if (counter.getAndDecrement() > 0) { throw new RuntimeException("foo"); } return "bar"; } }; QueueChannel replies = new QueueChannel(); handler.setOutputChannel(replies); RequestHandlerRetryAdvice advice = new RequestHandlerRetryAdvice(); List<Advice> adviceChain = new ArrayList<Advice>(); adviceChain.add(advice); handler.setAdviceChain(adviceChain); handler.setBeanFactory(mock(BeanFactory.class)); handler.afterPropertiesSet(); Message<String> message = new GenericMessage<>("Hello, world!"); handler.handleMessage(message); assertTrue(counter.get() == -1); Message<?> reply = replies.receive(10000); assertNotNull(reply); assertEquals("bar", reply.getPayload()); }
handler.handleMessage(message); fail("MessagingException expected.");
@Test public void testMessagingException() { QueueChannel errorChannel = new QueueChannel(); Message<String> message = MessageBuilder.withPayload("foo") .setErrorChannel(errorChannel) .build(); this.handler.handleMessage(message); assertNull(this.output.receive(0)); this.whichTest = 2; this.latch.countDown(); Message<?> received = errorChannel.receive(10000); assertNotNull(received); assertThat(received.getPayload(), instanceOf(MessagingException.class)); assertSame(message, ((MessagingException) received.getPayload()).getFailedMessage()); assertNull(this.failedCallbackException); }
handler.handleMessage(new GenericMessage<>("test"));
@Test @SuppressWarnings("unchecked") public void testNotPropagate() { AbstractReplyProducingMessageHandler handler = new AbstractReplyProducingMessageHandler() { @Override protected Object handleRequestMessage(Message<?> requestMessage) { return new GenericMessage<>("world", Collections.singletonMap("bar", "RAB")); } }; assertThat(handler.getNotPropagatedHeaders(), emptyCollectionOf(String.class)); handler.setNotPropagatedHeaders("f*", "*r"); handler.setOutputChannel(this.channel); assertThat(handler.getNotPropagatedHeaders(), containsInAnyOrder("f*", "*r")); ArgumentCaptor<Message<?>> captor = ArgumentCaptor.forClass(Message.class); willReturn(true).given(this.channel).send(captor.capture()); handler.handleMessage(MessageBuilder.withPayload("hello") .setHeader("foo", "FOO") .setHeader("bar", "BAR") .setHeader("baz", "BAZ") .build()); Message<?> out = captor.getValue(); assertThat(out, notNullValue()); assertThat(out.getHeaders().get("foo"), nullValue()); assertThat(out.getHeaders().get("bar"), equalTo("RAB")); assertThat(out.getHeaders().get("baz"), equalTo("BAZ")); }
@Test @SuppressWarnings("unchecked") public void testNotPropagateAdd() { AbstractReplyProducingMessageHandler handler = new AbstractReplyProducingMessageHandler() { @Override protected Object handleRequestMessage(Message<?> requestMessage) { return new GenericMessage<>("world", Collections.singletonMap("bar", "RAB")); } }; assertThat(handler.getNotPropagatedHeaders(), emptyCollectionOf(String.class)); handler.setNotPropagatedHeaders("foo"); handler.addNotPropagatedHeaders("b*r"); handler.setOutputChannel(this.channel); assertThat(handler.getNotPropagatedHeaders(), containsInAnyOrder("foo", "b*r")); ArgumentCaptor<Message<?>> captor = ArgumentCaptor.forClass(Message.class); willReturn(true).given(this.channel).send(captor.capture()); handler.handleMessage( MessageBuilder.withPayload("hello") .setHeader("foo", "FOO") .setHeader("bar", "BAR") .setHeader("baz", "BAZ") .build()); Message<?> out = captor.getValue(); assertThat(out, notNullValue()); assertThat(out.getHeaders().get("foo"), nullValue()); assertThat(out.getHeaders().get("bar"), equalTo("RAB")); assertThat(out.getHeaders().get("baz"), equalTo("BAZ")); }
for (int i = 0; i < 3; i++) { try { handler.handleMessage(message);
@Test public void testGoodResultWithReplyChannelHeader() { this.whichTest = 0; this.handler.setOutputChannel(null); QueueChannel replyChannel = new QueueChannel(); Message<?> message = MessageBuilder.withPayload("foo") .setReplyChannel(replyChannel) .build(); this.handler.handleMessage(message); assertNull(replyChannel.receive(0)); this.latch.countDown(); Message<?> received = replyChannel.receive(10000); assertNotNull(received); assertEquals("reply", received.getPayload()); assertNull(this.failedCallbackException); }
handler.handleMessage(message); Message<?> error = errors.receive(10000); assertNotNull(error);