camel-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From davscl...@apache.org
Subject [3/9] camel git commit: CAMEL-9201: Improved Camel CDI component
Date Fri, 15 Jan 2016 13:44:11 GMT
http://git-wip-us.apache.org/repos/asf/camel/blob/0421c24d/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/InjectedTypeConverterTest.java
----------------------------------------------------------------------
diff --git a/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/InjectedTypeConverterTest.java b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/InjectedTypeConverterTest.java
new file mode 100644
index 0000000..6e43984
--- /dev/null
+++ b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/InjectedTypeConverterTest.java
@@ -0,0 +1,103 @@
+/**
+ * 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.cdi.test;
+
+import java.util.Properties;
+import java.util.concurrent.TimeUnit;
+import javax.enterprise.context.ApplicationScoped;
+import javax.enterprise.inject.Produces;
+import javax.inject.Named;
+
+import org.apache.camel.NoTypeConversionAvailableException;
+import org.apache.camel.ProducerTemplate;
+import org.apache.camel.TypeConverter;
+import org.apache.camel.cdi.CdiCamelExtension;
+import org.apache.camel.cdi.Uri;
+import org.apache.camel.cdi.bean.InjectedTypeConverterRoute;
+import org.apache.camel.cdi.converter.InjectedTypeConverter;
+import org.apache.camel.cdi.pojo.TypeConverterInput;
+import org.apache.camel.cdi.pojo.TypeConverterOutput;
+import org.apache.camel.component.mock.MockEndpoint;
+import org.apache.camel.component.properties.PropertiesComponent;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.shrinkwrap.api.Archive;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.EmptyAsset;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.apache.camel.component.mock.MockEndpoint.assertIsSatisfied;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+@RunWith(Arquillian.class)
+public class InjectedTypeConverterTest {
+
+    @Deployment
+    public static Archive<?> deployment() {
+        return ShrinkWrap.create(JavaArchive.class)
+            // Camel CDI
+            .addPackage(CdiCamelExtension.class.getPackage())
+            // Test class
+            .addClass(InjectedTypeConverterRoute.class)
+            // Type converter
+            .addClass(InjectedTypeConverter.class)
+            // No need as Camel CDI automatically registers the type converter bean
+            //.addAsManifestResource(new StringAsset("org.apache.camel.cdi.se.converter"), ArchivePaths.create("services/org/apache/camel/TypeConverter"))
+            // Bean archive deployment descriptor
+            .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
+    }
+
+    @Produces
+    @ApplicationScoped
+    @Named("properties")
+    private static PropertiesComponent configuration() {
+        Properties properties = new Properties();
+        properties.put("property1", "value 1");
+        properties.put("property2", "value 2");
+        PropertiesComponent component = new PropertiesComponent();
+        component.setInitialProperties(properties);
+        return component;
+    }
+
+    @Test
+    public void sendMessageToInbound(@Uri("direct:inbound") ProducerTemplate inbound,
+                                     @Uri("mock:outbound") MockEndpoint outbound) throws InterruptedException {
+        outbound.expectedMessageCount(1);
+
+        TypeConverterInput input = new TypeConverterInput();
+        input.setProperty("property value is [{{property1}}]");
+        
+        inbound.sendBody(input);
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, outbound);
+        assertThat(outbound.getExchanges().get(0).getIn().getBody(TypeConverterOutput.class).getProperty(), is(equalTo("property value is [value 1]")));
+    }
+
+    @Test
+    public void convertWithTypeConverter(TypeConverter converter) throws NoTypeConversionAvailableException {
+        TypeConverterInput input = new TypeConverterInput();
+        input.setProperty("property value is [{{property2}}]");
+
+        TypeConverterOutput output = converter.mandatoryConvertTo(TypeConverterOutput.class, input);
+
+        assertThat(output.getProperty(), is(equalTo("property value is [value 2]")));
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/0421c24d/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/ManualCamelContextTest.java
----------------------------------------------------------------------
diff --git a/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/ManualCamelContextTest.java b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/ManualCamelContextTest.java
new file mode 100644
index 0000000..31cacd7
--- /dev/null
+++ b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/ManualCamelContextTest.java
@@ -0,0 +1,117 @@
+/**
+ * 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.cdi.test;
+
+import java.util.concurrent.TimeUnit;
+import javax.inject.Inject;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.ProducerTemplate;
+import org.apache.camel.ServiceStatus;
+import org.apache.camel.cdi.CdiCamelExtension;
+import org.apache.camel.cdi.Uri;
+import org.apache.camel.cdi.bean.ManualCamelRoute;
+import org.apache.camel.cdi.bean.SimpleCamelRoute;
+import org.apache.camel.cdi.qualifier.Manual;
+import org.apache.camel.component.mock.MockEndpoint;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.arquillian.junit.InSequence;
+import org.jboss.shrinkwrap.api.Archive;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.EmptyAsset;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.apache.camel.component.mock.MockEndpoint.assertIsSatisfied;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+@RunWith(Arquillian.class)
+public class ManualCamelContextTest {
+
+    @Inject
+    @Uri("direct:start")
+    private ProducerTemplate inbound;
+
+    @Inject
+    @Uri("mock:result")
+    private MockEndpoint outbound;
+
+    @Inject
+    @Uri("direct:manual")
+    private ProducerTemplate manual;
+
+    @Inject
+    @Uri("mock:manual")
+    private MockEndpoint mock;
+
+    @Inject
+    @Manual
+    private ManualCamelRoute builder;
+
+    @Deployment
+    public static Archive<?> deployment() {
+        return ShrinkWrap.create(JavaArchive.class)
+            // Camel CDI
+            .addPackage(CdiCamelExtension.class.getPackage())
+            // Test classes
+            .addClasses(SimpleCamelRoute.class, ManualCamelRoute.class)
+            // Bean archive deployment descriptor
+            .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
+    }
+
+    @Test
+    @InSequence(1)
+    public void verifyContext(CamelContext context) {
+        assertThat("Number of routes is incorrect!", context.getRoutes().size(), is(equalTo(1)));
+        assertThat("Configured route is incorrect!", context.getRouteStatus("simple"), is(equalTo(ServiceStatus.Started)));
+    }
+
+    @Test
+    @InSequence(2)
+    public void addManualRoute(CamelContext context) throws Exception {
+        context.addRoutes(builder);
+
+        assertThat("Number of routes is incorrect!", context.getRoutes().size(), is(equalTo(2)));
+        assertThat("Configured route is incorrect!", context.getRouteStatus("manual"), is(equalTo(ServiceStatus.Started)));
+    }
+
+    @Test
+    @InSequence(3)
+    public void sendMessageToInbound() throws InterruptedException {
+        outbound.expectedMessageCount(1);
+        outbound.expectedBodiesReceived("test");
+
+        inbound.sendBody("test");
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, outbound);
+    }
+
+    @Test
+    @InSequence(4)
+    public void sendMessageToManual() throws InterruptedException {
+        mock.expectedMessageCount(1);
+        mock.expectedBodiesReceived("manual");
+
+        manual.sendBody("manual");
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, mock);
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/0421c24d/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MockEndpointTest.java
----------------------------------------------------------------------
diff --git a/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MockEndpointTest.java b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MockEndpointTest.java
new file mode 100644
index 0000000..7bf0ba7
--- /dev/null
+++ b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MockEndpointTest.java
@@ -0,0 +1,84 @@
+/**
+ * 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.cdi.test;
+
+import java.util.concurrent.TimeUnit;
+import javax.inject.Inject;
+
+import org.apache.camel.ProducerTemplate;
+import org.apache.camel.cdi.CdiCamelExtension;
+import org.apache.camel.cdi.Mock;
+import org.apache.camel.cdi.Uri;
+import org.apache.camel.cdi.bean.DefaultCamelContextBean;
+import org.apache.camel.cdi.bean.MockAnnotationRoute;
+import org.apache.camel.component.mock.MockEndpoint;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.shrinkwrap.api.Archive;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.EmptyAsset;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.apache.camel.component.mock.MockEndpoint.assertIsSatisfied;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+@RunWith(Arquillian.class)
+public class MockEndpointTest {
+
+    @Inject
+    private DefaultCamelContextBean defaultCamelContext;
+
+    @Inject
+    @Uri("direct:start")
+    private ProducerTemplate defaultInbound;
+
+    @Inject
+    @Mock("mock:result")
+    private MockEndpoint defaultOutbound;
+
+    @Deployment
+    public static Archive<?> deployment() {
+        return ShrinkWrap.create(JavaArchive.class)
+            // Camel CDI
+            .addPackage(CdiCamelExtension.class.getPackage())
+            // Test classes
+            .addClasses(DefaultCamelContextBean.class, MockAnnotationRoute.class)
+            // Bean archive deployment descriptor
+            .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
+    }
+
+    @Test
+    public void verifyCamelContext() {
+        assertThat(defaultCamelContext.getName(), is(equalTo("camel-cdi")));
+        assertThat(defaultOutbound.getCamelContext().getName(), is(equalTo(defaultCamelContext.getName())));
+    }
+
+    @Test
+    public void sendMessageToInbound() throws InterruptedException {
+        defaultOutbound.expectedMessageCount(1);
+        defaultOutbound.expectedBodiesReceived("test");
+        defaultOutbound.expectedHeaderReceived("foo", "bar");
+
+        defaultInbound.sendBodyAndHeader("test", "foo", "bar");
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, defaultOutbound);
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/0421c24d/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiCamelContextProducerTest.java
----------------------------------------------------------------------
diff --git a/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiCamelContextProducerTest.java b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiCamelContextProducerTest.java
new file mode 100644
index 0000000..ebfbf70
--- /dev/null
+++ b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiCamelContextProducerTest.java
@@ -0,0 +1,168 @@
+/**
+ * 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.cdi.test;
+
+import java.util.concurrent.TimeUnit;
+import javax.enterprise.context.ApplicationScoped;
+import javax.enterprise.inject.Produces;
+import javax.inject.Inject;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.ProducerTemplate;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.cdi.CdiCamelExtension;
+import org.apache.camel.cdi.ContextName;
+import org.apache.camel.cdi.Uri;
+import org.apache.camel.cdi.bean.DefaultCamelContextBean;
+import org.apache.camel.cdi.bean.FirstCamelContextRoute;
+import org.apache.camel.cdi.bean.UriEndpointRoute;
+import org.apache.camel.component.mock.MockEndpoint;
+import org.apache.camel.impl.DefaultCamelContext;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.arquillian.junit.InSequence;
+import org.jboss.shrinkwrap.api.Archive;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.EmptyAsset;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.apache.camel.cdi.expression.ExchangeExpression.fromCamelContext;
+import static org.apache.camel.component.mock.MockEndpoint.assertIsSatisfied;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+@RunWith(Arquillian.class)
+public class MultiCamelContextProducerTest {
+
+    @Produces
+    @ApplicationScoped
+    @ContextName("first")
+    private static CamelContext firstContext = new DefaultCamelContext();
+
+    @Inject
+    // Support bean class injection for custom beans
+    private DefaultCamelContextBean defaultCamelContext;
+
+    @Inject @Uri("direct:inbound")
+    private ProducerTemplate defaultInbound;
+
+    @Inject @Uri("mock:outbound")
+    private MockEndpoint defaultOutbound;
+
+    @Inject @ContextName("first")
+    private CamelContext firstCamelContext;
+
+    @Inject @ContextName("first") @Uri("direct:inbound")
+    private ProducerTemplate firstInbound;
+
+    @Inject @ContextName("first") @Uri("mock:outbound")
+    private MockEndpoint firstOutbound;
+
+    @Inject @ContextName("second")
+    private CamelContext secondCamelContext;
+
+    @Inject @ContextName("second") @Uri("direct:inbound")
+    private ProducerTemplate secondInbound;
+
+    @Inject @ContextName("second") @Uri("mock:outbound")
+    private MockEndpoint secondOutbound;
+
+    @Produces
+    @ApplicationScoped
+    @ContextName("second")
+    private static CamelContext secondContext() {
+        return new DefaultCamelContext();
+    }
+
+    @Deployment
+    public static Archive<?> deployment() {
+        return ShrinkWrap.create(JavaArchive.class)
+            // Camel CDI
+            .addPackage(CdiCamelExtension.class.getPackage())
+            // Test classes
+            .addClasses(
+                DefaultCamelContextBean.class,
+                UriEndpointRoute.class,
+                FirstCamelContextRoute.class)
+            // Bean archive deployment descriptor
+            .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
+    }
+
+    @Test
+    @InSequence(1)
+    public void verifyCamelContexts() {
+        assertThat(defaultCamelContext.getName(), is(equalTo("camel-cdi")));
+        assertThat(firstCamelContext.getName(), is(equalTo("first")));
+        assertThat(secondCamelContext.getName(), is(equalTo("second")));
+
+        assertThat(defaultOutbound.getCamelContext().getName(), is(equalTo(defaultCamelContext.getName())));
+        assertThat(firstOutbound.getCamelContext().getName(), is(equalTo(firstCamelContext.getName())));
+        assertThat(secondOutbound.getCamelContext().getName(), is(equalTo(secondCamelContext.getName())));
+    }
+
+    @Test
+    @InSequence(2)
+    public void configureCamelContexts() throws Exception {
+        secondCamelContext.addRoutes(new RouteBuilder() {
+            @Override
+            public void configure() {
+                from("direct:inbound").setHeader("context").constant("second").to("mock:outbound");
+            }
+        });
+    }
+
+    @Test
+    @InSequence(3)
+    public void sendMessageToDefaultCamelContextInbound() throws InterruptedException {
+        defaultOutbound.expectedMessageCount(1);
+        defaultOutbound.expectedBodiesReceived("test-default");
+        defaultOutbound.message(0).exchange().matches(fromCamelContext("camel-cdi"));
+
+        defaultInbound.sendBody("test-default");
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, defaultOutbound);
+    }
+
+    @Test
+    @InSequence(4)
+    public void sendMessageToFirstCamelContextInbound() throws InterruptedException {
+        firstOutbound.expectedMessageCount(1);
+        firstOutbound.expectedBodiesReceived("test-first");
+        firstOutbound.expectedHeaderReceived("context", "first");
+        firstOutbound.message(0).exchange().matches(fromCamelContext("first"));
+
+        firstInbound.sendBody("test-first");
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, firstOutbound);
+    }
+
+    @Test
+    @InSequence(5)
+    public void sendMessageToSecondCamelContextInbound() throws InterruptedException {
+        secondOutbound.expectedMessageCount(1);
+        secondOutbound.expectedBodiesReceived("test-second");
+        secondOutbound.expectedHeaderReceived("context", "second");
+        secondOutbound.message(0).exchange().matches(fromCamelContext("second"));
+
+        secondInbound.sendBody("test-second");
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, secondOutbound);
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/0421c24d/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiCamelContextTest.java
----------------------------------------------------------------------
diff --git a/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiCamelContextTest.java b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiCamelContextTest.java
new file mode 100644
index 0000000..2eafb09
--- /dev/null
+++ b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiCamelContextTest.java
@@ -0,0 +1,159 @@
+/**
+ * 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.cdi.test;
+
+import java.util.concurrent.TimeUnit;
+import javax.inject.Inject;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.ProducerTemplate;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.cdi.CdiCamelExtension;
+import org.apache.camel.cdi.ContextName;
+import org.apache.camel.cdi.Uri;
+import org.apache.camel.cdi.bean.DefaultCamelContextBean;
+import org.apache.camel.cdi.bean.FirstCamelContextBean;
+import org.apache.camel.cdi.bean.FirstCamelContextRoute;
+import org.apache.camel.cdi.bean.SecondCamelContextBean;
+import org.apache.camel.cdi.bean.UriEndpointRoute;
+import org.apache.camel.component.mock.MockEndpoint;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.arquillian.junit.InSequence;
+import org.jboss.shrinkwrap.api.Archive;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.EmptyAsset;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.apache.camel.cdi.expression.ExchangeExpression.fromCamelContext;
+import static org.apache.camel.component.mock.MockEndpoint.assertIsSatisfied;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+@RunWith(Arquillian.class)
+public class MultiCamelContextTest {
+
+    @Inject
+    // Support bean class injection for custom beans
+    private DefaultCamelContextBean defaultCamelContext;
+
+    @Inject @Uri("direct:inbound")
+    private ProducerTemplate defaultInbound;
+
+    @Inject @Uri("mock:outbound")
+    private MockEndpoint defaultOutbound;
+
+    @Inject @ContextName("first")
+    private CamelContext firstCamelContext;
+
+    @Inject @ContextName("first") @Uri("direct:inbound")
+    private ProducerTemplate firstInbound;
+
+    @Inject @ContextName("first") @Uri("mock:outbound")
+    private MockEndpoint firstOutbound;
+
+    @Inject @ContextName("second")
+    private CamelContext secondCamelContext;
+
+    @Inject @ContextName("second") @Uri("direct:inbound")
+    private ProducerTemplate secondInbound;
+
+    @Inject @ContextName("second") @Uri("mock:outbound")
+    private MockEndpoint secondOutbound;
+
+    @Deployment
+    public static Archive<?> deployment() {
+        return ShrinkWrap.create(JavaArchive.class)
+            // Camel CDI
+            .addPackage(CdiCamelExtension.class.getPackage())
+            // Test classes
+            .addClasses(
+                DefaultCamelContextBean.class,
+                UriEndpointRoute.class,
+                FirstCamelContextBean.class,
+                FirstCamelContextRoute.class,
+                SecondCamelContextBean.class)
+            // Bean archive deployment descriptor
+            .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
+    }
+
+    @Test
+    @InSequence(1)
+    public void verifyCamelContexts() {
+        assertThat(defaultCamelContext.getName(), is(equalTo("camel-cdi")));
+        assertThat(firstCamelContext.getName(), is(equalTo("first")));
+        assertThat(secondCamelContext.getName(), is(equalTo("second")));
+
+        assertThat(defaultOutbound.getCamelContext().getName(), is(equalTo(defaultCamelContext.getName())));
+        assertThat(firstOutbound.getCamelContext().getName(), is(equalTo(firstCamelContext.getName())));
+        assertThat(secondOutbound.getCamelContext().getName(), is(equalTo(secondCamelContext.getName())));
+    }
+
+    @Test
+    @InSequence(2)
+    public void configureCamelContexts() throws Exception {
+        secondCamelContext.addRoutes(new RouteBuilder() {
+            @Override
+            public void configure() {
+                from("direct:inbound").setHeader("context").constant("second").to("mock:outbound");
+            }
+        });
+
+        secondCamelContext.startAllRoutes();
+    }
+
+    @Test
+    @InSequence(3)
+    public void sendMessageToDefaultCamelContextInbound() throws InterruptedException {
+        defaultOutbound.expectedMessageCount(1);
+        defaultOutbound.expectedBodiesReceived("test-default");
+        defaultOutbound.message(0).exchange().matches(fromCamelContext("camel-cdi"));
+
+        defaultInbound.sendBody("test-default");
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, defaultOutbound);
+    }
+
+    @Test
+    @InSequence(4)
+    public void sendMessageToFirstCamelContextInbound() throws InterruptedException {
+        firstOutbound.expectedMessageCount(1);
+        firstOutbound.expectedBodiesReceived("test-first");
+        firstOutbound.expectedHeaderReceived("context", "first");
+        firstOutbound.message(0).exchange().matches(fromCamelContext("first"));
+
+        firstInbound.sendBody("test-first");
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, firstOutbound);
+    }
+
+    @Test
+    @InSequence(5)
+    public void sendMessageToSecondCamelContextInbound() throws InterruptedException {
+        secondOutbound.expectedMessageCount(1);
+        secondOutbound.expectedBodiesReceived("test-second");
+        secondOutbound.expectedHeaderReceived("context", "second");
+        secondOutbound.message(0).exchange().matches(fromCamelContext("second"));
+
+        secondInbound.sendBody("test-second");
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, secondOutbound);
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/0421c24d/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiContextEndpointInjectTest.java
----------------------------------------------------------------------
diff --git a/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiContextEndpointInjectTest.java b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiContextEndpointInjectTest.java
new file mode 100644
index 0000000..5ce8eb3
--- /dev/null
+++ b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiContextEndpointInjectTest.java
@@ -0,0 +1,137 @@
+/**
+ * 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.cdi.test;
+
+import java.util.concurrent.TimeUnit;
+import javax.inject.Inject;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.ProducerTemplate;
+import org.apache.camel.cdi.CdiCamelExtension;
+import org.apache.camel.cdi.ContextName;
+import org.apache.camel.cdi.Uri;
+import org.apache.camel.cdi.bean.DefaultCamelContextBean;
+import org.apache.camel.cdi.bean.EndpointInjectRoute;
+import org.apache.camel.cdi.bean.FirstCamelContextBean;
+import org.apache.camel.cdi.bean.FirstCamelContextEndpointInjectRoute;
+import org.apache.camel.cdi.bean.SecondCamelContextBean;
+import org.apache.camel.cdi.bean.SecondCamelContextEndpointInjectRoute;
+import org.apache.camel.component.mock.MockEndpoint;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.arquillian.junit.InSequence;
+import org.jboss.shrinkwrap.api.Archive;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.EmptyAsset;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.apache.camel.cdi.expression.ExchangeExpression.fromCamelContext;
+import static org.apache.camel.component.mock.MockEndpoint.assertIsSatisfied;
+
+@RunWith(Arquillian.class)
+public class MultiContextEndpointInjectTest {
+
+    @Inject
+    private CamelContext defaultCamelContext;
+
+    @Inject @Uri("direct:inbound")
+    private ProducerTemplate defaultInbound;
+
+    @Inject @Uri("mock:outbound")
+    private MockEndpoint defaultOutbound;
+
+    @Inject @ContextName("first")
+    private CamelContext firstCamelContext;
+
+    @Inject @ContextName("first") @Uri("direct:inbound")
+    private ProducerTemplate firstInbound;
+
+    @Inject @ContextName("first") @Uri("mock:outbound")
+    private MockEndpoint firstOutbound;
+
+    @Inject @ContextName("second")
+    private CamelContext secondCamelContext;
+
+    @Inject @ContextName("second") @Uri("direct:inbound")
+    private ProducerTemplate secondInbound;
+
+    @Inject @ContextName("second") @Uri("mock:outbound")
+    private MockEndpoint secondOutbound;
+
+    @Deployment
+    public static Archive<?> deployment() {
+        return ShrinkWrap.create(JavaArchive.class)
+            // Camel CDI
+            .addPackage(CdiCamelExtension.class.getPackage())
+            // Test classes
+            .addClasses(
+                DefaultCamelContextBean.class,
+                EndpointInjectRoute.class,
+                FirstCamelContextBean.class,
+                FirstCamelContextEndpointInjectRoute.class,
+                SecondCamelContextBean.class,
+                SecondCamelContextEndpointInjectRoute.class)
+            // Bean archive deployment descriptor
+            .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
+    }
+
+    @Test
+    @InSequence(1)
+    public void configureCamelContexts() throws Exception {
+        secondCamelContext.startAllRoutes();
+    }
+
+    @Test
+    @InSequence(2)
+    public void sendMessageToDefaultCamelContextInbound() throws InterruptedException {
+        defaultOutbound.expectedMessageCount(1);
+        defaultOutbound.expectedBodiesReceived("test-default");
+        defaultOutbound.message(0).exchange().matches(fromCamelContext("camel-cdi"));
+
+        defaultInbound.sendBody("test-default");
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, defaultOutbound);
+    }
+
+    @Test
+    @InSequence(3)
+    public void sendMessageToFirstCamelContextInbound() throws InterruptedException {
+        firstOutbound.expectedMessageCount(1);
+        firstOutbound.expectedBodiesReceived("test-first");
+        firstOutbound.expectedHeaderReceived("context", "first");
+        firstOutbound.message(0).exchange().matches(fromCamelContext("first"));
+
+        firstInbound.sendBody("test-first");
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, firstOutbound);
+    }
+
+    @Test
+    @InSequence(4)
+    public void sendMessageToSecondCamelContextInbound() throws InterruptedException {
+        secondOutbound.expectedMessageCount(1);
+        secondOutbound.expectedBodiesReceived("test-second");
+        secondOutbound.expectedHeaderReceived("context", "second");
+        secondOutbound.message(0).exchange().matches(fromCamelContext("second"));
+
+        secondInbound.sendBody("test-second");
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, secondOutbound);
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/0421c24d/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiContextEventEndpointTest.java
----------------------------------------------------------------------
diff --git a/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiContextEventEndpointTest.java b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiContextEventEndpointTest.java
new file mode 100644
index 0000000..c6b51af
--- /dev/null
+++ b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiContextEventEndpointTest.java
@@ -0,0 +1,190 @@
+/**
+ * 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.cdi.test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import javax.enterprise.context.ApplicationScoped;
+import javax.enterprise.event.Event;
+import javax.enterprise.event.Observes;
+import javax.inject.Inject;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.ProducerTemplate;
+import org.apache.camel.cdi.CdiCamelExtension;
+import org.apache.camel.cdi.ContextName;
+import org.apache.camel.cdi.Uri;
+import org.apache.camel.cdi.bean.FirstCamelContextBean;
+import org.apache.camel.cdi.bean.FirstCamelContextEventConsumingRoute;
+import org.apache.camel.cdi.bean.FirstCamelContextEventProducingRoute;
+import org.apache.camel.cdi.bean.SecondCamelContextBean;
+import org.apache.camel.cdi.bean.SecondCamelContextEventConsumingRoute;
+import org.apache.camel.cdi.bean.SecondCamelContextEventProducingRoute;
+import org.apache.camel.component.mock.MockEndpoint;
+import org.hamcrest.Matchers;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.arquillian.junit.InSequence;
+import org.jboss.shrinkwrap.api.Archive;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.EmptyAsset;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.apache.camel.component.mock.MockEndpoint.assertIsSatisfied;
+import static org.hamcrest.Matchers.contains;
+import static org.junit.Assert.assertThat;
+
+@RunWith(Arquillian.class)
+public class MultiContextEventEndpointTest {
+
+    @Inject
+    @ContextName("first")
+    @Uri("mock:consumeString")
+    private MockEndpoint firstConsumeString;
+
+    @Inject
+    @ContextName("second")
+    @Uri("mock:consumeString")
+    private MockEndpoint secondConsumeString;
+
+    @Inject
+    @ContextName("first")
+    @Uri("direct:produceString")
+    private ProducerTemplate firstProduceString;
+
+    @Inject
+    @ContextName("second")
+    @Uri("direct:produceString")
+    private ProducerTemplate secondProduceString;
+
+    @Inject
+    private Event<Object> objectEvent;
+
+    @Inject
+    private EventObserver observer;
+
+    @Deployment
+    public static Archive<?> deployment() {
+        return ShrinkWrap.create(JavaArchive.class)
+            // Camel CDI
+            .addPackage(CdiCamelExtension.class.getPackage())
+            // Test classes
+            .addClasses(
+                FirstCamelContextBean.class,
+                FirstCamelContextEventConsumingRoute.class,
+                FirstCamelContextEventProducingRoute.class,
+                SecondCamelContextBean.class,
+                SecondCamelContextEventConsumingRoute.class,
+                SecondCamelContextEventProducingRoute.class)
+            // Bean archive deployment descriptor
+            .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
+    }
+
+    @Test
+    @InSequence(1)
+    public void configureCamelContexts(@ContextName("second") CamelContext secondContext) throws Exception {
+        secondContext.startAllRoutes();
+    }
+
+    @Test
+    @InSequence(2)
+    public void sendEventsToConsumers() throws InterruptedException {
+        firstConsumeString.expectedMessageCount(1);
+        firstConsumeString.expectedBodiesReceived("testFirst");
+
+        secondConsumeString.expectedMessageCount(2);
+        secondConsumeString.expectedBodiesReceived("testSecond1", "testSecond2");
+
+        objectEvent.select(String.class, new ContextName.Literal("first")).fire("testFirst");
+        objectEvent.select(String.class, new ContextName.Literal("second")).fire("testSecond1");
+        objectEvent.select(String.class, new ContextName.Literal("second")).fire("testSecond2");
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, firstConsumeString, secondConsumeString);
+    }
+
+    @Test
+    @InSequence(3)
+    public void sendMessagesToProducers() {
+        firstProduceString.sendBody("testFirst");
+        secondProduceString.sendBody("testSecond");
+
+        assertThat(observer.getObjectEvents(), Matchers.<Object>contains("testFirst", "testSecond"));
+        assertThat(observer.getStringEvents(), contains("testFirst", "testSecond"));
+        assertThat(observer.getFirstStringEvents(), contains("testFirst"));
+        assertThat(observer.secondStringEvents(), contains("testSecond"));
+    }
+
+    @Before
+    public void resetCollectedEvents() {
+        observer.reset();
+    }
+
+    @ApplicationScoped
+    static class EventObserver {
+
+        private final List<Object> objectEvents = new ArrayList<>();
+
+        private final List<String> stringEvents = new ArrayList<>();
+
+        private final List<String> firstStringEvents = new ArrayList<>();
+
+        private final List<String> secondStringEvents = new ArrayList<>();
+
+        void collectObjectEvents(@Observes Object event) {
+            objectEvents.add(event);
+        }
+
+        void collectStringEvents(@Observes String event) {
+            stringEvents.add(event);
+        }
+
+        void collectFirstStringEvents(@Observes @ContextName("first") String event) {
+            firstStringEvents.add(event);
+        }
+
+        void collectSecondStringEvents(@Observes @ContextName("second") String event) {
+            secondStringEvents.add(event);
+        }
+
+        List<Object> getObjectEvents() {
+            return objectEvents;
+        }
+
+        List<String> getStringEvents() {
+            return stringEvents;
+        }
+
+        List<String> getFirstStringEvents() {
+            return firstStringEvents;
+        }
+
+        List<String> secondStringEvents() {
+            return secondStringEvents;
+        }
+
+        void reset() {
+            objectEvents.clear();
+            stringEvents.clear();
+            firstStringEvents.clear();
+            secondStringEvents.clear();
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/0421c24d/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiContextEventNotifierTest.java
----------------------------------------------------------------------
diff --git a/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiContextEventNotifierTest.java b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiContextEventNotifierTest.java
new file mode 100644
index 0000000..57d24fe
--- /dev/null
+++ b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiContextEventNotifierTest.java
@@ -0,0 +1,300 @@
+/**
+ * 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.cdi.test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import javax.enterprise.context.ApplicationScoped;
+import javax.enterprise.event.Observes;
+import javax.enterprise.inject.Any;
+import javax.enterprise.inject.Default;
+import javax.enterprise.inject.Produces;
+import javax.inject.Inject;
+import javax.inject.Named;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.ProducerTemplate;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.cdi.CdiCamelExtension;
+import org.apache.camel.cdi.ContextName;
+import org.apache.camel.cdi.Uri;
+import org.apache.camel.cdi.bean.DefaultCamelContextBean;
+import org.apache.camel.cdi.bean.FirstCamelContextBean;
+import org.apache.camel.cdi.bean.FirstCamelContextRoute;
+import org.apache.camel.cdi.bean.SecondCamelContextBean;
+import org.apache.camel.cdi.bean.UriEndpointRoute;
+import org.apache.camel.component.mock.MockEndpoint;
+import org.apache.camel.management.event.AbstractExchangeEvent;
+import org.apache.camel.management.event.CamelContextStartedEvent;
+import org.apache.camel.management.event.CamelContextStartingEvent;
+import org.apache.camel.management.event.ExchangeCompletedEvent;
+import org.apache.camel.management.event.ExchangeCreatedEvent;
+import org.apache.camel.management.event.ExchangeSendingEvent;
+import org.apache.camel.management.event.ExchangeSentEvent;
+import org.hamcrest.Matchers;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.arquillian.junit.InSequence;
+import org.jboss.shrinkwrap.api.Archive;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.EmptyAsset;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.apache.camel.cdi.expression.ExchangeExpression.fromCamelContext;
+import static org.apache.camel.component.mock.MockEndpoint.assertIsSatisfied;
+import static org.hamcrest.Matchers.everyItem;
+import static org.hamcrest.Matchers.hasSize;
+import static org.junit.Assert.assertThat;
+
+@RunWith(Arquillian.class)
+public class MultiContextEventNotifierTest {
+
+    @Inject
+    // Support bean class injection for custom beans
+    private DefaultCamelContextBean defaultCamelContext;
+
+    @Inject @Uri("direct:inbound")
+    private ProducerTemplate defaultInbound;
+
+    @Inject @Uri("mock:outbound")
+    private MockEndpoint defaultOutbound;
+
+    @Produces @ApplicationScoped
+    private List<Class> defaultFiredEvents = new ArrayList<>();
+
+
+    @Inject @ContextName("first")
+    private CamelContext firstCamelContext;
+
+    @Inject @ContextName("first") @Uri("direct:inbound")
+    private ProducerTemplate firstInbound;
+
+    @Inject @ContextName("first") @Uri("mock:outbound")
+    private MockEndpoint firstOutbound;
+
+    @Produces @ApplicationScoped @ContextName("first")
+    private List<Class> firstFiredEvents = new ArrayList<>();
+
+
+    @Inject @ContextName("second")
+    private CamelContext secondCamelContext;
+
+    @Inject @ContextName("second") @Uri("direct:inbound")
+    private ProducerTemplate secondInbound;
+
+    @Inject @ContextName("second") @Uri("mock:outbound")
+    private MockEndpoint secondOutbound;
+
+    @Produces @ApplicationScoped @ContextName("second")
+    private List<Class> secondFiredEvents = new ArrayList<>();
+
+
+    @Produces @ApplicationScoped @Any @Named("anyContext")
+    private List<Class> anyFiredEvents = new ArrayList<>();
+
+
+    private void onAnyContextStartingEvent(@Observes CamelContextStartingEvent event, @Named("anyContext") List<Class> events) {
+        events.add(CamelContextStartingEvent.class);
+    }
+
+    private void onAnyContextStartedEvent(@Observes CamelContextStartedEvent event, @Named("anyContext") List<Class> events) {
+        events.add(CamelContextStartedEvent.class);
+    }
+
+    private void onAnyExchangeEvent(@Observes AbstractExchangeEvent event, @Named("anyContext") List<Class> events) {
+        events.add(event.getClass());
+    }
+
+
+    private void onDefaultContextStartingEvent(@Observes @Default CamelContextStartingEvent event, List<Class> events) {
+        events.add(CamelContextStartingEvent.class);
+    }
+
+    private void onDefaultContextStartedEvent(@Observes @Default CamelContextStartedEvent event, List<Class> events) {
+        events.add(CamelContextStartedEvent.class);
+    }
+
+    private void onDefaultExchangeEvent(@Observes @Default AbstractExchangeEvent event, List<Class> events) {
+        events.add(event.getClass());
+    }
+
+
+    private void onFirstContextStartingEvent(@Observes @ContextName("first") CamelContextStartingEvent event, @ContextName("first") List<Class> events) {
+        events.add(CamelContextStartingEvent.class);
+    }
+
+    private void onFirstContextStartedEvent(@Observes @ContextName("first") CamelContextStartedEvent event, @ContextName("first") List<Class> events) {
+        events.add(CamelContextStartedEvent.class);
+    }
+
+    private void onFirstExchangeEvent(@Observes @ContextName("first") AbstractExchangeEvent event, @ContextName("first") List<Class> events) {
+        events.add(event.getClass());
+    }
+
+
+    private void onSecondContextStartingEvent(@Observes @ContextName("second") CamelContextStartingEvent event, @ContextName("second") List<Class> events) {
+        events.add(CamelContextStartingEvent.class);
+    }
+
+    private void onSecondContextStartedEvent(@Observes @ContextName("second") CamelContextStartedEvent event, @ContextName("second") List<Class> events) {
+        events.add(CamelContextStartedEvent.class);
+    }
+
+    private void onSecondExchangeEvent(@Observes @ContextName("second") AbstractExchangeEvent event, @ContextName("second") List<Class> events) {
+        events.add(event.getClass());
+    }
+
+    @Deployment
+    public static Archive<?> deployment() {
+        return ShrinkWrap.create(JavaArchive.class)
+            // Camel CDI
+            .addPackage(CdiCamelExtension.class.getPackage())
+            // Test classes
+            .addClasses(
+                DefaultCamelContextBean.class,
+                UriEndpointRoute.class,
+                FirstCamelContextBean.class,
+                FirstCamelContextRoute.class,
+                SecondCamelContextBean.class)
+            // Bean archive deployment descriptor
+            .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
+    }
+
+    @Test
+    @InSequence(1)
+    public void configureCamelContexts(List<Class> defaultEvents,
+                                       @ContextName("first") List<Class> firstEvents,
+                                       @ContextName("second") List<Class> secondEvents,
+                                       @Named("anyContext") List<Class> anyEvents) throws Exception {
+        secondCamelContext.addRoutes(new RouteBuilder() {
+            @Override
+            public void configure() {
+                from("direct:inbound").setHeader("context").constant("second").to("mock:outbound");
+            }
+        });
+
+        secondCamelContext.startAllRoutes();
+
+        assertThat("Events fired for any contexts are incorrect", anyEvents,
+            everyItem(
+                Matchers.<Class>isOneOf(
+                    CamelContextStartingEvent.class,
+                    CamelContextStartedEvent.class)));
+        assertThat("Events fired for default context are incorrect", defaultEvents,
+            Matchers.<Class>contains(
+                CamelContextStartingEvent.class,
+                CamelContextStartedEvent.class));
+        assertThat("Events fired for first context are incorrect", firstEvents,
+            Matchers.<Class>contains(
+                CamelContextStartingEvent.class,
+                CamelContextStartedEvent.class));
+        assertThat("Events fired for second context are incorrect", secondEvents,
+            Matchers.<Class>contains(
+                CamelContextStartingEvent.class,
+                CamelContextStartedEvent.class));
+    }
+
+    @Test
+    @InSequence(2)
+    public void sendMessageToDefaultCamelContextInbound(List<Class> events) throws InterruptedException {
+        defaultOutbound.expectedMessageCount(1);
+        defaultOutbound.expectedBodiesReceived("test-default");
+        defaultOutbound.message(0).exchange().matches(fromCamelContext("camel-cdi"));
+
+        defaultInbound.sendBody("test-default");
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, defaultOutbound);
+
+        assertThat("Events fired are incorrect", events,
+            Matchers.<Class>contains(
+                CamelContextStartingEvent.class,
+                CamelContextStartedEvent.class,
+                ExchangeSendingEvent.class,
+                ExchangeCreatedEvent.class,
+                ExchangeSendingEvent.class,
+                ExchangeSentEvent.class,
+                ExchangeCompletedEvent.class,
+                ExchangeSentEvent.class));
+    }
+
+    @Test
+    @InSequence(3)
+    public void sendMessageToFirstCamelContextInbound(@ContextName("first") List<Class> events) throws InterruptedException {
+        firstOutbound.expectedMessageCount(1);
+        firstOutbound.expectedBodiesReceived("test-first");
+        firstOutbound.expectedHeaderReceived("context", "first");
+        firstOutbound.message(0).exchange().matches(fromCamelContext("first"));
+
+        firstInbound.sendBody("test-first");
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, firstOutbound);
+
+        assertThat("Events fired are incorrect", events,
+            Matchers.<Class>contains(
+                CamelContextStartingEvent.class,
+                CamelContextStartedEvent.class,
+                ExchangeSendingEvent.class,
+                ExchangeCreatedEvent.class,
+                ExchangeSendingEvent.class,
+                ExchangeSentEvent.class,
+                ExchangeCompletedEvent.class,
+                ExchangeSentEvent.class));
+    }
+
+    @Test
+    @InSequence(4)
+    public void sendMessageToSecondCamelContextInbound(@ContextName("second") List<Class> events) throws InterruptedException {
+        secondOutbound.expectedMessageCount(1);
+        secondOutbound.expectedBodiesReceived("test-second");
+        secondOutbound.expectedHeaderReceived("context", "second");
+        secondOutbound.message(0).exchange().matches(fromCamelContext("second"));
+
+        secondInbound.sendBody("test-second");
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, secondOutbound);
+
+        assertThat("Events fired are incorrect", events,
+            Matchers.<Class>contains(
+                CamelContextStartingEvent.class,
+                CamelContextStartedEvent.class,
+                ExchangeSendingEvent.class,
+                ExchangeCreatedEvent.class,
+                ExchangeSendingEvent.class,
+                ExchangeSentEvent.class,
+                ExchangeCompletedEvent.class,
+                ExchangeSentEvent.class));
+    }
+
+    @Test
+    @InSequence(5)
+    public void stopCamelContexts(List<Class> defaultEvents,
+                                  @ContextName("first") List<Class> firstEvents,
+                                  @ContextName("second") List<Class> secondEvents,
+                                  @Named("anyContext") List<Class> anyEvents) throws Exception {
+        defaultCamelContext.stop();
+        firstCamelContext.stop();
+        secondCamelContext.stop();
+
+        assertThat("Events count fired for default context are incorrect", defaultEvents, hasSize(8));
+        assertThat("Events count fired for first context are incorrect", firstEvents, hasSize(8));
+        assertThat("Events count fired for second context are incorrect", secondEvents, hasSize(8));
+        assertThat("Events count fired for any contexts are incorrect", anyEvents, hasSize(24));
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/0421c24d/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiContextProduceTemplateTest.java
----------------------------------------------------------------------
diff --git a/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiContextProduceTemplateTest.java b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiContextProduceTemplateTest.java
new file mode 100644
index 0000000..730c065
--- /dev/null
+++ b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiContextProduceTemplateTest.java
@@ -0,0 +1,157 @@
+/**
+ * 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.cdi.test;
+
+import java.util.concurrent.TimeUnit;
+import javax.inject.Inject;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.ProducerTemplate;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.cdi.CdiCamelExtension;
+import org.apache.camel.cdi.ContextName;
+import org.apache.camel.cdi.Uri;
+import org.apache.camel.cdi.bean.DefaultCamelContextBean;
+import org.apache.camel.cdi.bean.FirstCamelContextBean;
+import org.apache.camel.cdi.bean.FirstCamelContextProduceTemplateBean;
+import org.apache.camel.cdi.bean.ProduceTemplateBean;
+import org.apache.camel.cdi.bean.SecondCamelContextBean;
+import org.apache.camel.cdi.bean.SecondCamelContextProduceTemplateBean;
+import org.apache.camel.component.mock.MockEndpoint;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.arquillian.junit.InSequence;
+import org.jboss.shrinkwrap.api.Archive;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.EmptyAsset;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.apache.camel.cdi.expression.ExchangeExpression.fromCamelContext;
+import static org.apache.camel.component.mock.MockEndpoint.assertIsSatisfied;
+
+@RunWith(Arquillian.class)
+public class MultiContextProduceTemplateTest {
+
+    @Inject
+    private CamelContext defaultCamelContext;
+
+    @Inject @Uri("direct:inbound")
+    private ProducerTemplate defaultInbound;
+
+    @Inject @Uri("mock:outbound")
+    private MockEndpoint defaultOutbound;
+
+    @Inject @ContextName("first")
+    private CamelContext firstCamelContext;
+
+    @Inject @ContextName("first") @Uri("direct:inbound")
+    private ProducerTemplate firstInbound;
+
+    @Inject @ContextName("first") @Uri("mock:outbound")
+    private MockEndpoint firstOutbound;
+
+    @Inject @ContextName("second")
+    private CamelContext secondCamelContext;
+
+    @Inject @ContextName("second") @Uri("direct:inbound")
+    private ProducerTemplate secondInbound;
+
+    @Inject @ContextName("second") @Uri("mock:outbound")
+    private MockEndpoint secondOutbound;
+
+    @Deployment
+    public static Archive<?> deployment() {
+        return ShrinkWrap.create(JavaArchive.class)
+            // Camel CDI
+            .addPackage(CdiCamelExtension.class.getPackage())
+            // Test classes
+            .addClasses(
+                DefaultCamelContextBean.class,
+                ProduceTemplateBean.class,
+                FirstCamelContextBean.class,
+                FirstCamelContextProduceTemplateBean.class,
+                SecondCamelContextBean.class,
+                SecondCamelContextProduceTemplateBean.class)
+            // Bean archive deployment descriptor
+            .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
+    }
+
+    @Test
+    @InSequence(1)
+    public void configureCamelContexts() throws Exception {
+        defaultCamelContext.addRoutes(new RouteBuilder() {
+            @Override
+            public void configure() {
+                from("direct:inbound").bean(ProduceTemplateBean.class);
+            }
+        });
+
+        firstCamelContext.addRoutes(new RouteBuilder() {
+            @Override
+            public void configure() {
+                from("direct:inbound").bean(FirstCamelContextProduceTemplateBean.class);
+            }
+        });
+
+        secondCamelContext.addRoutes(new RouteBuilder() {
+            @Override
+            public void configure() {
+                from("direct:inbound").bean(SecondCamelContextProduceTemplateBean.class);
+            }
+        });
+
+        secondCamelContext.startAllRoutes();
+    }
+
+    @Test
+    @InSequence(2)
+    public void sendMessageToDefaultCamelContextInbound() throws InterruptedException {
+        defaultOutbound.expectedMessageCount(1);
+        defaultOutbound.expectedBodiesReceived("test-processed");
+        defaultOutbound.message(0).exchange().matches(fromCamelContext("camel-cdi"));
+
+        defaultInbound.sendBody("test");
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, defaultOutbound);
+    }
+
+    @Test
+    @InSequence(3)
+    public void sendMessageToFirstCamelContextInbound() throws InterruptedException {
+        firstOutbound.expectedMessageCount(1);
+        firstOutbound.expectedBodiesReceived("test-first");
+        firstOutbound.message(0).exchange().matches(fromCamelContext("first"));
+
+        firstInbound.sendBody("test");
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, firstOutbound);
+    }
+
+    @Test
+    @InSequence(4)
+    public void sendMessageToSecondCamelContextInbound() throws InterruptedException {
+        secondOutbound.expectedMessageCount(1);
+        secondOutbound.expectedBodiesReceived("test-second");
+        secondOutbound.message(0).exchange().matches(fromCamelContext("second"));
+
+        secondInbound.sendBody("test");
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, secondOutbound);
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/0421c24d/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiContextPropertyInjectTest.java
----------------------------------------------------------------------
diff --git a/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiContextPropertyInjectTest.java b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiContextPropertyInjectTest.java
new file mode 100644
index 0000000..024a304
--- /dev/null
+++ b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/MultiContextPropertyInjectTest.java
@@ -0,0 +1,193 @@
+/**
+ * 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.cdi.test;
+
+import java.util.Properties;
+import java.util.concurrent.TimeUnit;
+import javax.enterprise.context.ApplicationScoped;
+import javax.enterprise.inject.Produces;
+import javax.inject.Inject;
+import javax.inject.Named;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.ProducerTemplate;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.cdi.CdiCamelExtension;
+import org.apache.camel.cdi.ContextName;
+import org.apache.camel.cdi.Uri;
+import org.apache.camel.cdi.bean.DefaultCamelContextBean;
+import org.apache.camel.cdi.bean.FirstCamelContextBean;
+import org.apache.camel.cdi.bean.FirstCamelContextPropertyInjectBean;
+import org.apache.camel.cdi.bean.PropertyInjectBean;
+import org.apache.camel.cdi.bean.SecondCamelContextBean;
+import org.apache.camel.cdi.bean.SecondCamelContextPropertyInjectBean;
+import org.apache.camel.component.mock.MockEndpoint;
+import org.apache.camel.component.properties.PropertiesComponent;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.arquillian.junit.InSequence;
+import org.jboss.shrinkwrap.api.Archive;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.EmptyAsset;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.apache.camel.component.mock.MockEndpoint.assertIsSatisfied;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+@RunWith(Arquillian.class)
+public class MultiContextPropertyInjectTest {
+
+    @Inject
+    private CamelContext defaultCamelContext;
+
+    @Inject @Uri("direct:in")
+    private ProducerTemplate defaultInbound;
+
+    @Inject @Uri("mock:out")
+    private MockEndpoint defaultOutbound;
+
+    @Inject @ContextName("first")
+    private CamelContext firstCamelContext;
+
+    @Inject @ContextName("first") @Uri("direct:in")
+    private ProducerTemplate firstInbound;
+
+    @Inject @ContextName("first") @Uri("mock:out")
+    private MockEndpoint firstOutbound;
+
+    @Inject @ContextName("second")
+    private CamelContext secondCamelContext;
+
+    @Inject @ContextName("second") @Uri("direct:in")
+    private ProducerTemplate secondInbound;
+
+    @Inject @ContextName("second") @Uri("mock:out")
+    private MockEndpoint secondOutbound;
+
+    @Produces
+    @ApplicationScoped
+    @Named("properties")
+    private static PropertiesComponent configuration() {
+        Properties properties = new Properties();
+        properties.put("property", "default");
+        PropertiesComponent component = new PropertiesComponent();
+        component.setInitialProperties(properties);
+        return component;
+    }
+
+    @Deployment
+    public static Archive<?> deployment() {
+        return ShrinkWrap.create(JavaArchive.class)
+            // Camel CDI
+            .addPackage(CdiCamelExtension.class.getPackage())
+            // Test classes
+            .addClasses(
+                DefaultCamelContextBean.class,
+                PropertyInjectBean.class,
+                FirstCamelContextBean.class,
+                FirstCamelContextPropertyInjectBean.class,
+                SecondCamelContextBean.class,
+                SecondCamelContextPropertyInjectBean.class)
+            // Bean archive deployment descriptor
+            .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
+    }
+
+    @Test
+    @InSequence(1)
+    public void configureCamelContexts() throws Exception {
+        defaultCamelContext.addRoutes(new RouteBuilder() {
+            @Override
+            public void configure() {
+                from("direct:in").bean(PropertyInjectBean.class).to("mock:out");
+            }
+        });
+
+        firstCamelContext.addRoutes(new RouteBuilder() {
+            @Override
+            public void configure() {
+                from("direct:in").bean(FirstCamelContextPropertyInjectBean.class).to("mock:out");
+            }
+        });
+
+        secondCamelContext.addRoutes(new RouteBuilder() {
+            @Override
+            public void configure() {
+                from("direct:in").bean(SecondCamelContextPropertyInjectBean.class).to("mock:out");
+            }
+        });
+
+        secondCamelContext.startAllRoutes();
+    }
+
+    @Test
+    @InSequence(2)
+    public void sendMessageToDefaultCamelContextInbound() throws InterruptedException {
+        defaultOutbound.expectedMessageCount(1);
+        defaultOutbound.expectedBodiesReceived("test");
+        defaultOutbound.expectedHeaderReceived("header", "default");
+
+        defaultInbound.sendBody("test");
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, defaultOutbound);
+    }
+
+    @Test
+    @InSequence(3)
+    public void retrieveReferenceFromDefaultCamelContext(PropertyInjectBean bean) {
+        assertThat(bean.getProperty(), is(equalTo("default")));
+    }
+
+    @Test
+    @InSequence(4)
+    public void sendMessageToFirstCamelContextInbound() throws InterruptedException {
+        firstOutbound.expectedMessageCount(1);
+        firstOutbound.expectedBodiesReceived("test");
+        firstOutbound.expectedHeaderReceived("header", "default");
+
+        firstInbound.sendBody("test");
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, firstOutbound);
+    }
+
+    @Test
+    @InSequence(5)
+    public void retrieveReferenceFromFirstCamelContext(FirstCamelContextPropertyInjectBean bean) {
+        assertThat(bean.getProperty(), is(equalTo("default")));
+    }
+
+    @Test
+    @InSequence(6)
+    public void sendMessageToSecondCamelContextInbound() throws InterruptedException {
+        secondOutbound.expectedMessageCount(1);
+        secondOutbound.expectedBodiesReceived("test");
+        secondOutbound.expectedHeaderReceived("header", "default");
+
+        secondInbound.sendBody("test");
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, secondOutbound);
+    }
+
+    @Test
+    @InSequence(7)
+    public void retrieveReferenceFromSecondCamelContext(SecondCamelContextPropertyInjectBean bean) {
+        assertThat(bean.getProperty(), is(equalTo("default")));
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/0421c24d/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/NamedCamelBeanTest.java
----------------------------------------------------------------------
diff --git a/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/NamedCamelBeanTest.java b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/NamedCamelBeanTest.java
new file mode 100644
index 0000000..cb93c55
--- /dev/null
+++ b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/NamedCamelBeanTest.java
@@ -0,0 +1,75 @@
+/**
+ * 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.cdi.test;
+
+import java.util.concurrent.TimeUnit;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.ProducerTemplate;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.cdi.CdiCamelExtension;
+import org.apache.camel.cdi.Uri;
+import org.apache.camel.cdi.bean.NamedCamelBean;
+import org.apache.camel.component.mock.MockEndpoint;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.arquillian.junit.InSequence;
+import org.jboss.shrinkwrap.api.Archive;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.EmptyAsset;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.apache.camel.component.mock.MockEndpoint.assertIsSatisfied;
+
+@RunWith(Arquillian.class)
+public class NamedCamelBeanTest {
+
+    @Deployment
+    public static Archive<?> deployment() {
+        return ShrinkWrap.create(JavaArchive.class)
+            // Camel CDI
+            .addPackage(CdiCamelExtension.class.getPackage())
+            // Test class
+            .addClass(NamedCamelBean.class)
+            // Bean archive deployment descriptor
+            .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
+    }
+
+    @Test
+    @InSequence(1)
+    public void configureCamelContext(CamelContext context) throws Exception {
+        context.addRoutes(new RouteBuilder() {
+            @Override
+            public void configure() {
+                from("direct:inbound").bean("beanName").to("mock:outbound");
+            }
+        });
+    }
+
+    @Test
+    @InSequence(2)
+    public void sendMessageToInbound(@Uri("direct:inbound") ProducerTemplate in, @Uri("mock:outbound") MockEndpoint out) throws InterruptedException {
+        out.expectedMessageCount(1);
+        out.expectedBodiesReceived("test-processed");
+        
+        in.sendBody("test");
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, out);
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/0421c24d/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/NamedCamelContextTest.java
----------------------------------------------------------------------
diff --git a/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/NamedCamelContextTest.java b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/NamedCamelContextTest.java
new file mode 100644
index 0000000..92adb38
--- /dev/null
+++ b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/NamedCamelContextTest.java
@@ -0,0 +1,114 @@
+/**
+ * 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.cdi.test;
+
+import javax.enterprise.context.ApplicationScoped;
+import javax.enterprise.inject.Instance;
+import javax.enterprise.inject.Produces;
+import javax.inject.Named;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.cdi.CdiCamelExtension;
+import org.apache.camel.impl.DefaultCamelContext;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.shrinkwrap.api.Archive;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.EmptyAsset;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.hasProperty;
+import static org.junit.Assert.assertThat;
+
+@RunWith(Arquillian.class)
+public class NamedCamelContextTest {
+
+    @Named
+    @Produces
+    @ApplicationScoped
+    private CamelContext emptyNamedFieldContext = new DefaultCamelContext();
+
+    @Produces
+    @ApplicationScoped
+    @Named("named-field-context")
+    private CamelContext namedFieldContext = new DefaultCamelContext();
+
+    @Named
+    @Produces
+    @ApplicationScoped
+    private CamelContext getEmptyNamedGetterContext() {
+        return new DefaultCamelContext();
+    }
+
+    @Named
+    @Produces
+    @ApplicationScoped
+    private CamelContext getEmptyNamedMethodContext() {
+        return new DefaultCamelContext();
+    }
+
+    @Produces
+    @ApplicationScoped
+    @Named("named-getter-context")
+    private CamelContext getNamedGetterContext() {
+        return new DefaultCamelContext();
+    }
+
+    @Produces
+    @ApplicationScoped
+    @Named("named-method-context")
+    private CamelContext getNamedMethodContext() {
+        return new DefaultCamelContext();
+    }
+
+    @Deployment
+    public static Archive<?> deployment() {
+        return ShrinkWrap.create(JavaArchive.class)
+            // Camel CDI
+            .addPackage(CdiCamelExtension.class.getPackage())
+            // Bean archive deployment descriptor
+            .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
+    }
+
+    @Test
+    public void verifyCamelContexts(Instance<CamelContext> contexts) {
+        assertThat(contexts, containsInAnyOrder(
+            hasProperty("name", equalTo("emptyNamedFieldContext")),
+            hasProperty("name", equalTo("emptyNamedGetterContext")),
+            hasProperty("name", equalTo("emptyNamedMethodContext")),
+            hasProperty("name", equalTo("named-field-context")),
+            hasProperty("name", equalTo("named-getter-context")),
+            hasProperty("name", equalTo("named-method-context")),
+            hasProperty("name", equalTo("emptyNamedBeanContext")),
+            hasProperty("name", equalTo("named-bean-context"))
+        ));
+    }
+
+    @Named
+    @ApplicationScoped
+    static class EmptyNamedBeanContext extends DefaultCamelContext {
+    }
+
+    @ApplicationScoped
+    @Named("named-bean-context")
+    static class NamedBeanContext extends DefaultCamelContext {
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/0421c24d/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/ProduceTemplateTest.java
----------------------------------------------------------------------
diff --git a/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/ProduceTemplateTest.java b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/ProduceTemplateTest.java
new file mode 100644
index 0000000..77e9cef
--- /dev/null
+++ b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/ProduceTemplateTest.java
@@ -0,0 +1,76 @@
+/**
+ * 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.cdi.test;
+
+import java.util.concurrent.TimeUnit;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.ProducerTemplate;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.cdi.CdiCamelExtension;
+import org.apache.camel.cdi.Uri;
+import org.apache.camel.cdi.bean.ProduceTemplateBean;
+import org.apache.camel.component.mock.MockEndpoint;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.arquillian.junit.InSequence;
+import org.jboss.shrinkwrap.api.Archive;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.EmptyAsset;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.apache.camel.component.mock.MockEndpoint.assertIsSatisfied;
+
+@RunWith(Arquillian.class)
+public class ProduceTemplateTest {
+
+    @Deployment
+    public static Archive<?> deployment() {
+        return ShrinkWrap.create(JavaArchive.class)
+            // Camel CDI
+            .addPackage(CdiCamelExtension.class.getPackage())
+            // Test class
+            .addClass(ProduceTemplateBean.class)
+            // Bean archive deployment descriptor
+            .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
+    }
+
+    @Test
+    @InSequence(1)
+    public void configureCamelContext(CamelContext context) throws Exception {
+        context.addRoutes(new RouteBuilder() {
+            @Override
+            public void configure() {
+                from("direct:inbound").bean(ProduceTemplateBean.class);
+            }
+        });
+    }
+
+    @Test
+    @InSequence(2)
+    public void sendMessageToInbound(@Uri("direct:inbound") ProducerTemplate in,
+                                     @Uri("mock:outbound") MockEndpoint out) throws InterruptedException {
+        out.expectedMessageCount(1);
+        out.expectedBodiesReceived("test-processed");
+        
+        in.sendBody("test");
+
+        assertIsSatisfied(2L, TimeUnit.SECONDS, out);
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/0421c24d/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/PropertiesLocationTest.java
----------------------------------------------------------------------
diff --git a/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/PropertiesLocationTest.java b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/PropertiesLocationTest.java
new file mode 100644
index 0000000..a6ec82f
--- /dev/null
+++ b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/PropertiesLocationTest.java
@@ -0,0 +1,102 @@
+/**
+ * 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.cdi.test;
+
+import javax.enterprise.context.ApplicationScoped;
+import javax.enterprise.inject.Produces;
+import javax.inject.Named;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.cdi.CdiCamelExtension;
+import org.apache.camel.component.properties.PropertiesComponent;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.container.test.api.OperateOnDeployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.shrinkwrap.api.Archive;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.EmptyAsset;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+@RunWith(Arquillian.class)
+public class PropertiesLocationTest {
+
+    @Deployment(name = "single-location")
+    public static Archive<?> deployment() {
+        return ShrinkWrap.create(JavaArchive.class)
+            // Camel CDI
+            .addPackage(CdiCamelExtension.class.getPackage())
+            // Test class
+            .addClass(SingleLocation.class)
+            // Bean archive deployment descriptor
+            .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
+    }
+
+    // TODO: reactivate when ARQ-1255 is fixed
+    /*
+    @Deployment(name = "multiple-locations")
+    public static Archive<?> multipleLocationsDeployment() {
+        return ShrinkWrap.create(JavaArchive.class)
+            // Camel CDI
+            .addPackage(CdiCamelExtension.class.getPackage())
+            // Test classes
+            .addClass(MultipleLocations.class)
+            // Bean archive deployment descriptor
+            .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
+    }
+    */
+
+    @Test
+    @OperateOnDeployment("single-location")
+    public void resolvePropertyFromLocation(CamelContext context) throws Exception {
+        assertThat("Property from classpath location does not resolve!", context.resolvePropertyPlaceholders("{{header.message}}"), is(equalTo("message from file")));
+    }
+
+    /*
+    @Test
+    @OperateOnDeployment("multiple-locations")
+    public void resolvePropertyFromLocations(CamelContext context) throws Exception {
+        assertThat("Property from classpath locations does not resolve!", context.resolvePropertyPlaceholders("{{foo.property}}"), is(equalTo("foo.value")));
+        assertThat("Property from classpath locations does not resolve!", context.resolvePropertyPlaceholders("{{bar.property}}"), is(equalTo("bar.value")));
+    }
+    */
+}
+
+class SingleLocation {
+
+    @Produces
+    @ApplicationScoped
+    @Named("properties")
+    private static PropertiesComponent configuration() {
+        return new PropertiesComponent("classpath:placeholder.properties");
+    }
+}
+
+class MultipleLocations {
+
+    @Produces
+    @ApplicationScoped
+    @Named("properties")
+    private static PropertiesComponent configuration() {
+        return new PropertiesComponent("classpath:foo.properties", "classpath:bar.properties");
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/camel/blob/0421c24d/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/PropertiesMultipleLocationTest.java
----------------------------------------------------------------------
diff --git a/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/PropertiesMultipleLocationTest.java b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/PropertiesMultipleLocationTest.java
new file mode 100644
index 0000000..3f038a4
--- /dev/null
+++ b/components/camel-cdi/src/test/java/org/apache/camel/cdi/test/PropertiesMultipleLocationTest.java
@@ -0,0 +1,55 @@
+/**
+ * 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.cdi.test;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.cdi.CdiCamelExtension;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.container.test.api.OperateOnDeployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.shrinkwrap.api.Archive;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.EmptyAsset;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+@RunWith(Arquillian.class)
+public class PropertiesMultipleLocationTest {
+
+    @Deployment(name = "multiple-locations")
+    public static Archive<?> multipleLocationsDeployment() {
+        return ShrinkWrap.create(JavaArchive.class)
+            // Camel CDI
+            .addPackage(CdiCamelExtension.class.getPackage())
+            // Test class
+            .addClass(MultipleLocations.class)
+            // Bean archive deployment descriptor
+            .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
+    }
+
+    @Test
+    @OperateOnDeployment("multiple-locations")
+    public void resolvePropertyFromLocations(CamelContext context) throws Exception {
+        assertThat("Property from classpath locations does not resolve!", context.resolvePropertyPlaceholders("{{foo.property}}"), is(equalTo("foo.value")));
+        assertThat("Property from classpath locations does not resolve!", context.resolvePropertyPlaceholders("{{bar.property}}"), is(equalTo("bar.value")));
+    }
+}


Mime
View raw message