@Override public void setBeanFactory(BeanFactory beanFactory) { super.setBeanFactory(beanFactory); this.processor.setBeanFactory(beanFactory); }
@Test(expected = MessageHandlingException.class) public void fromMessageWithOptionalAndRequiredHeaderAndOnlyOptionalHeaderProvided() throws Exception { Method method = TestService.class.getMethod("optionalAndRequiredHeader", String.class, Integer.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(testService, method); processor.setBeanFactory(mock(BeanFactory.class)); Message<String> message = MessageBuilder.withPayload("foo") .setHeader("prop", "bar").build(); processor.processMessage(message); }
@Test(expected = MessagingException.class) public void fromMessageInvalidMethodWithMultipleMappingAnnotations() throws Exception { Method method = MultipleMappingAnnotationTestBean.class.getMethod("test", String.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(testService, method); processor.setBeanFactory(mock(BeanFactory.class)); Message<?> message = MessageBuilder.withPayload("payload").setHeader("foo", "bar").build(); processor.processMessage(message); }
@Test public void fromMessageWithMapMethodAndHeadersAnnotation() throws Exception { Method method = TestService.class.getMethod("mapHeaders", Map.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(testService, method); processor.setBeanFactory(mock(BeanFactory.class)); Message<String> message = MessageBuilder.withPayload("test") .setHeader("attrib1", 123) .setHeader("attrib2", 456).build(); Map<String, Object> result = (Map<String, Object>) processor.processMessage(message); assertEquals(123, result.get("attrib1")); assertEquals(456, result.get("attrib2")); }
@Test public void testProcessMessageCheckedException() throws Exception { expected.expect(new ExceptionCauseMatcher(CheckedException.class)); TestErrorService service = new TestErrorService(); Method method = service.getClass().getMethod("checked", String.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(service, method); processor.setBeanFactory(mock(BeanFactory.class)); assertEquals("foo", processor.processMessage(new GenericMessage<>("foo"))); }
@Test public void messageAndHeaderWithAnnotatedMethod() throws Exception { AnnotatedTestService service = new AnnotatedTestService(); Method method = service.getClass().getMethod("messageAndHeader", Message.class, Integer.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(service, method); processor.setBeanFactory(mock(BeanFactory.class)); Message<String> message = MessageBuilder.withPayload("foo").setHeader("number", 42).build(); Object result = processor.processMessage(message); assertEquals("foo-42", result); }
@Test public void fromMessageToPayload() throws Exception { Method method = TestService.class.getMethod("mapOnly", Map.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(testService, method); processor.setBeanFactory(mock(BeanFactory.class)); Message<Employee> message = MessageBuilder.withPayload(employee).setHeader("number", "jkl").build(); Object result = processor.processMessage(message); Assert.assertTrue(result instanceof Map); Assert.assertEquals("jkl", ((Map<?, ?>) result).get("number")); }
@Test public void payloadAsMethodParameterAndMessageAsReturnValue() { MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(new TestBean(), "acceptPayloadAndReturnMessage"); processor.setBeanFactory(mock(BeanFactory.class)); Message<?> result = (Message<?>) processor.processMessage(new GenericMessage<>("testing")); assertEquals("testing-2", result.getPayload()); }
@Test public void messageAsMethodParameterAndMessageAsReturnValue() { MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(new TestBean(), "acceptMessageAndReturnMessage"); processor.setBeanFactory(mock(BeanFactory.class)); Message<?> result = (Message<?>) processor.processMessage(new GenericMessage<>("testing")); assertEquals("testing-4", result.getPayload()); }
@Test public void fromMessageWithRequiredHeaderProvided() throws Exception { Method method = TestService.class.getMethod("requiredHeader", Integer.class); Message<String> message = MessageBuilder.withPayload("foo") .setHeader("num", 123).build(); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(testService, method); processor.setBeanFactory(mock(BeanFactory.class)); Object result = processor.processMessage(message); assertEquals(123, result); }
@Test public void fromMessageWithOptionalAndRequiredHeaderAndOnlyRequiredHeaderProvided() throws Exception { Method method = TestService.class.getMethod("optionalAndRequiredHeader", String.class, Integer.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(testService, method); processor.setBeanFactory(mock(BeanFactory.class)); Message<String> message = MessageBuilder.withPayload("foo") .setHeader("num", 123).build(); Object result = processor.processMessage(message); assertEquals("null123", result); }
@Test public void fromMessageToPayloadArgs() throws Exception { Method method = TestService.class.getMethod("payloadAnnotationFullName", String.class, String.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(testService, method); processor.setBeanFactory(mock(BeanFactory.class)); Message<Employee> message = MessageBuilder.withPayload(employee).setHeader("number", "jkl").build(); Object result = processor.processMessage(message); Assert.assertEquals("oleg zhurakousky", result); }
@Test public void fromMessageToPayloadArgsHeaderArgs() throws Exception { Method method = TestService.class.getMethod("payloadArgAndHeaderArg", String.class, String.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(testService, method); processor.setBeanFactory(mock(BeanFactory.class)); Message<Employee> message = MessageBuilder.withPayload(employee).setHeader("day", "monday").build(); Object result = processor.processMessage(message); Assert.assertEquals("olegmonday", result); }
@Test public void testProcessMessageMethodNotFound() throws Exception { expected.expect(new ExceptionCauseMatcher(SpelEvaluationException.class)); TestDifferentErrorService service = new TestDifferentErrorService(); Method method = TestErrorService.class.getMethod("checked", String.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(service, method); processor.setUseSpelInvoker(true); processor.setBeanFactory(mock(BeanFactory.class)); processor.processMessage(new GenericMessage<>("foo")); }
@Test public void fromMessageToPayloadArg() throws Exception { Method method = TestService.class.getMethod("payloadAnnotationFirstName", String.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(testService, method); processor.setBeanFactory(mock(BeanFactory.class)); Message<Employee> message = MessageBuilder.withPayload(employee).setHeader("number", "jkl").build(); Object result = processor.processMessage(message); Assert.assertTrue(result instanceof String); Assert.assertEquals("oleg", result); }
@Test public void fromMessageToHeadersWithExpressions() throws Exception { Method method = TestService.class.getMethod("headersWithExpressions", String.class, String.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(testService, method); processor.setBeanFactory(mock(BeanFactory.class)); Employee employee = new Employee("John", "Doe"); Message<?> message = MessageBuilder.withPayload("payload").setHeader("emp", employee).build(); Object result = processor.processMessage(message); assertEquals("DOE, John", result); }
@Test public void testOverloadedNonVoidReturningMethodsWithExactMatchForType() { AmbiguousMethodBean bean = new AmbiguousMethodBean(); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(bean, "foo"); processor.setBeanFactory(mock(BeanFactory.class)); processor.processMessage(MessageBuilder.withPayload("true").build()); assertNotNull(bean.lastArg); assertEquals(String.class, bean.lastArg.getClass()); assertEquals("true", bean.lastArg); }
@Override protected MessageHandler createHandler(Object bean, Method method, List<Annotation> annotations) { LoggingHandler.Level level = MessagingAnnotationUtils.resolveAttribute(annotations, "level", LoggingHandler.Level.class); LoggingHandler loggingHandler = new LoggingHandler(level.name()); MethodInvokingMessageProcessor<String> processor = new MethodInvokingMessageProcessor<>(bean, method); processor.setBeanFactory(this.beanFactory); loggingHandler.setLogExpression(new FunctionExpression<>(processor::processMessage)); return loggingHandler; }
@Test public void payloadAndHeaderAnnotationMethodParametersAndObjectAsReturnValue() { MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(new TestBean(), "acceptPayloadAndHeaderAndReturnObject"); processor.setBeanFactory(mock(BeanFactory.class)); Message<?> request = MessageBuilder.withPayload("testing").setHeader("number", 123).build(); Object result = processor.processMessage(request); assertEquals("testing-123", result); }
@Test public void testVoidMethodsIncludedByDefault() { MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(new TestBean(), "testVoidReturningMethods"); processor.setBeanFactory(mock(BeanFactory.class)); assertNull(processor.processMessage(MessageBuilder.withPayload("Something").build())); assertEquals(12, processor.processMessage(MessageBuilder.withPayload(12).build())); }