You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by da...@apache.org on 2019/06/06 10:59:21 UTC
[camel] branch master updated (6f7b143 -> c1c47a0)
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git.
from 6f7b143 CAMEL-12868: Detect if camel on spring-boot shutdown very quickly because there is no main controller or starter-web dependency to keep the JVM alive.
new fa07d9f CAMEL-13491: Fixed camel-test with isCreateCamelContextPerClass = true to correctly setup/teardown only once before/after class and reset in between test methods. This is a little bit tricky to do with JUnit 4
new c1c47a0 CAMEL-13491: Fixed CS. And some smaller improvements between camel-test and camel-test-spring
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../camel/test/spring/CamelSpringTestSupport.java | 15 +--
.../apache/camel/test/patterns/SimpleMockTest.java | 29 +++-
.../camel/test/junit4/CamelTearDownRule.java} | 41 +++---
.../apache/camel/test/junit4/CamelTestSupport.java | 88 ++++++------
.../org/apache/camel/test/junit4/TestSupport.java | 5 +-
...ava => CreateCamelContextPerTestFalseTest.java} | 61 +++++++--
.../CreateCamelContextPerTestTrueTest.java | 148 +++++++++++++++++++++
7 files changed, 294 insertions(+), 93 deletions(-)
copy components/{camel-cassandraql/src/test/java/org/apache/camel/component/cassandra/BaseCassandraTest.java => camel-test/src/main/java/org/apache/camel/test/junit4/CamelTearDownRule.java} (54%)
copy components/camel-test/src/test/java/org/apache/camel/test/patterns/{FilterTest.java => CreateCamelContextPerTestFalseTest.java} (54%)
create mode 100644 components/camel-test/src/test/java/org/apache/camel/test/patterns/CreateCamelContextPerTestTrueTest.java
[camel] 01/02: CAMEL-13491: Fixed camel-test with
isCreateCamelContextPerClass = true to correctly setup/teardown only once
before/after class and reset in between test methods. This is a little bit
tricky to do with JUnit 4
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit fa07d9f45cd422190234f6d5b273aad356861801
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Thu Jun 6 08:34:40 2019 +0200
CAMEL-13491: Fixed camel-test with isCreateCamelContextPerClass = true to correctly setup/teardown only once before/after class and reset in between test methods. This is a little bit tricky to do with JUnit 4
---
.../camel/test/junit4/CamelTearDownRule.java | 46 +++++++
.../apache/camel/test/junit4/CamelTestSupport.java | 74 +++++------
.../org/apache/camel/test/junit4/TestSupport.java | 5 +-
.../CreateCamelContextPerTestFalseTest.java | 116 ++++++++++++++++
.../CreateCamelContextPerTestTrueTest.java | 148 +++++++++++++++++++++
5 files changed, 349 insertions(+), 40 deletions(-)
diff --git a/components/camel-test/src/main/java/org/apache/camel/test/junit4/CamelTearDownRule.java b/components/camel-test/src/main/java/org/apache/camel/test/junit4/CamelTearDownRule.java
new file mode 100644
index 0000000..23c89b8
--- /dev/null
+++ b/components/camel-test/src/main/java/org/apache/camel/test/junit4/CamelTearDownRule.java
@@ -0,0 +1,46 @@
+/**
+ * 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
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * 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.test.junit4;
+
+import org.junit.rules.ExternalResource;
+
+public class CamelTearDownRule extends ExternalResource {
+
+ private final ThreadLocal<CamelTestSupport> testSupport;
+
+ public CamelTearDownRule(ThreadLocal<CamelTestSupport> testSupport) {
+ this.testSupport = testSupport;
+ }
+
+ @Override
+ protected void before() throws Throwable {
+ super.before();
+ }
+
+ @Override
+ protected void after() {
+ CamelTestSupport support = testSupport.get();
+ if (support != null && support.isCreateCamelContextPerClass()) {
+ try {
+ support.tearDownCreateCamelContextPerClass();
+ } catch (Throwable e) {
+ // ignore
+ }
+ }
+ super.after();
+ }
+}
diff --git a/components/camel-test/src/main/java/org/apache/camel/test/junit4/CamelTestSupport.java b/components/camel-test/src/main/java/org/apache/camel/test/junit4/CamelTestSupport.java
index 02c167b..ce1ca20 100644
--- a/components/camel-test/src/main/java/org/apache/camel/test/junit4/CamelTestSupport.java
+++ b/components/camel-test/src/main/java/org/apache/camel/test/junit4/CamelTestSupport.java
@@ -88,6 +88,7 @@ import org.apache.camel.util.StopWatch;
import org.apache.camel.util.TimeUtils;
import org.junit.After;
import org.junit.Before;
+import org.junit.ClassRule;
import org.junit.Rule;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -120,8 +121,11 @@ public abstract class CamelTestSupport extends TestSupport {
private final DebugBreakpoint breakpoint = new DebugBreakpoint();
private final StopWatch watch = new StopWatch();
private final Map<String, String> fromEndpoints = new HashMap<>();
- private final AtomicInteger tests = new AtomicInteger(0);
+ private static final ThreadLocal<AtomicInteger> TESTS = new ThreadLocal<>();
+ private static final ThreadLocal<CamelTestSupport> INSTANCE = new ThreadLocal<>();
private CamelTestWatcher camelTestWatcher = new CamelTestWatcher();
+ @ClassRule
+ public static final CamelTearDownRule CAMEL_TEAR_DOWN_RULE = new CamelTearDownRule(INSTANCE);
/**
* Use the RouteBuilder or not
@@ -298,24 +302,25 @@ public abstract class CamelTestSupport extends TestSupport {
log.info("********************************************************************************");
if (isCreateCamelContextPerClass()) {
- while (true) {
- int v = tests.get();
- if (tests.compareAndSet(v, v + 1)) {
- if (v == 0) {
- // test is per class, so only setup once (the first time)
- doSpringBootCheck();
- setupResources();
- doPreSetup();
- doSetUp();
- doPostSetup();
- } else {
- // and in between tests we must do IoC and reset mocks
- postProcessTest();
- resetMocks();
- }
-
- break;
- }
+ INSTANCE.set(this);
+ AtomicInteger v = TESTS.get();
+ if (v == null) {
+ v = new AtomicInteger();
+ TESTS.set(v);
+ }
+ if (v.getAndIncrement() == 0) {
+ LOG.debug("Setup CamelContext before running first test");
+ // test is per class, so only setup once (the first time)
+ doSpringBootCheck();
+ setupResources();
+ doPreSetup();
+ doSetUp();
+ doPostSetup();
+ } else {
+ LOG.debug("Reset between test methods");
+ // and in between tests we must do IoC and reset mocks
+ postProcessTest();
+ resetMocks();
}
} else {
// test is per test so always setup
@@ -510,27 +515,9 @@ public abstract class CamelTestSupport extends TestSupport {
log.info("********************************************************************************");
if (isCreateCamelContextPerClass()) {
- while (true) {
- int v = tests.get();
- if (v <= 0) {
- LOG.warn("Test already teared down");
- break;
- }
-
- if (tests.compareAndSet(v, v - 1)) {
- if (v == 1) {
- LOG.debug("tearDown test");
- doStopTemplates(threadConsumer.get(), threadTemplate.get(), threadFluentTemplate.get());
- doStopCamelContext(threadCamelContext.get(), threadService.get());
- doPostTearDown();
- cleanupResources();
- }
-
- break;
- }
- }
+ // will tear down test specially in CamelTearDownRule
} else {
- LOG.debug("tearDown test");
+ LOG.debug("tearDown()");
doStopTemplates(consumer, template, fluentTemplate);
doStopCamelContext(context, camelContextService);
doPostTearDown();
@@ -538,6 +525,15 @@ public abstract class CamelTestSupport extends TestSupport {
}
}
+ void tearDownCreateCamelContextPerClass() throws Exception {
+ LOG.debug("tearDownCreateCamelContextPerClass()");
+ TESTS.remove();
+ doStopTemplates(threadConsumer.get(), threadTemplate.get(), threadFluentTemplate.get());
+ doStopCamelContext(threadCamelContext.get(), threadService.get());
+ doPostTearDown();
+ cleanupResources();
+ }
+
/**
* Strategy to perform any post action, after {@link CamelContext} is stopped
*/
diff --git a/components/camel-test/src/main/java/org/apache/camel/test/junit4/TestSupport.java b/components/camel-test/src/main/java/org/apache/camel/test/junit4/TestSupport.java
index ddf10e1..3f47d96 100644
--- a/components/camel-test/src/main/java/org/apache/camel/test/junit4/TestSupport.java
+++ b/components/camel-test/src/main/java/org/apache/camel/test/junit4/TestSupport.java
@@ -20,6 +20,7 @@ import java.io.File;
import java.util.Collection;
import java.util.List;
import java.util.Locale;
+import java.util.concurrent.atomic.AtomicInteger;
import org.apache.camel.CamelContext;
import org.apache.camel.Endpoint;
@@ -38,6 +39,8 @@ import org.apache.camel.support.PredicateAssertHelper;
import org.junit.Assert;
import org.junit.Rule;
import org.junit.rules.TestName;
+import org.junit.rules.TestWatcher;
+import org.junit.runner.Description;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -49,8 +52,8 @@ public abstract class TestSupport extends Assert {
protected static final String LS = System.lineSeparator();
private static final Logger LOG = LoggerFactory.getLogger(TestSupport.class);
protected Logger log = LoggerFactory.getLogger(getClass());
-
private TestName testName = new TestName();
+ private CamelTestWatcher camelTestWatcher = new CamelTestWatcher();
// Builder methods for expressions used when testing
// -------------------------------------------------------------------------
diff --git a/components/camel-test/src/test/java/org/apache/camel/test/patterns/CreateCamelContextPerTestFalseTest.java b/components/camel-test/src/test/java/org/apache/camel/test/patterns/CreateCamelContextPerTestFalseTest.java
new file mode 100644
index 0000000..059d88b
--- /dev/null
+++ b/components/camel-test/src/test/java/org/apache/camel/test/patterns/CreateCamelContextPerTestFalseTest.java
@@ -0,0 +1,116 @@
+/*
+ * 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.test.patterns;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.EndpointInject;
+import org.apache.camel.Produce;
+import org.apache.camel.ProducerTemplate;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.component.mock.MockEndpoint;
+import org.apache.camel.test.junit4.CamelTestSupport;
+import org.junit.AfterClass;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class CreateCamelContextPerTestFalseTest extends CamelTestSupport {
+
+ private static final Logger LOG = LoggerFactory.getLogger(CreateCamelContextPerTestFalseTest.class);
+
+ private static final AtomicInteger CREATED_CONTEXTS = new AtomicInteger();
+ private static final AtomicInteger POST_TEAR_DOWN = new AtomicInteger();
+
+ @EndpointInject("mock:result")
+ protected MockEndpoint resultEndpoint;
+
+ @Produce("direct:start")
+ protected ProducerTemplate template;
+
+ @Override
+ public boolean isCreateCamelContextPerClass() {
+ return false;
+ }
+
+ @Override
+ protected CamelContext createCamelContext() throws Exception {
+ LOG.info("createCamelContext()");
+ CREATED_CONTEXTS.incrementAndGet();
+ return super.createCamelContext();
+ }
+
+ @Override
+ protected void doPostTearDown() throws Exception {
+ LOG.info("doPostTearDown()");
+ POST_TEAR_DOWN.incrementAndGet();
+ super.doPostTearDown();
+ }
+
+ @Test
+ public void testSendMatchingMessage() throws Exception {
+ String expectedBody = "<matched/>";
+
+ resultEndpoint.expectedBodiesReceived(expectedBody);
+
+ template.sendBodyAndHeader(expectedBody, "foo", "bar");
+
+ resultEndpoint.assertIsSatisfied();
+
+ assertTrue("Should create 1 or more CamelContext per test class", CREATED_CONTEXTS.get() >= 1);
+ }
+
+ @Test
+ public void testSendAnotherMatchingMessage() throws Exception {
+ String expectedBody = "<matched/>";
+
+ resultEndpoint.expectedBodiesReceived(expectedBody);
+
+ template.sendBodyAndHeader(expectedBody, "foo", "bar");
+
+ resultEndpoint.assertIsSatisfied();
+
+ assertTrue("Should create 1 or more CamelContext per test class", CREATED_CONTEXTS.get() >= 1);
+ }
+
+ @Test
+ public void testSendNotMatchingMessage() throws Exception {
+ resultEndpoint.expectedMessageCount(0);
+
+ template.sendBodyAndHeader("<notMatched/>", "foo", "notMatchedHeaderValue");
+
+ resultEndpoint.assertIsSatisfied();
+
+ assertTrue("Should create 1 or more CamelContext per test class", CREATED_CONTEXTS.get() >= 1);
+ }
+
+ @AfterClass
+ public static void validateTearDown() throws Exception {
+ assertEquals(3, CREATED_CONTEXTS.get());
+ assertEquals(3, POST_TEAR_DOWN.get());
+ }
+
+ @Override
+ protected RouteBuilder createRouteBuilder() {
+ return new RouteBuilder() {
+ public void configure() {
+ from("direct:start").filter(header("foo").isEqualTo("bar")).to("mock:result");
+ }
+ };
+ }
+}
diff --git a/components/camel-test/src/test/java/org/apache/camel/test/patterns/CreateCamelContextPerTestTrueTest.java b/components/camel-test/src/test/java/org/apache/camel/test/patterns/CreateCamelContextPerTestTrueTest.java
new file mode 100644
index 0000000..dd1e9db
--- /dev/null
+++ b/components/camel-test/src/test/java/org/apache/camel/test/patterns/CreateCamelContextPerTestTrueTest.java
@@ -0,0 +1,148 @@
+/*
+ * 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.test.patterns;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.EndpointInject;
+import org.apache.camel.Produce;
+import org.apache.camel.ProducerTemplate;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.component.mock.MockEndpoint;
+import org.apache.camel.test.junit4.CamelTestSupport;
+import org.apache.camel.util.StopWatch;
+import org.junit.AfterClass;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class CreateCamelContextPerTestTrueTest extends CamelTestSupport {
+
+ private static final Logger LOG = LoggerFactory.getLogger(CreateCamelContextPerTestTrueTest.class);
+
+ private static final AtomicInteger CREATED_CONTEXTS = new AtomicInteger();
+ private static final AtomicInteger POST_TEAR_DOWN = new AtomicInteger();
+ private static final CountDownLatch LATCH = new CountDownLatch(1);
+
+ @EndpointInject("mock:result")
+ protected MockEndpoint resultEndpoint;
+
+ @Produce("direct:start")
+ protected ProducerTemplate template;
+
+ @Override
+ public boolean isCreateCamelContextPerClass() {
+ return true;
+ }
+
+ @Override
+ protected CamelContext createCamelContext() throws Exception {
+ LOG.info("createCamelContext()");
+ CREATED_CONTEXTS.incrementAndGet();
+ return super.createCamelContext();
+ }
+
+ @Override
+ protected void doPostTearDown() throws Exception {
+ LOG.info("doPostTearDown()");
+ POST_TEAR_DOWN.incrementAndGet();
+ super.doPostTearDown();
+ LATCH.await(5, TimeUnit.SECONDS);
+ }
+
+ @Test
+ public void testSendMatchingMessage() throws Exception {
+ String expectedBody = "<matched/>";
+
+ resultEndpoint.expectedBodiesReceived(expectedBody);
+
+ template.sendBodyAndHeader(expectedBody, "foo", "bar");
+
+ resultEndpoint.assertIsSatisfied();
+
+ assertEquals("Should only create 1 CamelContext per test class", 1, CREATED_CONTEXTS.get());
+ assertEquals("Should not call postTearDown yet", 0, POST_TEAR_DOWN.get());
+ }
+
+ @Test
+ public void testSendAnotherMatchingMessage() throws Exception {
+ String expectedBody = "<matched/>";
+
+ resultEndpoint.expectedBodiesReceived(expectedBody);
+
+ template.sendBodyAndHeader(expectedBody, "foo", "bar");
+
+ resultEndpoint.assertIsSatisfied();
+
+ assertEquals("Should only create 1 CamelContext per test class", 1, CREATED_CONTEXTS.get());
+ assertEquals("Should not call postTearDown yet", 0, POST_TEAR_DOWN.get());
+ }
+
+ @Test
+ public void testSendNotMatchingMessage() throws Exception {
+ resultEndpoint.expectedMessageCount(0);
+
+ template.sendBodyAndHeader("<notMatched/>", "foo", "notMatchedHeaderValue");
+
+ resultEndpoint.assertIsSatisfied();
+
+ assertEquals("Should only create 1 CamelContext per test class", 1, CREATED_CONTEXTS.get());
+ assertEquals("Should not call postTearDown yet", 0, POST_TEAR_DOWN.get());
+ }
+
+ @AfterClass
+ public static void shouldTearDown() throws Exception {
+ // we are called before doPostTearDown so lets wait for that to be called
+ Runnable r = () -> {
+ try {
+ StopWatch watch = new StopWatch();
+ while (watch.taken() < 5000) {
+ LOG.debug("Checking for tear down called correctly");
+ if (POST_TEAR_DOWN.get() == 1) {
+ LATCH.countDown();
+ break;
+ } else {
+ try {
+ Thread.sleep(100);
+ } catch (InterruptedException e) {
+ break;
+ }
+ }
+ }
+ } finally {
+ LOG.info("Should only call postTearDown 1 time per test class, called: " + POST_TEAR_DOWN.get());
+ assertEquals("Should only call postTearDown 1 time per test class", 1, POST_TEAR_DOWN.get());
+ }
+ };
+ Thread t = new Thread(r);
+ t.setDaemon(false);
+ t.setName("shouldTearDown checker");
+ t.start();
+ }
+
+ @Override
+ protected RouteBuilder createRouteBuilder() {
+ return new RouteBuilder() {
+ public void configure() {
+ from("direct:start").filter(header("foo").isEqualTo("bar")).to("mock:result");
+ }
+ };
+ }
+}
[camel] 02/02: CAMEL-13491: Fixed CS. And some smaller improvements
between camel-test and camel-test-spring
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit c1c47a02c0cb0ac49ac65aed87fa3339b2b68ecc
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Thu Jun 6 10:13:51 2019 +0200
CAMEL-13491: Fixed CS. And some smaller improvements between camel-test and camel-test-spring
---
.../camel/test/spring/CamelSpringTestSupport.java | 15 ++---------
.../apache/camel/test/patterns/SimpleMockTest.java | 29 +++++++++++++++++++---
.../camel/test/junit4/CamelTearDownRule.java | 11 +++++---
.../apache/camel/test/junit4/CamelTestSupport.java | 14 +++++------
4 files changed, 42 insertions(+), 27 deletions(-)
diff --git a/components/camel-test-spring/src/main/java/org/apache/camel/test/spring/CamelSpringTestSupport.java b/components/camel-test-spring/src/main/java/org/apache/camel/test/spring/CamelSpringTestSupport.java
index 0b2914f..4e8ff41 100644
--- a/components/camel-test-spring/src/main/java/org/apache/camel/test/spring/CamelSpringTestSupport.java
+++ b/components/camel-test-spring/src/main/java/org/apache/camel/test/spring/CamelSpringTestSupport.java
@@ -21,7 +21,7 @@ import java.util.HashSet;
import java.util.List;
import org.apache.camel.CamelContext;
-import org.apache.camel.spring.CamelBeanPostProcessor;
+import org.apache.camel.ExtendedCamelContext;
import org.apache.camel.spring.SpringCamelContext;
import org.apache.camel.test.ExcludingPackageScanClassResolver;
import org.apache.camel.test.junit4.CamelTestSupport;
@@ -44,23 +44,12 @@ public abstract class CamelSpringTestSupport extends CamelTestSupport {
protected AbstractApplicationContext applicationContext;
protected abstract AbstractApplicationContext createApplicationContext();
- /**
- * Lets post process this test instance to process any Camel annotations.
- * Note that using Spring Test or Guice is a more powerful approach.
- */
@Override
public void postProcessTest() throws Exception {
- super.postProcessTest();
if (isCreateCamelContextPerClass()) {
applicationContext = threadAppContext.get();
}
-
- // use the bean post processor from camel-spring
- CamelBeanPostProcessor processor = new CamelBeanPostProcessor();
- processor.setApplicationContext(applicationContext);
- processor.setCamelContext(context);
- processor.postProcessBeforeInitialization(this, getClass().getName());
- processor.postProcessAfterInitialization(this, getClass().getName());
+ super.postProcessTest();
}
@Override
diff --git a/components/camel-test-spring/src/test/java/org/apache/camel/test/patterns/SimpleMockTest.java b/components/camel-test-spring/src/test/java/org/apache/camel/test/patterns/SimpleMockTest.java
index 27bf096..c257e68 100644
--- a/components/camel-test-spring/src/test/java/org/apache/camel/test/patterns/SimpleMockTest.java
+++ b/components/camel-test-spring/src/test/java/org/apache/camel/test/patterns/SimpleMockTest.java
@@ -16,6 +16,10 @@
*/
package org.apache.camel.test.patterns;
+import org.apache.camel.EndpointInject;
+import org.apache.camel.Produce;
+import org.apache.camel.ProducerTemplate;
+import org.apache.camel.component.mock.MockEndpoint;
import org.apache.camel.test.spring.CamelSpringTestSupport;
import org.junit.Test;
import org.springframework.context.support.AbstractApplicationContext;
@@ -23,6 +27,12 @@ import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SimpleMockTest extends CamelSpringTestSupport {
+ @EndpointInject("mock:result")
+ protected MockEndpoint resultEndpoint;
+
+ @Produce("direct:start")
+ protected ProducerTemplate template;
+
@Override
protected AbstractApplicationContext createApplicationContext() {
return new ClassPathXmlApplicationContext("org/apache/camel/test/patterns/SimpleMockTest.xml");
@@ -30,11 +40,24 @@ public class SimpleMockTest extends CamelSpringTestSupport {
@Test
public void testMock() throws Exception {
- getMockEndpoint("mock:result").expectedBodiesReceived("Hello World");
+ String expectedBody = "Hello World";
+
+ resultEndpoint.expectedBodiesReceived(expectedBody);
+
+ template.sendBodyAndHeader(expectedBody, "foo", "bar");
+
+ resultEndpoint.assertIsSatisfied();
+ }
+
+ @Test
+ public void testMockAgain() throws Exception {
+ String expectedBody = "Bye World";
+
+ resultEndpoint.expectedBodiesReceived(expectedBody);
- template.sendBody("direct:start", "Hello World");
+ template.sendBodyAndHeader(expectedBody, "foo", "bar");
- assertMockEndpointsSatisfied();
+ resultEndpoint.assertIsSatisfied();
}
}
diff --git a/components/camel-test/src/main/java/org/apache/camel/test/junit4/CamelTearDownRule.java b/components/camel-test/src/main/java/org/apache/camel/test/junit4/CamelTearDownRule.java
index 23c89b8..2d2dd1f 100644
--- a/components/camel-test/src/main/java/org/apache/camel/test/junit4/CamelTearDownRule.java
+++ b/components/camel-test/src/main/java/org/apache/camel/test/junit4/CamelTearDownRule.java
@@ -1,13 +1,13 @@
-/**
+/*
* 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
- * <p>
- * http://www.apache.org/licenses/LICENSE-2.0
- * <p>
+ *
+ * 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.
@@ -18,6 +18,9 @@ package org.apache.camel.test.junit4;
import org.junit.rules.ExternalResource;
+/**
+ * A JUnit rule to tear down Camel when using createCamelContextPerClass=true.
+ */
public class CamelTearDownRule extends ExternalResource {
private final ThreadLocal<CamelTestSupport> testSupport;
diff --git a/components/camel-test/src/main/java/org/apache/camel/test/junit4/CamelTestSupport.java b/components/camel-test/src/main/java/org/apache/camel/test/junit4/CamelTestSupport.java
index ce1ca20..1b5fb54 100644
--- a/components/camel-test/src/main/java/org/apache/camel/test/junit4/CamelTestSupport.java
+++ b/components/camel-test/src/main/java/org/apache/camel/test/junit4/CamelTestSupport.java
@@ -72,7 +72,6 @@ import org.apache.camel.component.mock.MockEndpoint;
import org.apache.camel.component.properties.PropertiesComponent;
import org.apache.camel.impl.DefaultCamelContext;
import org.apache.camel.impl.JndiRegistry;
-import org.apache.camel.impl.engine.DefaultCamelBeanPostProcessor;
import org.apache.camel.impl.engine.InterceptSendToMockEndpointStrategy;
import org.apache.camel.model.Model;
import org.apache.camel.model.ModelCamelContext;
@@ -80,6 +79,7 @@ import org.apache.camel.model.ProcessorDefinition;
import org.apache.camel.processor.interceptor.BreakpointSupport;
import org.apache.camel.processor.interceptor.DefaultDebugger;
import org.apache.camel.reifier.RouteReifier;
+import org.apache.camel.spi.CamelBeanPostProcessor;
import org.apache.camel.spi.Language;
import org.apache.camel.spi.Registry;
import org.apache.camel.support.EndpointHelper;
@@ -105,6 +105,7 @@ public abstract class CamelTestSupport extends TestSupport {
*/
public static final String ROUTE_COVERAGE_ENABLED = "CamelTestRouteCoverage";
+ // CHECKSTYLE:OFF
private static final Logger LOG = LoggerFactory.getLogger(CamelTestSupport.class);
private static ThreadLocal<ModelCamelContext> threadCamelContext = new ThreadLocal<>();
private static ThreadLocal<ProducerTemplate> threadTemplate = new ThreadLocal<>();
@@ -116,7 +117,6 @@ public abstract class CamelTestSupport extends TestSupport {
protected volatile FluentProducerTemplate fluentTemplate;
protected volatile ConsumerTemplate consumer;
protected volatile Service camelContextService;
- protected boolean dumpRouteStats;
private boolean useRouteBuilder = true;
private final DebugBreakpoint breakpoint = new DebugBreakpoint();
private final StopWatch watch = new StopWatch();
@@ -126,6 +126,7 @@ public abstract class CamelTestSupport extends TestSupport {
private CamelTestWatcher camelTestWatcher = new CamelTestWatcher();
@ClassRule
public static final CamelTearDownRule CAMEL_TEAR_DOWN_RULE = new CamelTearDownRule(INSTANCE);
+ // CHECKSTYLE:ON
/**
* Use the RouteBuilder or not
@@ -732,18 +733,17 @@ public abstract class CamelTestSupport extends TestSupport {
}
/**
- * Applies the {@link DefaultCamelBeanPostProcessor} to this instance.
+ * Applies the {@link CamelBeanPostProcessor} to this instance.
*
* Derived classes using IoC / DI frameworks may wish to turn this into a NoOp such as for CDI
* we would just use CDI to inject this
*/
protected void applyCamelPostProcessor() throws Exception {
- // use the default bean post processor from camel-core if the test class is not dependency injected already by Spring
+ // use the bean post processor if the test class is not dependency injected already by Spring Framework
boolean spring = hasClassAnnotation("org.springframework.boot.test.context.SpringBootTest", "org.springframework.context.annotation.ComponentScan");
if (!spring) {
- DefaultCamelBeanPostProcessor processor = new DefaultCamelBeanPostProcessor(context);
- processor.postProcessBeforeInitialization(this, getClass().getName());
- processor.postProcessAfterInitialization(this, getClass().getName());
+ context.getExtension(ExtendedCamelContext.class).getBeanPostProcessor().postProcessBeforeInitialization(this, getClass().getName());
+ context.getExtension(ExtendedCamelContext.class).getBeanPostProcessor().postProcessAfterInitialization(this, getClass().getName());
}
}