@Test public void shouldFindSimpleAggregatorMethod() { @SuppressWarnings("unused") class SimpleAggregator { public Integer and(List<Integer> flags) { int result = 0; for (Integer flag : flags) { result = result | flag; } return result; } } MethodInvokingMessageGroupProcessor processor = new MethodInvokingMessageGroupProcessor(new SimpleAggregator()); processor.setBeanFactory(mock(BeanFactory.class)); when(this.messageGroupMock.getMessages()).thenReturn(this.messagesUpForProcessing); Object result = processor.processMessageGroup(this.messageGroupMock); assertThat(((AbstractIntegrationMessageBuilder<?>) result).build().getPayload(), is(7)); }
@Test public void shouldFindSimpleAggregatorMethodWithIterator() { @SuppressWarnings("unused") class SimpleAggregator { public Integer and(Iterator<Integer> flags) { int result = 0; while (flags.hasNext()) { result = result | flags.next(); } return result; } } MethodInvokingMessageGroupProcessor processor = new MethodInvokingMessageGroupProcessor(new SimpleAggregator()); processor.setBeanFactory(mock(BeanFactory.class)); GenericConversionService conversionService = new DefaultConversionService(); conversionService.addConverter(new Converter<ArrayList<?>, Iterator<?>>() { // Must not be lambda @Override public Iterator<?> convert(ArrayList<?> source) { return source.iterator(); } }); processor.setConversionService(conversionService); when(this.messageGroupMock.getMessages()).thenReturn(this.messagesUpForProcessing); Object result = processor.processMessageGroup(this.messageGroupMock); assertThat(((AbstractIntegrationMessageBuilder<?>) result).build().getPayload(), is(7)); }
/** * Configure the handler with {@link org.springframework.integration.aggregator.MethodInvokingCorrelationStrategy} * and {@link org.springframework.integration.aggregator.MethodInvokingReleaseStrategy} using the target * object which should have methods annotated appropriately for each function. * Also set the output processor. * @param target the target object. * @param methodName The method name for the output processor (or 'null' in which case, the * target object must have an {@link org.springframework.integration.annotation.Aggregator} annotation). * @return the handler spec. */ public AggregatorSpec processor(Object target, String methodName) { super.processor(target); return this.outputProcessor(methodName != null ? new MethodInvokingMessageGroupProcessor(target, methodName) : new MethodInvokingMessageGroupProcessor(target)); }
@Test public void testHeaderParameters() { class SingleAnnotationTestBean { @Aggregator public String method1(List<String> input, @Header("foo") String foo) { return input.get(0) + foo; } } SingleAnnotationTestBean bean = new SingleAnnotationTestBean(); MethodInvokingMessageGroupProcessor processor = new MethodInvokingMessageGroupProcessor(bean); processor.setBeanFactory(mock(BeanFactory.class)); SimpleMessageGroup group = new SimpleMessageGroup("FOO"); group.add(MessageBuilder.withPayload("foo").setHeader("foo", "bar").build()); group.add(MessageBuilder.withPayload("bar").setHeader("foo", "bar").build()); assertEquals("foobar", processor.aggregatePayloads(group, processor.aggregateHeaders(group))); }
@Test public void singleAnnotation() { @SuppressWarnings("unused") class SingleAnnotationTestBean { @Aggregator public String method1(List<String> input) { return input.get(0); } public String method2(List<String> input) { return input.get(1); } } SingleAnnotationTestBean bean = new SingleAnnotationTestBean(); MethodInvokingMessageGroupProcessor aggregator = new MethodInvokingMessageGroupProcessor(bean); aggregator.setBeanFactory(mock(BeanFactory.class)); SimpleMessageGroup group = new SimpleMessageGroup("FOO"); group.add(new GenericMessage<>("foo")); group.add(new GenericMessage<>("bar")); assertEquals("foo", aggregator.aggregatePayloads(group, null)); }
@Override protected MessageHandler createHandler(Object bean, Method method, List<Annotation> annotations) { MethodInvokingMessageGroupProcessor processor = new MethodInvokingMessageGroupProcessor(bean, method); processor.setBeanFactory(this.beanFactory);
@Before public void setup() { this.defaultProcessor.setBeanFactory(mock(BeanFactory.class)); this.methodInvokingProcessor.setBeanFactory(mock(BeanFactory.class)); }
@Test(expected = IllegalStateException.class) public void noPublicMethods() { @SuppressWarnings("unused") class NoPublicMethodTestBean { String lowerCase(String s) { return s.toLowerCase(); } } NoPublicMethodTestBean bean = new NoPublicMethodTestBean(); new MethodInvokingMessageGroupProcessor(bean); }
@Test public void testHeadersParameters() { class SingleAnnotationTestBean { @Aggregator public String method1(List<String> input, @Headers Map<String, ?> map) { return input.get(0) + map.get("foo"); } } SingleAnnotationTestBean bean = new SingleAnnotationTestBean(); MethodInvokingMessageGroupProcessor aggregator = new MethodInvokingMessageGroupProcessor(bean); aggregator.setBeanFactory(mock(BeanFactory.class)); SimpleMessageGroup group = new SimpleMessageGroup("FOO"); group.add(MessageBuilder.withPayload("foo").setHeader("foo", "bar").build()); group.add(MessageBuilder.withPayload("bar").setHeader("foo", "bar").build()); assertEquals("foobar", aggregator.aggregatePayloads(group, aggregator.aggregateHeaders(group))); }
@Test public void noAnnotations() { @SuppressWarnings("unused") class NoAnnotationTestBean { public String method1(List<String> input) { return input.get(0); } String method2(List<String> input) { return input.get(1); } } NoAnnotationTestBean bean = new NoAnnotationTestBean(); MethodInvokingMessageGroupProcessor aggregator = new MethodInvokingMessageGroupProcessor(bean); aggregator.setBeanFactory(mock(BeanFactory.class)); SimpleMessageGroup group = new SimpleMessageGroup("FOO"); group.add(new GenericMessage<>("foo")); group.add(new GenericMessage<>("bar")); assertEquals("foo", aggregator.aggregatePayloads(group, null)); }
@Override protected MessageHandler createHandler(Object bean, Method method, List<Annotation> annotations) { MethodInvokingMessageGroupProcessor processor = new MethodInvokingMessageGroupProcessor(bean, method); processor.setBeanFactory(this.beanFactory);
@Test public void shouldFindSimpleAggregatorMethodWithCollection() { @SuppressWarnings("unused") class SimpleAggregator { public Integer and(Collection<Integer> flags) { int result = 0; for (Integer flag : flags) { result = result | flag; } return result; } } MethodInvokingMessageGroupProcessor processor = new MethodInvokingMessageGroupProcessor(new SimpleAggregator()); processor.setBeanFactory(mock(BeanFactory.class)); when(this.messageGroupMock.getMessages()).thenReturn(this.messagesUpForProcessing); Object result = processor.processMessageGroup(this.messageGroupMock); assertThat(((AbstractIntegrationMessageBuilder<?>) result).build().getPayload(), is(7)); }
@Test(expected = IllegalArgumentException.class) public void multipleAnnotations() { class MultipleAnnotationTestBean { @Aggregator public String method1(List<String> input) { return input.get(0); } @Aggregator public String method2(List<String> input) { return input.get(0); } } MultipleAnnotationTestBean bean = new MultipleAnnotationTestBean(); new MethodInvokingMessageGroupProcessor(bean); }
@Test public void shouldFindSimpleAggregatorMethodWithArray() { @SuppressWarnings("unused") class SimpleAggregator { public Integer and(int[] flags) { int result = 0; for (int flag : flags) { result = result | flag; } return result; } } MethodInvokingMessageGroupProcessor processor = new MethodInvokingMessageGroupProcessor(new SimpleAggregator()); processor.setBeanFactory(mock(BeanFactory.class)); when(this.messageGroupMock.getMessages()).thenReturn(this.messagesUpForProcessing); Object result = processor.processMessageGroup(this.messageGroupMock); assertThat(((AbstractIntegrationMessageBuilder<?>) result).build().getPayload(), is(7)); }
@Test(expected = IllegalArgumentException.class) public void multiplePublicMethods() { @SuppressWarnings("unused") class MultiplePublicMethodTestBean { public String upperCase(String s) { return s.toUpperCase(); } public String lowerCase(String s) { return s.toLowerCase(); } } MultiplePublicMethodTestBean bean = new MultiplePublicMethodTestBean(); new MethodInvokingMessageGroupProcessor(bean); }
@Test public void shouldFindSimpleAggregatorMethodForMessages() { @SuppressWarnings("unused") class SimpleAggregator { public Integer and(List<Message<Integer>> flags) { int result = 0; for (Message<Integer> flag : flags) { result = result | flag.getPayload(); } return result; } } MethodInvokingMessageGroupProcessor processor = new MethodInvokingMessageGroupProcessor(new SimpleAggregator()); processor.setBeanFactory(mock(BeanFactory.class)); when(this.messageGroupMock.getMessages()).thenReturn(this.messagesUpForProcessing); Object result = processor.processMessageGroup(this.messageGroupMock); assertThat(((AbstractIntegrationMessageBuilder<?>) result).build().getPayload(), is(7)); }
outputProcessor = new MethodInvokingMessageGroupProcessor(this.processorBean); outputProcessor = new MethodInvokingMessageGroupProcessor(this.processorBean, this.methodName);
@Test public void shouldUseAnnotatedPayloads() { @SuppressWarnings("unused") class SimpleAggregator { @Aggregator public String and(@Payloads List<Integer> flags) { return flags.toString(); } public String or(List<Integer> flags) { throw new UnsupportedOperationException("Not expected"); } } MethodInvokingMessageGroupProcessor processor = new MethodInvokingMessageGroupProcessor(new SimpleAggregator()); processor.setBeanFactory(mock(BeanFactory.class)); when(this.messageGroupMock.getMessages()).thenReturn(this.messagesUpForProcessing); Object result = processor.processMessageGroup(this.messageGroupMock); assertThat(((AbstractIntegrationMessageBuilder<?>) result).build().getPayload(), is("[1, 2, 4]")); }
@Test public void jdkProxy() { DirectChannel input = new DirectChannel(); QueueChannel output = new QueueChannel(); GreetingService testBean = new GreetingBean(); ProxyFactory proxyFactory = new ProxyFactory(testBean); proxyFactory.setProxyTargetClass(true); testBean = (GreetingService) proxyFactory.getProxy(); MethodInvokingMessageGroupProcessor aggregator = new MethodInvokingMessageGroupProcessor(testBean); AggregatingMessageHandler handler = new AggregatingMessageHandler(aggregator); handler.setReleaseStrategy(new MessageCountReleaseStrategy()); handler.setOutputChannel(output); handler.setBeanFactory(mock(BeanFactory.class)); handler.afterPropertiesSet(); EventDrivenConsumer endpoint = new EventDrivenConsumer(input, handler); endpoint.start(); Message<?> message = MessageBuilder.withPayload("proxy").setCorrelationId("abc").build(); input.send(message); assertEquals("hello proxy", output.receive(0).getPayload()); }
@Test public void shouldFindFittingMethodForIteratorOfMessages() { @SuppressWarnings("unused") class UnannotatedAggregator { public Iterator<?> and(Iterator<Message<?>> flags) { return flags; } public void voidMethodShouldBeIgnored(List<Integer> flags) { fail("this method should not be invoked"); } public String methodAcceptingNoCollectionShouldBeIgnored(String irrelevant) { fail("this method should not be invoked"); return null; } } MethodInvokingMessageGroupProcessor processor = new MethodInvokingMessageGroupProcessor(new UnannotatedAggregator()); processor.setBeanFactory(mock(BeanFactory.class)); when(this.messageGroupMock.getMessages()).thenReturn(this.messagesUpForProcessing); Object result = processor.processMessageGroup(this.messageGroupMock); assertThat(((AbstractIntegrationMessageBuilder<?>) result).build().getPayload(), instanceOf(Iterator.class)); }