@Test public void messageMustNotBeNull() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("Message must not be null"); this.channel.send(null); }
@Test public void postSendInterceptorMessageWasSent() { final AtomicBoolean preSendInvoked = new AtomicBoolean(false); final AtomicBoolean completionInvoked = new AtomicBoolean(false); this.channel.addInterceptor(new ChannelInterceptor() { @Override public void postSend(Message<?> message, MessageChannel channel, boolean sent) { assertInput(message, channel, sent); preSendInvoked.set(true); } @Override public void afterSendCompletion(Message<?> message, MessageChannel channel, boolean sent, Exception ex) { assertInput(message, channel, sent); completionInvoked.set(true); } private void assertInput(Message<?> message, MessageChannel channel, boolean sent) { assertNotNull(message); assertNotNull(channel); assertSame(ChannelInterceptorTests.this.channel, channel); assertTrue(sent); } }); this.channel.send(MessageBuilder.withPayload("test").build()); assertTrue(preSendInvoked.get()); assertTrue(completionInvoked.get()); }
@Test public void subscribeTwice() { assertThat(this.channel.subscribe(this.handler), equalTo(true)); assertThat(this.channel.subscribe(this.handler), equalTo(false)); this.channel.send(this.message); verify(this.handler, times(1)).handleMessage(this.message); }
@Test public void unsubscribeTwice() { this.channel.subscribe(this.handler); assertThat(this.channel.unsubscribe(this.handler), equalTo(true)); assertThat(this.channel.unsubscribe(this.handler), equalTo(false)); this.channel.send(this.message); verify(this.handler, never()).handleMessage(this.message); }
@Test public void concurrentModification() { this.channel.subscribe(message1 -> channel.unsubscribe(handler)); this.channel.subscribe(this.handler); this.channel.send(this.message); verify(this.handler).handleMessage(this.message); }
@Test public void preSendInterceptorReturningModifiedMessage() { Message<?> expected = mock(Message.class); PreSendInterceptor interceptor = new PreSendInterceptor(); interceptor.setMessageToReturn(expected); this.channel.addInterceptor(interceptor); this.channel.send(MessageBuilder.withPayload("test").build()); assertEquals(1, this.messageHandler.getMessages().size()); Message<?> result = this.messageHandler.getMessages().get(0); assertNotNull(result); assertSame(expected, result); assertTrue(interceptor.wasAfterCompletionInvoked()); }
@Test public void failurePropagates() { RuntimeException ex = new RuntimeException(); willThrow(ex).given(this.handler).handleMessage(this.message); MessageHandler secondHandler = mock(MessageHandler.class); this.channel.subscribe(this.handler); this.channel.subscribe(secondHandler); try { this.channel.send(message); } catch (MessageDeliveryException actualException) { assertThat(actualException.getCause(), equalTo(ex)); } verifyZeroInteractions(secondHandler); }
@Test public void afterCompletionWithPreSendException() { PreSendInterceptor interceptor1 = new PreSendInterceptor(); PreSendInterceptor interceptor2 = new PreSendInterceptor(); interceptor2.setExceptionToRaise(new RuntimeException("Simulated exception")); this.channel.addInterceptor(interceptor1); this.channel.addInterceptor(interceptor2); try { this.channel.send(MessageBuilder.withPayload("test").build()); } catch (Exception ex) { assertEquals("Simulated exception", ex.getCause().getMessage()); } assertTrue(interceptor1.wasAfterCompletionInvoked()); assertFalse(interceptor2.wasAfterCompletionInvoked()); }
@Test public void sendWithoutExecutor() { BeforeHandleInterceptor interceptor = new BeforeHandleInterceptor(); this.channel.addInterceptor(interceptor); this.channel.subscribe(this.handler); this.channel.send(this.message); verify(this.handler).handleMessage(this.message); assertEquals(1, interceptor.getCounter().get()); assertTrue(interceptor.wasAfterHandledInvoked()); }
@Test public void sendWithExecutor() { BeforeHandleInterceptor interceptor = new BeforeHandleInterceptor(); TaskExecutor executor = mock(TaskExecutor.class); ExecutorSubscribableChannel testChannel = new ExecutorSubscribableChannel(executor); testChannel.addInterceptor(interceptor); testChannel.subscribe(this.handler); testChannel.send(this.message); verify(executor).execute(this.runnableCaptor.capture()); verify(this.handler, never()).handleMessage(this.message); this.runnableCaptor.getValue().run(); verify(this.handler).handleMessage(this.message); assertEquals(1, interceptor.getCounter().get()); assertTrue(interceptor.wasAfterHandledInvoked()); }
@Test public void interceptorWithNull() { BeforeHandleInterceptor interceptor1 = new BeforeHandleInterceptor(); NullReturningBeforeHandleInterceptor interceptor2 = new NullReturningBeforeHandleInterceptor(); this.channel.addInterceptor(interceptor1); this.channel.addInterceptor(interceptor2); this.channel.subscribe(this.handler); this.channel.send(this.message); verifyNoMoreInteractions(this.handler); assertEquals(1, interceptor1.getCounter().get()); assertEquals(1, interceptor2.getCounter().get()); assertTrue(interceptor1.wasAfterHandledInvoked()); }
@Test public void preSendInterceptorReturningNull() { PreSendInterceptor interceptor1 = new PreSendInterceptor(); NullReturningPreSendInterceptor interceptor2 = new NullReturningPreSendInterceptor(); this.channel.addInterceptor(interceptor1); this.channel.addInterceptor(interceptor2); Message<?> message = MessageBuilder.withPayload("test").build(); this.channel.send(message); assertEquals(1, interceptor1.getCounter().get()); assertEquals(1, interceptor2.getCounter().get()); assertEquals(0, this.messageHandler.getMessages().size()); assertTrue(interceptor1.wasAfterCompletionInvoked()); assertFalse(interceptor2.wasAfterCompletionInvoked()); }
@Test public void interceptorWithModifiedMessage() { Message<?> expected = mock(Message.class); BeforeHandleInterceptor interceptor = new BeforeHandleInterceptor(); interceptor.setMessageToReturn(expected); this.channel.addInterceptor(interceptor); this.channel.subscribe(this.handler); this.channel.send(this.message); verify(this.handler).handleMessage(expected); assertEquals(1, interceptor.getCounter().get()); assertTrue(interceptor.wasAfterHandledInvoked()); }
@Override public boolean send(Message<?> message, long timeout) { return mySubscribableChannel.send(message, timeout); }
@Test public void interceptorWithException() { IllegalStateException expected = new IllegalStateException("Fake exception"); willThrow(expected).given(this.handler).handleMessage(this.message); BeforeHandleInterceptor interceptor = new BeforeHandleInterceptor(); this.channel.addInterceptor(interceptor); this.channel.subscribe(this.handler); try { this.channel.send(this.message); } catch (MessageDeliveryException actual) { assertSame(expected, actual.getCause()); } verify(this.handler).handleMessage(this.message); assertEquals(1, interceptor.getCounter().get()); assertTrue(interceptor.wasAfterHandledInvoked()); }