| /** |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.camel.impl; |
| |
| import java.lang.reflect.Field; |
| import java.lang.reflect.Method; |
| |
| import org.apache.camel.Consume; |
| import org.apache.camel.ContextTestSupport; |
| import org.apache.camel.EndpointInject; |
| import org.apache.camel.Exchange; |
| import org.apache.camel.NoSuchBeanException; |
| import org.apache.camel.PollingConsumer; |
| import org.apache.camel.Processor; |
| import org.apache.camel.Produce; |
| import org.apache.camel.Producer; |
| import org.apache.camel.ProducerTemplate; |
| import org.apache.camel.ResolveEndpointFailedException; |
| import org.apache.camel.component.mock.MockEndpoint; |
| import org.apache.camel.util.ObjectHelper; |
| |
| /** |
| * @version |
| */ |
| public class CamelPostProcessorHelperTest extends ContextTestSupport { |
| |
| private MySynchronization mySynchronization = new MySynchronization(); |
| |
| public void testConstructor() { |
| CamelPostProcessorHelper helper = new CamelPostProcessorHelper(); |
| assertNull(helper.getCamelContext()); |
| |
| helper.setCamelContext(context); |
| assertNotNull(helper.getCamelContext()); |
| } |
| |
| public void testConstructorCamelContext() { |
| CamelPostProcessorHelper helper = new CamelPostProcessorHelper(context); |
| assertNotNull(helper.getCamelContext()); |
| } |
| |
| public void testMatchContext() { |
| CamelPostProcessorHelper helper = new CamelPostProcessorHelper(context); |
| assertTrue(helper.matchContext(context.getName())); |
| assertFalse(helper.matchContext("foo")); |
| } |
| |
| public void testConsume() throws Exception { |
| CamelPostProcessorHelper helper = new CamelPostProcessorHelper(context); |
| |
| MyConsumeBean my = new MyConsumeBean(); |
| Method method = my.getClass().getMethod("consumeSomething", String.class); |
| helper.consumerInjection(method, my, "foo"); |
| |
| MockEndpoint mock = getMockEndpoint("mock:result"); |
| mock.expectedBodiesReceived("Hello World"); |
| |
| template.sendBody("seda:foo", "Hello World"); |
| |
| assertMockEndpointsSatisfied(); |
| } |
| |
| public void testConsumeSynchronization() throws Exception { |
| CamelPostProcessorHelper helper = new CamelPostProcessorHelper(context); |
| |
| MyConsumeAndSynchronizationBean my = new MyConsumeAndSynchronizationBean(); |
| Method method = my.getClass().getMethod("consumeSomething", String.class, Exchange.class); |
| helper.consumerInjection(method, my, "foo"); |
| |
| MockEndpoint mock = getMockEndpoint("mock:result"); |
| mock.expectedBodiesReceived("Hello World"); |
| |
| template.sendBody("seda:foo", "Hello World"); |
| |
| assertMockEndpointsSatisfied(); |
| |
| // give UoW a bit of time |
| Thread.sleep(500); |
| |
| assertTrue("Should have invoked onDone", mySynchronization.isOnDone()); |
| } |
| |
| public void testProduceSynchronization() throws Exception { |
| MyProduceAndSynchronizationBean my = new MyProduceAndSynchronizationBean(); |
| |
| CamelPostProcessorHelper helper = new CamelPostProcessorHelper(context); |
| Producer producer = helper.createInjectionProducer(context.getEndpoint("mock:result"), my, "foo"); |
| my.setProducer(producer); |
| |
| MockEndpoint mock = getMockEndpoint("mock:result"); |
| mock.expectedBodiesReceived("Hello World"); |
| |
| my.produceSomething("Hello World"); |
| |
| assertMockEndpointsSatisfied(); |
| |
| // give UoW a bit of time |
| Thread.sleep(500); |
| |
| assertTrue("Should have invoked onDone", mySynchronization.isOnDone()); |
| } |
| |
| public void testEndpointInjectProducerTemplate() throws Exception { |
| CamelPostProcessorHelper helper = new CamelPostProcessorHelper(context); |
| |
| MyEndpointInjectBeanProducerTemplate bean = new MyEndpointInjectBeanProducerTemplate(); |
| Method method = bean.getClass().getMethod("setProducer", ProducerTemplate.class); |
| |
| EndpointInject endpointInject = method.getAnnotation(EndpointInject.class); |
| Class<?>[] parameterTypes = method.getParameterTypes(); |
| for (Class type : parameterTypes) { |
| String propertyName = ObjectHelper.getPropertyName(method); |
| Object value = helper.getInjectionValue(type, endpointInject.uri(), endpointInject.ref(), propertyName, bean, "foo"); |
| ObjectHelper.invokeMethod(method, bean, value); |
| } |
| |
| MockEndpoint mock = getMockEndpoint("mock:result"); |
| mock.expectedBodiesReceived("Hello World"); |
| |
| assertNotNull(bean.getProducer()); |
| bean.send("Hello World"); |
| |
| assertMockEndpointsSatisfied(); |
| } |
| |
| public void testEndpointInjectProducer() throws Exception { |
| CamelPostProcessorHelper helper = new CamelPostProcessorHelper(context); |
| |
| MyEndpointBeanProducer bean = new MyEndpointBeanProducer(); |
| Method method = bean.getClass().getMethod("setProducer", Producer.class); |
| |
| EndpointInject endpointInject = method.getAnnotation(EndpointInject.class); |
| Class<?>[] parameterTypes = method.getParameterTypes(); |
| for (Class type : parameterTypes) { |
| String propertyName = ObjectHelper.getPropertyName(method); |
| Object value = helper.getInjectionValue(type, endpointInject.uri(), endpointInject.ref(), propertyName, bean, "foo"); |
| ObjectHelper.invokeMethod(method, bean, value); |
| } |
| |
| MockEndpoint mock = getMockEndpoint("mock:result"); |
| mock.expectedBodiesReceived("Hello World"); |
| |
| assertNotNull(bean.getProducer()); |
| |
| Exchange exchange = new DefaultExchange(context); |
| exchange.getIn().setBody("Hello World"); |
| |
| bean.send(exchange); |
| |
| assertMockEndpointsSatisfied(); |
| } |
| |
| public void testEndpointInjectPollingConsumer() throws Exception { |
| CamelPostProcessorHelper helper = new CamelPostProcessorHelper(context); |
| |
| MyEndpointBeanPollingConsumer bean = new MyEndpointBeanPollingConsumer(); |
| Method method = bean.getClass().getMethod("setConsumer", PollingConsumer.class); |
| |
| EndpointInject endpointInject = method.getAnnotation(EndpointInject.class); |
| Class<?>[] parameterTypes = method.getParameterTypes(); |
| for (Class type : parameterTypes) { |
| String propertyName = ObjectHelper.getPropertyName(method); |
| Object value = helper.getInjectionValue(type, endpointInject.uri(), endpointInject.ref(), propertyName, bean, "foo"); |
| ObjectHelper.invokeMethod(method, bean, value); |
| } |
| |
| template.sendBody("seda:foo", "Hello World"); |
| |
| MockEndpoint mock = getMockEndpoint("mock:result"); |
| mock.expectedBodiesReceived("Hello World"); |
| |
| assertNotNull(bean.getConsumer()); |
| |
| Exchange exchange = bean.consume(); |
| template.send("mock:result", exchange); |
| |
| assertMockEndpointsSatisfied(); |
| } |
| |
| public void testEndpointInjectProducerTemplateField() throws Exception { |
| CamelPostProcessorHelper helper = new CamelPostProcessorHelper(context); |
| |
| MyEndpointInjectProducerTemplate bean = new MyEndpointInjectProducerTemplate(); |
| Field field = bean.getClass().getField("producer"); |
| |
| EndpointInject endpointInject = field.getAnnotation(EndpointInject.class); |
| Class<?> type = field.getType(); |
| String propertyName = "producer"; |
| Object value = helper.getInjectionValue(type, endpointInject.uri(), endpointInject.ref(), propertyName, bean, "foo"); |
| |
| field.set(bean, value); |
| |
| MockEndpoint mock = getMockEndpoint("mock:result"); |
| mock.expectedBodiesReceived("Hello World"); |
| |
| Exchange exchange = new DefaultExchange(context); |
| exchange.getIn().setBody("Hello World"); |
| |
| bean.send(exchange); |
| |
| assertMockEndpointsSatisfied(); |
| } |
| |
| public void testEndpointInjectProducerTemplateFieldNoDefaultEndpoint() throws Exception { |
| CamelPostProcessorHelper helper = new CamelPostProcessorHelper(context); |
| |
| MyEndpointInjectProducerTemplateNoDefaultEndpoint bean = new MyEndpointInjectProducerTemplateNoDefaultEndpoint(); |
| Field field = bean.getClass().getField("producer"); |
| |
| EndpointInject endpointInject = field.getAnnotation(EndpointInject.class); |
| Class<?> type = field.getType(); |
| String propertyName = "producer"; |
| Object value = helper.getInjectionValue(type, endpointInject.uri(), endpointInject.ref(), propertyName, bean, "foo"); |
| |
| field.set(bean, value); |
| |
| MockEndpoint mock = getMockEndpoint("mock:result"); |
| mock.expectedBodiesReceived("Hello World"); |
| |
| Exchange exchange = new DefaultExchange(context); |
| exchange.getIn().setBody("Hello World"); |
| |
| bean.send(exchange); |
| |
| assertMockEndpointsSatisfied(); |
| } |
| |
| public void testEndpointInjectProducerTemplateFieldNameUnknown() throws Exception { |
| CamelPostProcessorHelper helper = new CamelPostProcessorHelper(context); |
| |
| MyEndpointInjectProducerTemplateNameUnknown bean = new MyEndpointInjectProducerTemplateNameUnknown(); |
| Field field = bean.getClass().getField("producer"); |
| |
| EndpointInject endpointInject = field.getAnnotation(EndpointInject.class); |
| Class<?> type = field.getType(); |
| String propertyName = "producer"; |
| |
| try { |
| helper.getInjectionValue(type, endpointInject.uri(), endpointInject.ref(), propertyName, bean, "foo"); |
| fail("Should throw exception"); |
| } catch (NoSuchBeanException e) { |
| assertEquals("No bean could be found in the registry for: unknown of type: org.apache.camel.Endpoint", e.getMessage()); |
| } |
| } |
| |
| public void testEndpointInjectProducerTemplateFieldUrlUnknown() throws Exception { |
| CamelPostProcessorHelper helper = new CamelPostProcessorHelper(context); |
| |
| MyEndpointInjectProducerTemplateUrlUnknown bean = new MyEndpointInjectProducerTemplateUrlUnknown(); |
| Field field = bean.getClass().getField("producer"); |
| |
| EndpointInject endpointInject = field.getAnnotation(EndpointInject.class); |
| Class<?> type = field.getType(); |
| String propertyName = "producer"; |
| |
| try { |
| helper.getInjectionValue(type, endpointInject.uri(), endpointInject.ref(), propertyName, bean, "foo"); |
| fail("Should throw exception"); |
| } catch (ResolveEndpointFailedException e) { |
| assertEquals("Failed to resolve endpoint: xxx://foo due to: No component found with scheme: xxx", e.getMessage()); |
| } |
| } |
| |
| public void testEndpointInjectBothUriAndRef() throws Exception { |
| CamelPostProcessorHelper helper = new CamelPostProcessorHelper(context); |
| |
| MyEndpointBothUriAndRef bean = new MyEndpointBothUriAndRef(); |
| Field field = bean.getClass().getField("producer"); |
| |
| EndpointInject endpointInject = field.getAnnotation(EndpointInject.class); |
| Class<?> type = field.getType(); |
| String propertyName = "producer"; |
| |
| try { |
| helper.getInjectionValue(type, endpointInject.uri(), endpointInject.ref(), propertyName, bean, "foo"); |
| fail("Should throw exception"); |
| } catch (IllegalArgumentException e) { |
| assertEquals("Both uri and name is provided, only either one is allowed: uri=seda:foo, ref=myEndpoint", e.getMessage()); |
| } |
| } |
| |
| public class MyConsumeBean { |
| |
| @Consume(uri = "seda:foo") |
| public void consumeSomething(String body) { |
| assertEquals("Hello World", body); |
| template.sendBody("mock:result", body); |
| } |
| } |
| |
| public class MyConsumeAndSynchronizationBean { |
| |
| @Consume(uri = "seda:foo") |
| public void consumeSomething(String body, Exchange exchange) { |
| exchange.addOnCompletion(mySynchronization); |
| assertEquals("Hello World", body); |
| template.sendBody("mock:result", body); |
| } |
| } |
| |
| public class MyProduceAndSynchronizationBean { |
| |
| @Produce(uri = "mock:result") |
| Producer producer; |
| |
| public void produceSomething(String body) throws Exception { |
| assertEquals("Hello World", body); |
| |
| Exchange exchange = producer.createExchange(); |
| exchange.addOnCompletion(mySynchronization); |
| exchange.getIn().setBody(body); |
| producer.process(exchange); |
| } |
| |
| public void setProducer(Producer producer) { |
| this.producer = producer; |
| } |
| } |
| |
| private class MySynchronization extends SynchronizationAdapter { |
| |
| private boolean onDone; |
| |
| @Override |
| public void onDone(Exchange exchange) { |
| onDone = true; |
| } |
| |
| public boolean isOnDone() { |
| return onDone; |
| } |
| } |
| |
| public class MyEndpointInjectBeanProducerTemplate { |
| |
| private ProducerTemplate producer; |
| |
| @EndpointInject(uri = "mock:result") |
| public void setProducer(ProducerTemplate producer) { |
| this.producer = producer; |
| } |
| |
| public ProducerTemplate getProducer() { |
| return producer; |
| } |
| |
| public void send(String message) { |
| producer.sendBody(message); |
| } |
| } |
| |
| public class MyEndpointBeanProducer { |
| |
| private Producer producer; |
| |
| @EndpointInject(uri = "mock:result") |
| public void setProducer(Producer producer) { |
| this.producer = producer; |
| } |
| |
| public Producer getProducer() { |
| return producer; |
| } |
| |
| public void send(Exchange exchange) throws Exception { |
| producer.process(exchange); |
| } |
| |
| } |
| |
| public class MyEndpointBeanPollingConsumer { |
| |
| private PollingConsumer consumer; |
| |
| @EndpointInject(uri = "seda:foo") |
| public void setConsumer(PollingConsumer consumer) { |
| this.consumer = consumer; |
| } |
| |
| public PollingConsumer getConsumer() { |
| return consumer; |
| } |
| |
| public Exchange consume() throws Exception { |
| return consumer.receive(1000); |
| } |
| |
| } |
| |
| public class MyEndpointInjectProducerTemplate { |
| |
| @EndpointInject(uri = "mock:result") |
| public ProducerTemplate producer; |
| |
| public void send(Exchange exchange) throws Exception { |
| producer.send(exchange); |
| } |
| |
| } |
| |
| public class MyEndpointInjectProducerTemplateNoDefaultEndpoint { |
| |
| @EndpointInject() |
| public ProducerTemplate producer; |
| |
| public void send(Exchange exchange) throws Exception { |
| producer.send("mock:result", exchange); |
| } |
| |
| } |
| |
| public class MyEndpointInjectProducerTemplateNameUnknown { |
| |
| @EndpointInject(ref = "unknown") |
| public ProducerTemplate producer; |
| |
| public void send(Exchange exchange) throws Exception { |
| producer.send(exchange); |
| } |
| |
| } |
| |
| public class MyEndpointInjectProducerTemplateUrlUnknown { |
| |
| @EndpointInject(uri = "xxx:foo") |
| public ProducerTemplate producer; |
| |
| public void send(Exchange exchange) throws Exception { |
| producer.send(exchange); |
| } |
| |
| } |
| |
| public class MyEndpointBothUriAndRef { |
| |
| @EndpointInject(uri = "seda:foo", ref = "myEndpoint") |
| public ProducerTemplate producer; |
| |
| public void send(Exchange exchange) throws Exception { |
| producer.send(exchange); |
| } |
| |
| } |
| |
| } |