@Test public void multipleCyclesThroughHandlers() throws Exception { dispatcher.addHandler(handler); dispatcher.addHandler(differentHandler); for (int i = 0; i < 7; i++) { dispatcher.dispatch(message); } verify(handler, times(4)).handleMessage(message); verify(differentHandler, times(3)).handleMessage(message); }
@Test public void dispatchMessageWithSingleHandler() throws Exception { dispatcher.addHandler(handler); dispatcher.dispatch(message); }
@Test public void differentHandlerInvokedOnSecondMessage() throws Exception { dispatcher.addHandler(handler); dispatcher.addHandler(differentHandler); dispatcher.dispatch(message); dispatcher.dispatch(message); verify(handler).handleMessage(message); verify(differentHandler).handleMessage(message); }
@Test public void noHandlerExhaustion() throws Exception { dispatcher.addHandler(handler1); dispatcher.addHandler(handler2); dispatcher.addHandler(handler3); dispatcher.addHandler(handler4); final CountDownLatch start = new CountDownLatch(1); final CountDownLatch allDone = new CountDownLatch(TOTAL_EXECUTIONS);
@Test public void noDuplicateSubscriptions() { UnicastingDispatcher dispatcher = new UnicastingDispatcher(); final AtomicInteger counter = new AtomicInteger(); MessageHandler target = new CountingTestEndpoint(counter, false); dispatcher.addHandler(target); dispatcher.addHandler(target); try { dispatcher.dispatch(new GenericMessage<>("test")); } catch (Exception e) { // ignore } assertEquals("target should not have duplicate subscriptions", 1, counter.get()); }
@Test public void pointToPoint() throws InterruptedException { UnicastingDispatcher dispatcher = new UnicastingDispatcher(); final CountDownLatch latch = new CountDownLatch(1); final AtomicInteger counter1 = new AtomicInteger(); final AtomicInteger counter2 = new AtomicInteger(); dispatcher.addHandler(createConsumer(TestHandlers.countingCountDownHandler(counter1, latch))); dispatcher.addHandler(createConsumer(TestHandlers.countingCountDownHandler(counter2, latch))); dispatcher.dispatch(new GenericMessage<>("test")); assertTrue(latch.await(500, TimeUnit.MILLISECONDS)); assertEquals("only 1 handler should have received the message", 1, counter1.get() + counter2.get()); }
@Test public void middleHandlerReturnsTrue() { UnicastingDispatcher dispatcher = new UnicastingDispatcher(); final AtomicInteger counter = new AtomicInteger(); MessageHandler target1 = new CountingTestEndpoint(counter, false); MessageHandler target2 = new CountingTestEndpoint(counter, true); MessageHandler target3 = new CountingTestEndpoint(counter, false); dispatcher.addHandler(target1); dispatcher.addHandler(target2); dispatcher.addHandler(target3); assertTrue(dispatcher.dispatch(new GenericMessage<>("test"))); assertEquals("first two targets should have been invoked", 2, counter.get()); }
@Test public void firstHandlerReturnsTrue() { UnicastingDispatcher dispatcher = new UnicastingDispatcher(); final AtomicInteger counter = new AtomicInteger(); MessageHandler target1 = new CountingTestEndpoint(counter, true); MessageHandler target2 = new CountingTestEndpoint(counter, false); MessageHandler target3 = new CountingTestEndpoint(counter, false); dispatcher.addHandler(target1); dispatcher.addHandler(target2); dispatcher.addHandler(target3); assertTrue(dispatcher.dispatch(new GenericMessage<>("test"))); assertEquals("only the first target should have been invoked", 1, counter.get()); }
@Test public void noHandlerSkipUnderConcurrentFailureWithFailover() throws Exception { dispatcher.addHandler(handler1); dispatcher.addHandler(handler2); doThrow(new MessageRejectedException(message, null)).when(handler1).handleMessage(message); final CountDownLatch start = new CountDownLatch(1);
@Test public void noFailoverNoLoadBalancing() { DirectChannel channel = (DirectChannel) ac.getBean("noLoadBalancerNoFailover"); doThrow(new MessageRejectedException(message, null)).when(handlerA).handleMessage(message); UnicastingDispatcher dispatcher = channel.getDispatcher(); dispatcher.addHandler(handlerA); dispatcher.addHandler(handlerB); try { channel.send(message); } catch (Exception e) { /* ignore */ } try { channel.send(message); } catch (Exception e) { /* ignore */ } verify(handlerA, times(2)).handleMessage(message); verify(handlerB, times(0)).handleMessage(message); }
@Test public void allHandlersReturnFalse() { UnicastingDispatcher dispatcher = new UnicastingDispatcher(); final AtomicInteger counter = new AtomicInteger(); MessageHandler target1 = new CountingTestEndpoint(counter, false); MessageHandler target2 = new CountingTestEndpoint(counter, false); MessageHandler target3 = new CountingTestEndpoint(counter, false); dispatcher.addHandler(target1); dispatcher.addHandler(target2); dispatcher.addHandler(target3); try { assertFalse(dispatcher.dispatch(new GenericMessage<>("test"))); } catch (Exception e) { // ignore } assertEquals("each target should have been invoked", 3, counter.get()); }
@Test public void removeConsumerBeforeSend() { UnicastingDispatcher dispatcher = new UnicastingDispatcher(); final AtomicInteger counter = new AtomicInteger(); MessageHandler target1 = new CountingTestEndpoint(counter, false); MessageHandler target2 = new CountingTestEndpoint(counter, false); MessageHandler target3 = new CountingTestEndpoint(counter, false); dispatcher.addHandler(target1); dispatcher.addHandler(target2); dispatcher.addHandler(target3); dispatcher.removeHandler(target2); try { dispatcher.dispatch(new GenericMessage<>("test")); } catch (Exception e) { // ignore } assertEquals(2, counter.get()); }
@Test public void failoverNoLoadBalancing() { DirectChannel channel = (DirectChannel) ac .getBean("noLoadBalancerFailover"); doThrow(new MessageRejectedException(message, null)).when(handlerA) .handleMessage(message); UnicastingDispatcher dispatcher = channel.getDispatcher(); dispatcher.addHandler(handlerA); dispatcher.addHandler(handlerB); InOrder inOrder = inOrder(handlerA, handlerB); try { channel.send(message); } catch (Exception e) { /* ignore */ } inOrder.verify(handlerA).handleMessage(message); inOrder.verify(handlerB).handleMessage(message); try { channel.send(message); } catch (Exception e) { /* ignore */ } inOrder.verify(handlerA).handleMessage(message); inOrder.verify(handlerB).handleMessage(message); verify(handlerA, times(2)).handleMessage(message); verify(handlerB, times(2)).handleMessage(message); }
@Test public void currentHandlerIndexOverFlow() throws Exception { dispatcher.addHandler(handler); dispatcher.addHandler(differentHandler); DirectFieldAccessor accessor = new DirectFieldAccessor( new DirectFieldAccessor(dispatcher).getPropertyValue("loadBalancingStrategy")); ((AtomicInteger) accessor.getPropertyValue("currentHandlerIndex")).set(Integer.MAX_VALUE - 5); for (int i = 0; i < 40; i++) { dispatcher.dispatch(message); } verify(handler, atLeast(18)).handleMessage(message); verify(differentHandler, atLeast(18)).handleMessage(message); }
UnicastingDispatcher dispatcher = channel.getDispatcher(); dispatcher.setLoadBalancingStrategy(new RoundRobinLoadBalancingStrategy()); dispatcher.addHandler(handlerA); dispatcher.addHandler(handlerB); dispatcher.addHandler(handlerC); InOrder inOrder = inOrder(handlerA, handlerB, handlerC); try {
@Test public void singleMessage() throws InterruptedException { UnicastingDispatcher dispatcher = new UnicastingDispatcher(); final CountDownLatch latch = new CountDownLatch(1); dispatcher.addHandler(createConsumer(TestHandlers.countDownHandler(latch))); dispatcher.dispatch(new GenericMessage<>("test")); assertTrue(latch.await(500, TimeUnit.MILLISECONDS)); }
/** * Verifies that the dispatcher adds the message to the exception if it * was not attached by the handler. */ @Test public void testExceptionEnhancement() { dispatcher.addHandler(handler); doThrow(new MessagingException("Mock Exception")). when(handler).handleMessage(message); try { dispatcher.dispatch(message); fail("Expected Exception"); } catch (MessagingException e) { assertEquals(message, e.getFailedMessage()); } }
MessageHandler target2 = new CountingTestEndpoint(counter, false); MessageHandler target3 = new CountingTestEndpoint(counter, false); dispatcher.addHandler(target1); dispatcher.addHandler(target2); dispatcher.addHandler(target3); try { dispatcher.dispatch(new GenericMessage<>("test1"));
@Test(expected = MessageDeliveryException.class) public void removeConsumerLastTargetCausesDeliveryException() { UnicastingDispatcher dispatcher = new UnicastingDispatcher(); final AtomicInteger counter = new AtomicInteger(); MessageHandler target = new CountingTestEndpoint(counter, false); dispatcher.addHandler(target); try { dispatcher.dispatch(new GenericMessage<>("test1")); } catch (Exception e) { // ignore } assertEquals(1, counter.get()); dispatcher.removeHandler(target); dispatcher.dispatch(new GenericMessage<>("test2")); }
/** * Verifies that the dispatcher does not add the message to the exception if it * was attached by the handler. */ @Test public void testNoExceptionEnhancement() { dispatcher.addHandler(handler); Message<String> dontReplaceThisMessage = MessageBuilder.withPayload("x").build(); doThrow(new MessagingException(dontReplaceThisMessage, "Mock Exception")). when(handler).handleMessage(message); try { dispatcher.dispatch(message); fail("Expected Exception"); } catch (MessagingException e) { assertEquals(dontReplaceThisMessage, e.getFailedMessage()); } } }