diff --git a/docs/modules/ROOT/pages/user-guide/testing.adoc b/docs/modules/ROOT/pages/user-guide/testing.adoc index 24688eb851c6..1bc790083a3e 100644 --- a/docs/modules/ROOT/pages/user-guide/testing.adoc +++ b/docs/modules/ROOT/pages/user-guide/testing.adoc @@ -226,3 +226,40 @@ class MyTest { ---- More examples of WireMock usage can be found in the Camel Quarkus integration test source tree such as https://github.com/apache/camel-quarkus/tree/main/integration-tests/geocoder[Geocoder]. + +== `CamelTestSupport` style of testing + +If you used plain Camel before, you may know https://camel.apache.org/components/latest/others/test-junit5.html[CamelTestSupport] already. +Unfortunately the Camel variant won't work on Quarkus and so we prepared a replacement called `CamelQuarkusTestSupport`, which can be used in JVM mode. + +To leverage `CamelQuarkusTestSupport`, please add following dependency into your module (preferably in the `test` scope) + +``` + + org.apache.camel.quarkus + camel-quarkus-junit5 + test + +``` + +There are several limitations: + +* The test class has to be annotated with `@io.quarkus.test.junit.QuarkusTest` and has to extend `org.apache.camel.quarkus.test.CamelQuarkusTestSupport`. +* Camel Quarkus does not support stopping and re-starting the same `CamelContext` instance within the life cycle of a single application. You will be able to call `CamelContext.stop()`, but `CamelContext.start()` won't work. +* Starting and stopping `CamelContext` in Camel Quarkus is generally bound to starting and stopping the application and this holds also when testing. +* Starting and stopping the application under test (and thus also `CamelContext`) is under full control of Quarkus JUnit Extension. It prefers keeping the application up and running unless it is told to do otherwise. +* Hence normally the application under test is started only once for all test classes of the given Maven/Gradle module. +* To force Quarkus JUnit Extension to restart the application (and thus also `CamelContext`) for a given test class, you need to assign a unique `@io.quarkus.test.junit.TestProfile` to that class. Check the https://quarkus.io/guides/getting-started-testing#testing_different_profiles[Quarkus documentation] how you can do that. (Note that `https://quarkus.io/guides/getting-started-testing#quarkus-test-resource[@io.quarkus.test.common.QuarkusTestResource]` has a similar effect.) +* Camel Quarkus executes the production of beans during the build phase. Because all the tests are +build together, exclusion behavior is implemented into `CamelQuarkusTestSupport`. If a producer of the specific type and name is used in one tests, the instance will be the same for the rest of the tests. +* JUnit Jupiter callbacks (`BeforeEachCallback`, `AfterEachCallback`, `AfterAllCallback`, `BeforeAllCallback`, `BeforeTestExecutionCallback` and `AfterTestExecutionCallback`) might not work correctly. See the https://quarkus.io/guides/getting-started-testing#enrichment-via-quarkustestcallback[documentation]. + +[source,java] +---- +@QuarkusTest +@TestProfile(SimpleTest.class) //necessary only if "newly created" context is required for the test (worse performance) +public class SimpleTest extends CamelQuarkusTestSupport { + ... +} +---- + diff --git a/extensions-core/core/deployment/src/main/java/org/apache/camel/quarkus/core/deployment/InjectionPointsProcessor.java b/extensions-core/core/deployment/src/main/java/org/apache/camel/quarkus/core/deployment/InjectionPointsProcessor.java index e8ced1788acf..2e15c9c8e171 100644 --- a/extensions-core/core/deployment/src/main/java/org/apache/camel/quarkus/core/deployment/InjectionPointsProcessor.java +++ b/extensions-core/core/deployment/src/main/java/org/apache/camel/quarkus/core/deployment/InjectionPointsProcessor.java @@ -78,6 +78,8 @@ public class InjectionPointsProcessor { .createSimple(EndpointInject.class.getName()); private static final DotName PRODUCE_ANNOTATION = DotName .createSimple(Produce.class.getName()); + private static final DotName TEST_SUPPORT_CLASS_NAME = DotName + .createSimple("org.apache.camel.quarkus.test.CamelQuarkusTestSupport"); private static SyntheticBeanBuildItem syntheticBean(DotName name, Supplier creator) { return SyntheticBeanBuildItem.configure(name) @@ -226,12 +228,16 @@ void syntheticBeans( BuildProducer syntheticBeans, BuildProducer proxyDefinitions) { + Set alreadyCreated = new HashSet<>(); + for (AnnotationInstance annot : index.getIndex().getAnnotations(ENDPOINT_INJECT_ANNOTATION)) { final AnnotationTarget target = annot.target(); switch (target.kind()) { case FIELD: { final FieldInfo field = target.asField(); - endpointInjectBeans(recorder, syntheticBeans, index.getIndex(), annot, field.type().name()); + if (!excludeTestSyntheticBeanDuplicities(annot, alreadyCreated, field.declaringClass(), index.getIndex())) { + endpointInjectBeans(recorder, syntheticBeans, index.getIndex(), annot, field.type().name()); + } break; } case METHOD: { @@ -251,8 +257,10 @@ void syntheticBeans( switch (target.kind()) { case FIELD: { final FieldInfo field = target.asField(); - produceBeans(recorder, capabilities, syntheticBeans, proxyDefinitions, beanCapabilityAvailable, - index.getIndex(), annot, field.type().name(), field.name(), field.declaringClass().name()); + if (!excludeTestSyntheticBeanDuplicities(annot, alreadyCreated, field.declaringClass(), index.getIndex())) { + produceBeans(recorder, capabilities, syntheticBeans, proxyDefinitions, beanCapabilityAvailable, + index.getIndex(), annot, field.type().name(), field.name(), field.declaringClass().name()); + } break; } case METHOD: { @@ -266,6 +274,45 @@ void syntheticBeans( } } + private boolean excludeTestSyntheticBeanDuplicities(AnnotationInstance annot, Set alreadyCreated, + ClassInfo declaringClass, IndexView index) { + String identifier = annot.toString(false) + ":" + getTargetClass(annot).toString(); + + if (extendsCamelQuarkusTest(declaringClass, index)) { + if (alreadyCreated.contains(identifier)) { + return true; + } else { + alreadyCreated.add(identifier); + } + } + return false; + } + + private DotName getTargetClass(AnnotationInstance annot) { + switch (annot.target().kind()) { + case FIELD: + return annot.target().asField().type().name(); + case METHOD: + return annot.target().asMethod().returnType().name(); + default: + return null; + } + } + + private boolean extendsCamelQuarkusTest(ClassInfo declaringClass, IndexView indexView) { + if (declaringClass == null) { + return false; + } + + if (TEST_SUPPORT_CLASS_NAME.equals(declaringClass.name())) { + return true; + } + + //iterate over parent until found CamelQuarkusTest or null + return (declaringClass.superName() != null && + extendsCamelQuarkusTest(indexView.getClassByName(declaringClass.superName()), indexView)); + } + void produceBeans(CamelRecorder recorder, List capabilities, BuildProducer syntheticBeans, BuildProducer proxyDefinitions, diff --git a/extensions-core/core/runtime/src/main/java/org/apache/camel/quarkus/core/FastCamelContext.java b/extensions-core/core/runtime/src/main/java/org/apache/camel/quarkus/core/FastCamelContext.java index 95c525491986..be0bca1bfa0a 100644 --- a/extensions-core/core/runtime/src/main/java/org/apache/camel/quarkus/core/FastCamelContext.java +++ b/extensions-core/core/runtime/src/main/java/org/apache/camel/quarkus/core/FastCamelContext.java @@ -81,7 +81,9 @@ public String getVersion() { @Override protected Registry createRegistry() { // Registry creation is done at build time - throw new UnsupportedOperationException(); + throw new UnsupportedOperationException("In case that the test based on CamelQuarkusTestSupport throws this exception, " + + "be aware that re-starting of context is not possible. " + + "(See https://camel.apache.org/camel-quarkus/2.10.x/user-guide/testing.html)"); } @Override diff --git a/pom.xml b/pom.xml index 3685ae1c95c7..59e29cda3ca5 100644 --- a/pom.xml +++ b/pom.xml @@ -223,6 +223,7 @@ integration-test-groups docs integration-tests-jvm + test-framework @@ -588,6 +589,10 @@ integration-tests-support camel-quarkus-integration-test-support- + + test-framework + camel-quarkus-test-framework + diff --git a/poms/bom/pom.xml b/poms/bom/pom.xml index 496c2e58e3d4..99c01082a2b4 100644 --- a/poms/bom/pom.xml +++ b/poms/bom/pom.xml @@ -1647,6 +1647,11 @@ + + org.apache.camel + camel-dataset + ${camel.version} + org.apache.camel camel-datasonnet @@ -1840,6 +1845,11 @@ + + org.apache.camel + camel-directvm + ${camel.version} + org.apache.camel camel-disruptor @@ -5312,6 +5322,11 @@ + + org.apache.camel + camel-test-junit5 + ${camel.version} + org.apache.camel camel-threadpoolfactory-vertx @@ -7625,6 +7640,11 @@ camel-quarkus-jta-deployment ${camel-quarkus.version} + + org.apache.camel.quarkus + camel-quarkus-junit5 + ${camel-quarkus.version} + org.apache.camel.quarkus camel-quarkus-kafka diff --git a/poms/bom/src/main/generated/flattened-full-pom.xml b/poms/bom/src/main/generated/flattened-full-pom.xml index eed860c7a3f5..138f55262834 100644 --- a/poms/bom/src/main/generated/flattened-full-pom.xml +++ b/poms/bom/src/main/generated/flattened-full-pom.xml @@ -1593,6 +1593,11 @@ + + org.apache.camel + camel-dataset + 3.18.0 + org.apache.camel camel-datasonnet @@ -1786,6 +1791,11 @@ + + org.apache.camel + camel-directvm + 3.18.0 + org.apache.camel camel-disruptor @@ -5258,6 +5268,11 @@ + + org.apache.camel + camel-test-junit5 + 3.18.0 + org.apache.camel camel-threadpoolfactory-vertx @@ -7569,6 +7584,11 @@ camel-quarkus-jta-deployment 2.11.0-SNAPSHOT + + org.apache.camel.quarkus + camel-quarkus-junit5 + 2.11.0-SNAPSHOT + org.apache.camel.quarkus camel-quarkus-kafka diff --git a/poms/bom/src/main/generated/flattened-reduced-pom.xml b/poms/bom/src/main/generated/flattened-reduced-pom.xml index fdfcd3c24ab9..59ab3316e1dd 100644 --- a/poms/bom/src/main/generated/flattened-reduced-pom.xml +++ b/poms/bom/src/main/generated/flattened-reduced-pom.xml @@ -1593,6 +1593,11 @@ + + org.apache.camel + camel-dataset + 3.18.0 + org.apache.camel camel-datasonnet @@ -1786,6 +1791,11 @@ + + org.apache.camel + camel-directvm + 3.18.0 + org.apache.camel camel-disruptor @@ -5258,6 +5268,11 @@ + + org.apache.camel + camel-test-junit5 + 3.18.0 + org.apache.camel camel-threadpoolfactory-vertx @@ -7569,6 +7584,11 @@ camel-quarkus-jta-deployment 2.11.0-SNAPSHOT + + org.apache.camel.quarkus + camel-quarkus-junit5 + 2.11.0-SNAPSHOT + org.apache.camel.quarkus camel-quarkus-kafka diff --git a/poms/bom/src/main/generated/flattened-reduced-verbose-pom.xml b/poms/bom/src/main/generated/flattened-reduced-verbose-pom.xml index e3f8e63aad10..71f437508f82 100644 --- a/poms/bom/src/main/generated/flattened-reduced-verbose-pom.xml +++ b/poms/bom/src/main/generated/flattened-reduced-verbose-pom.xml @@ -1593,6 +1593,11 @@ + + org.apache.camel + camel-dataset + 3.18.0 + org.apache.camel camel-datasonnet @@ -1786,6 +1791,11 @@ + + org.apache.camel + camel-directvm + 3.18.0 + org.apache.camel camel-disruptor @@ -5258,6 +5268,11 @@ + + org.apache.camel + camel-test-junit5 + 3.18.0 + org.apache.camel camel-threadpoolfactory-vertx @@ -7569,6 +7584,11 @@ camel-quarkus-jta-deployment 2.11.0-SNAPSHOT + + org.apache.camel.quarkus + camel-quarkus-junit5 + 2.11.0-SNAPSHOT + org.apache.camel.quarkus camel-quarkus-kafka diff --git a/test-framework/junit5/pom.xml b/test-framework/junit5/pom.xml new file mode 100644 index 000000000000..bd0366a15ead --- /dev/null +++ b/test-framework/junit5/pom.xml @@ -0,0 +1,67 @@ + + + + + org.apache.camel.quarkus + camel-quarkus-test-framework + 2.11.0-SNAPSHOT + ../pom.xml + + 4.0.0 + + camel-quarkus-junit5 + Camel Quarkus :: Test Framework :: Junit5 + + + + org.slf4j + slf4j-api + + + io.quarkus + quarkus-junit5 + + + org.assertj + assertj-core + + + org.junit.jupiter + junit-jupiter-engine + + + org.apache.camel.quarkus + camel-quarkus-core + + + org.apache.camel + camel-test-junit5 + + + org.apache.camel.quarkus + camel-quarkus-bean + test + + + org.apache.camel.quarkus + camel-quarkus-management + + + diff --git a/test-framework/junit5/src/main/java/org/apache/camel/quarkus/test/AfterAllCallback.java b/test-framework/junit5/src/main/java/org/apache/camel/quarkus/test/AfterAllCallback.java new file mode 100644 index 000000000000..99b23ba46203 --- /dev/null +++ b/test-framework/junit5/src/main/java/org/apache/camel/quarkus/test/AfterAllCallback.java @@ -0,0 +1,34 @@ +/* + * 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.quarkus.test; + +import io.quarkus.test.junit.callback.QuarkusTestAfterAllCallback; +import io.quarkus.test.junit.callback.QuarkusTestContext; + +public class AfterAllCallback implements QuarkusTestAfterAllCallback { + + @Override + public void afterAll(QuarkusTestContext context) { + if (context.getTestInstance() instanceof CamelQuarkusTestSupport) { + CamelQuarkusTestSupport testInstance = (CamelQuarkusTestSupport) context.getTestInstance(); + + if (CallbackUtil.isPerClass(testInstance)) { + CallbackUtil.resetContext(testInstance); + } + } + } +} diff --git a/test-framework/junit5/src/main/java/org/apache/camel/quarkus/test/AfterEachCallback.java b/test-framework/junit5/src/main/java/org/apache/camel/quarkus/test/AfterEachCallback.java new file mode 100644 index 000000000000..514f9bbdd370 --- /dev/null +++ b/test-framework/junit5/src/main/java/org/apache/camel/quarkus/test/AfterEachCallback.java @@ -0,0 +1,34 @@ +/* + * 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.quarkus.test; + +import io.quarkus.test.junit.callback.QuarkusTestAfterEachCallback; +import io.quarkus.test.junit.callback.QuarkusTestMethodContext; + +public class AfterEachCallback implements QuarkusTestAfterEachCallback { + + @Override + public void afterEach(QuarkusTestMethodContext context) { + if (context.getTestInstance() instanceof CamelQuarkusTestSupport) { + CamelQuarkusTestSupport testInstance = (CamelQuarkusTestSupport) context.getTestInstance(); + + if (!CallbackUtil.isPerClass(testInstance)) { + CallbackUtil.resetContext(testInstance); + } + } + } +} diff --git a/test-framework/junit5/src/main/java/org/apache/camel/quarkus/test/BeforeEachCallback.java b/test-framework/junit5/src/main/java/org/apache/camel/quarkus/test/BeforeEachCallback.java new file mode 100644 index 000000000000..7bd62b92b27b --- /dev/null +++ b/test-framework/junit5/src/main/java/org/apache/camel/quarkus/test/BeforeEachCallback.java @@ -0,0 +1,51 @@ +/* + * 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.quarkus.test; + +import java.lang.reflect.Method; +import java.util.Arrays; +import java.util.stream.Collectors; + +import io.quarkus.test.junit.callback.QuarkusTestBeforeEachCallback; +import io.quarkus.test.junit.callback.QuarkusTestMethodContext; +import org.junit.jupiter.api.extension.ExtensionContext; + +public class BeforeEachCallback implements QuarkusTestBeforeEachCallback { + + @Override + public void beforeEach(QuarkusTestMethodContext context) { + if (context.getTestInstance() instanceof CamelQuarkusTestSupport) { + CamelQuarkusTestSupport testInstance = (CamelQuarkusTestSupport) context.getTestInstance(); + ExtensionContext mockContext = new CallbackUtil.MockExtensionContext(CallbackUtil.getLifecycle(testInstance), + getDisplayName(context.getTestMethod())); + + try { + testInstance.mockBeforeEach(mockContext); + } catch (Exception e) { + throw new RuntimeException(e); + } + testInstance.mockBeforeAll(mockContext); + } + } + + private String getDisplayName(Method method) { + return String.format("%s(%s)", + method.getName(), + Arrays.stream(method.getParameterTypes()).map(c -> c.getSimpleName()).collect(Collectors.joining(", "))); + } + +} diff --git a/test-framework/junit5/src/main/java/org/apache/camel/quarkus/test/CallbackUtil.java b/test-framework/junit5/src/main/java/org/apache/camel/quarkus/test/CallbackUtil.java new file mode 100644 index 000000000000..1ba6552d308b --- /dev/null +++ b/test-framework/junit5/src/main/java/org/apache/camel/quarkus/test/CallbackUtil.java @@ -0,0 +1,166 @@ +/* + * 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.quarkus.test; + +import java.lang.reflect.AnnotatedElement; +import java.lang.reflect.Method; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.function.Function; + +import org.apache.camel.component.mock.MockEndpoint; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.TestInstances; +import org.junit.jupiter.api.parallel.ExecutionMode; +import org.junit.jupiter.engine.execution.ExtensionValuesStore; +import org.junit.jupiter.engine.execution.NamespaceAwareStore; + +public class CallbackUtil { + + static boolean isPerClass(CamelQuarkusTestSupport testSupport) { + return getLifecycle(testSupport).filter(lc -> lc.equals(TestInstance.Lifecycle.PER_CLASS)).isPresent(); + } + + static Optional getLifecycle(CamelQuarkusTestSupport testSupport) { + if (testSupport.getClass().getAnnotation(TestInstance.class) != null) { + return Optional.of(testSupport.getClass().getAnnotation(TestInstance.class).value()); + } + + return Optional.empty(); + } + + static void resetContext(CamelQuarkusTestSupport testInstance) { + + //if routeBuilder (from the test) was used, all routes has to be stopped and removed + //because routes will be created again (in case of TestInstance.Lifecycle.PER_CLASS, this method is not executed) + if (testInstance.isWasUsedRouteBuilder()) { + try { + testInstance.context().getRouteController().stopAllRoutes(); + testInstance.context().getRouteController().removeAllRoutes(); + + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + testInstance.context().getComponentNames().forEach(cn -> testInstance.context().removeComponent(cn)); + MockEndpoint.resetMocks(testInstance.context()); + } + + static class MockExtensionContext implements ExtensionContext { + + private final Optional lifecycle; + private final String currentTestName; + private final ExtensionContext.Store globalStore; + + public MockExtensionContext(Optional lifecycle, String currentTestName) { + this.lifecycle = lifecycle; + this.currentTestName = currentTestName; + this.globalStore = new NamespaceAwareStore(new ExtensionValuesStore(null), ExtensionContext.Namespace.GLOBAL); + } + + @Override + public Optional getParent() { + return Optional.empty(); + } + + @Override + public ExtensionContext getRoot() { + return null; + } + + @Override + public String getUniqueId() { + return null; + } + + @Override + public String getDisplayName() { + return currentTestName; + } + + @Override + public Set getTags() { + return null; + } + + @Override + public Optional getElement() { + return Optional.empty(); + } + + @Override + public Optional> getTestClass() { + return Optional.empty(); + } + + @Override + public Optional getTestInstanceLifecycle() { + return lifecycle; + } + + @Override + public Optional getTestInstance() { + return Optional.empty(); + } + + @Override + public Optional getTestInstances() { + return Optional.empty(); + } + + @Override + public Optional getTestMethod() { + return Optional.empty(); + } + + @Override + public Optional getExecutionException() { + return Optional.empty(); + } + + @Override + public Optional getConfigurationParameter(String key) { + return Optional.empty(); + } + + @Override + public Optional getConfigurationParameter(String key, Function transformer) { + return Optional.empty(); + } + + @Override + public void publishReportEntry(Map map) { + + } + + @Override + public Store getStore(Namespace namespace) { + if (namespace == Namespace.GLOBAL) { + return globalStore; + } + return null; + } + + @Override + public ExecutionMode getExecutionMode() { + return null; + } + } +} diff --git a/test-framework/junit5/src/main/java/org/apache/camel/quarkus/test/CamelQuarkusTestSupport.java b/test-framework/junit5/src/main/java/org/apache/camel/quarkus/test/CamelQuarkusTestSupport.java new file mode 100644 index 000000000000..6016c68efcb4 --- /dev/null +++ b/test-framework/junit5/src/main/java/org/apache/camel/quarkus/test/CamelQuarkusTestSupport.java @@ -0,0 +1,162 @@ +/* + * 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.quarkus.test; + +import java.util.List; + +import javax.inject.Inject; + +import io.quarkus.test.junit.QuarkusTestProfile; +import org.apache.camel.CamelContext; +import org.apache.camel.RoutesBuilder; +import org.apache.camel.Service; +import org.apache.camel.model.ModelCamelContext; +import org.apache.camel.model.RouteDefinition; +import org.apache.camel.quarkus.core.FastCamelContext; +import org.apache.camel.spi.Registry; +import org.apache.camel.test.junit5.CamelTestSupport; +import org.junit.jupiter.api.extension.ExtensionContext; + +public class CamelQuarkusTestSupport extends CamelTestSupport + implements QuarkusTestProfile { + + private boolean initialized; + + //Flag, whether routes was created by test's route builder and therefore should be stopped smd removed based on lifecycle + private boolean wasUsedRouteBuilder; + + @Inject + protected CamelContext context; + + @Override + protected CamelContext createCamelContext() throws Exception { + return this.context; + } + + @Override + protected Registry createCamelRegistry() { + throw new UnsupportedOperationException("won't be executed."); + } + + @Override + public void beforeAll(ExtensionContext context) { + //replaced by quarkus callback (beforeEach) + } + + @Override + public void beforeEach(ExtensionContext context) throws Exception { + //replaced by quarkus callback (beforeEach) + } + + @Override + public void afterAll(ExtensionContext context) { + //in camel-quarkus, junit5 uses different classloader, necessary code was moved into quarkus's callback + try { + doPostTearDown(); + cleanupResources(); + } catch (Exception e) { + // ignore + } + } + + @Override + public void afterEach(ExtensionContext context) throws Exception { + //in camel-quarkus, junit5 uses different classloader, necessary code was moved into quarkus's callback + } + + @Override + public void afterTestExecution(ExtensionContext context) throws Exception { + //in camel-quarkus, junit5 uses different classloader, necessary code was moved into quarkus's callback + } + + @Override + protected void stopCamelContext() throws Exception { + //context is started and stopped via quarkus lifecycle + } + + @Override + protected void doQuarkusCheck() { + //can run on Quarkus + } + + public void mockBeforeAll(ExtensionContext context) { + super.beforeAll(context); + } + + public void mockBeforeEach(ExtensionContext context) throws Exception { + super.beforeEach(context); + } + + @Override + public boolean isUseRouteBuilder() { + if (context.getRoutes().isEmpty()) { + wasUsedRouteBuilder = super.isUseRouteBuilder(); + return wasUsedRouteBuilder; + } + + return false; + } + + @Override + protected void doSetUp() throws Exception { + context.getManagementStrategy(); + if (!initialized) { + super.doSetUp(); + initialized = true; + } + } + + @Override + protected void doPreSetup() throws Exception { + if (isUseAdviceWith() || isUseDebugger()) { + ((FastCamelContext) context).suspend(); + } + super.doPreSetup(); + } + + @Override + protected void doPostSetup() throws Exception { + if (isUseAdviceWith() || isUseDebugger()) { + ((FastCamelContext) context).resume(); + if (isUseDebugger()) { + ModelCamelContext mcc = context.adapt(ModelCamelContext.class); + List rdfs = mcc.getRouteDefinitions(); + //addition causes removal -> it starts routes, which were added during setUp, when context was suspended + mcc.addRouteDefinitions(rdfs); + } + } + super.doPostSetup(); + } + + RoutesBuilder getRouteBuilder() throws Exception { + return createRouteBuilder(); + } + + @Override + protected void doStopCamelContext(CamelContext context, Service camelContextService) { + //don't stop + } + + @Override + protected void startCamelContext() { + //context has already started + } + + boolean isWasUsedRouteBuilder() { + return wasUsedRouteBuilder; + } +} diff --git a/test-framework/junit5/src/main/java/org/apache/camel/quarkus/test/TestConfigSourceFactory.java b/test-framework/junit5/src/main/java/org/apache/camel/quarkus/test/TestConfigSourceFactory.java new file mode 100644 index 000000000000..c491971791a6 --- /dev/null +++ b/test-framework/junit5/src/main/java/org/apache/camel/quarkus/test/TestConfigSourceFactory.java @@ -0,0 +1,44 @@ +/* + * 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.quarkus.test; + +import java.util.Collections; +import java.util.HashMap; + +import io.smallrye.config.ConfigSourceContext; +import io.smallrye.config.ConfigSourceFactory; +import io.smallrye.config.common.MapBackedConfigSource; +import org.eclipse.microprofile.config.spi.ConfigSource; + +public class TestConfigSourceFactory implements ConfigSourceFactory { + + private final static MapBackedConfigSource source = new MapBackedConfigSource("logging_properties", new HashMap() { + { + put("quarkus.log.console.enable", "false"); + put("quarkus.log.file.enable", "true"); + put("quarkus.log.file.path", "target/camel-test.log"); + put("quarkus.log.file.level", "INFO"); + put("quarkus.log.file.format", "%d %-5p %c{1} - %m %n"); + } + }) { + }; + + @Override + public Iterable getConfigSources(ConfigSourceContext configSourceContext) { + return Collections.singletonList(source); + } +} diff --git a/test-framework/junit5/src/main/resources/META-INF/services/io.quarkus.test.junit.callback.QuarkusTestAfterAllCallback b/test-framework/junit5/src/main/resources/META-INF/services/io.quarkus.test.junit.callback.QuarkusTestAfterAllCallback new file mode 100644 index 000000000000..23f8280e310e --- /dev/null +++ b/test-framework/junit5/src/main/resources/META-INF/services/io.quarkus.test.junit.callback.QuarkusTestAfterAllCallback @@ -0,0 +1 @@ +org.apache.camel.quarkus.test.AfterAllCallback diff --git a/test-framework/junit5/src/main/resources/META-INF/services/io.quarkus.test.junit.callback.QuarkusTestAfterEachCallback b/test-framework/junit5/src/main/resources/META-INF/services/io.quarkus.test.junit.callback.QuarkusTestAfterEachCallback new file mode 100644 index 000000000000..8749fd5f220c --- /dev/null +++ b/test-framework/junit5/src/main/resources/META-INF/services/io.quarkus.test.junit.callback.QuarkusTestAfterEachCallback @@ -0,0 +1 @@ +org.apache.camel.quarkus.test.AfterEachCallback diff --git a/test-framework/junit5/src/main/resources/META-INF/services/io.quarkus.test.junit.callback.QuarkusTestBeforeEachCallback b/test-framework/junit5/src/main/resources/META-INF/services/io.quarkus.test.junit.callback.QuarkusTestBeforeEachCallback new file mode 100644 index 000000000000..0887c9994488 --- /dev/null +++ b/test-framework/junit5/src/main/resources/META-INF/services/io.quarkus.test.junit.callback.QuarkusTestBeforeEachCallback @@ -0,0 +1 @@ +org.apache.camel.quarkus.test.BeforeEachCallback diff --git a/test-framework/junit5/src/main/resources/META-INF/services/io.smallrye.config.ConfigSourceFactory b/test-framework/junit5/src/main/resources/META-INF/services/io.smallrye.config.ConfigSourceFactory new file mode 100644 index 000000000000..f684df6f3058 --- /dev/null +++ b/test-framework/junit5/src/main/resources/META-INF/services/io.smallrye.config.ConfigSourceFactory @@ -0,0 +1 @@ +org.apache.camel.quarkus.test.TestConfigSourceFactory \ No newline at end of file diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/common/AbstractCallbacksTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/common/AbstractCallbacksTest.java new file mode 100644 index 000000000000..40627ab625b2 --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/common/AbstractCallbacksTest.java @@ -0,0 +1,204 @@ +/* + * 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.apachencamel.quarkus.test.common; + +import java.io.File; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.Arrays; +import java.util.HashMap; +import java.util.Map; +import java.util.Set; +import java.util.function.BiConsumer; +import java.util.stream.Collectors; + +import org.apache.camel.CamelContext; +import org.apache.camel.Produce; +import org.apache.camel.ProducerTemplate; +import org.apache.camel.RoutesBuilder; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.quarkus.test.CamelQuarkusTestSupport; +import org.apache.camel.util.StopWatch; +import org.apachencamel.quarkus.test.junit5.patterns.DebugJUnit5Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public abstract class AbstractCallbacksTest extends CamelQuarkusTestSupport { + + private static final Logger LOG = LoggerFactory.getLogger(DebugJUnit5Test.class); + + public enum Callback { + postTearDown, + doSetup, + preSetup, + postSetup, + contextCreation; + } + + private final String testName; + + @Produce("direct:start") + protected ProducerTemplate template; + + public AbstractCallbacksTest(String testName) { + this.testName = testName; + } + + @Override + protected CamelContext createCamelContext() throws Exception { + createTmpFile(testName, Callback.contextCreation); + return super.createCamelContext(); + } + + @Override + protected void doPreSetup() throws Exception { + createTmpFile(testName, Callback.preSetup); + super.doPostSetup(); + } + + @Override + protected void doSetUp() throws Exception { + createTmpFile(testName, Callback.doSetup); + super.doSetUp(); + } + + @Override + protected void doPostSetup() throws Exception { + createTmpFile(testName, Callback.postSetup); + super.doPostSetup(); + } + + @Override + protected void doPostTearDown() throws Exception { + createTmpFile(testName, Callback.postTearDown); + super.doPostTearDown(); + } + + @Test + public void testMock() throws Exception { + getMockEndpoint("mock:result").expectedBodiesReceived("Hello World"); + template.sendBody("direct:start", "Hello World"); + assertMockEndpointsSatisfied(); + } + + @Test + public void testMock2() throws Exception { + getMockEndpoint("mock:result").expectedBodiesReceived("Hello World 2"); + template.sendBody("direct:start", "Hello World 2"); + assertMockEndpointsSatisfied(); + } + + @Override + protected RoutesBuilder createRouteBuilder() { + return new RouteBuilder() { + @Override + public void configure() { + from("direct:start").to("mock:result"); + } + }; + } + + static void assertCount(int expectedCount, Long count, Callback c, String testName) { + Assertions.assertEquals(expectedCount, count, + c.name() + " should be called exactly " + expectedCount + " times in " + testName); + } + + static void testAfterAll(String testName, BiConsumer consumer) { + // we are called before doPostTearDown so lets wait for that to be + // called + Runnable r = () -> { + Map counts = new HashMap<>(); + try { + StopWatch watch = new StopWatch(); + while (watch.taken() < 5000) { + //LOG.debug("Checking for tear down called correctly"); + try { + for (AbstractCallbacksTest.Callback c : AbstractCallbacksTest.Callback.values()) { + long count = doesTmpFileExist(testName, c); + if (count > 0) { + counts.put(c, count); + } + } + } catch (Exception e) { + //ignore + } + + if (counts.size() == AbstractCallbacksTest.Callback.values().length) { + 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()); + for (Callback c : Callback.values()) { + consumer.accept(c, counts.get(c)); + } + } + + }; + Thread t = new Thread(r); + t.setDaemon(false); + t.setName("shouldTearDown checker"); + t.start(); + } + + private static void createTmpFile(String testName, Callback callback) throws Exception { + Set testDirs = Arrays.stream(Paths.get("target").toFile().listFiles()) + .filter(f -> f.isDirectory() && f.getName().startsWith(testName)) + .collect(Collectors.toSet()); + + Path tmpDir; + if (testDirs.size() == 1) { + tmpDir = testDirs.stream().findFirst().get().toPath(); + } else if (testDirs.size() > 1) { + throw new RuntimeException(); + } else { + tmpDir = Files.createTempDirectory(Paths.get("target"), testName); + tmpDir.toFile().deleteOnExit(); + } + + Path tmpFile = Files.createTempFile(tmpDir, callback.name(), ".log"); + tmpFile.toFile().deleteOnExit(); + } + + private static long doesTmpFileExist(String testName, Callback callback) throws Exception { + //find test dir + Set testDirs = Arrays.stream(Paths.get("target").toFile().listFiles()) + .filter(f -> f.isDirectory() && f.getName().startsWith(testName)) + .collect(Collectors.toSet()); + if (testDirs.size() > 1) { + LOG.warn("There are more tmp folders for the Callback tests."); + return -1; + } + if (testDirs.isEmpty()) { + LOG.warn("There is no tmp folder for the Callback tests."); + return 0; + } + + return Arrays.stream(testDirs.stream().findFirst().get().listFiles()) + .filter(f -> f.getName().startsWith(callback.name())) + .count(); + } +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/common/AbstractSimpleMockTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/common/AbstractSimpleMockTest.java new file mode 100644 index 000000000000..a34dba0a78b4 --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/common/AbstractSimpleMockTest.java @@ -0,0 +1,64 @@ +/* + * 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.apachencamel.quarkus.test.common; + +import io.quarkus.test.junit.QuarkusTest; +import org.apache.camel.Produce; +import org.apache.camel.ProducerTemplate; +import org.apache.camel.RoutesBuilder; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.Test; + +@QuarkusTest +public abstract class AbstractSimpleMockTest extends CamelQuarkusTestSupport { + + @Produce("direct:start") + protected ProducerTemplate template; + + private String msgToSend; + private String msgToExpect; + + public AbstractSimpleMockTest(String msgToSend, String msgToExpect) { + this.msgToSend = msgToSend; + this.msgToExpect = msgToExpect; + } + + public void setMsgToSend(String msgToSend) { + this.msgToSend = msgToSend; + } + + @Test + public void testMock() throws Exception { + getMockEndpoint("mock:result").expectedBodiesReceived(msgToExpect); + + template.sendBody("direct:start", msgToSend); + + assertMockEndpointsSatisfied(); + } + + @Override + protected RoutesBuilder createRouteBuilder() { + return new RouteBuilder() { + @Override + public void configure() { + from("direct:start").to("mock:result"); + } + }; + } + +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/common/CallbacksPerTestFalseTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/common/CallbacksPerTestFalseTest.java new file mode 100644 index 000000000000..d1e9ffaa997e --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/common/CallbacksPerTestFalseTest.java @@ -0,0 +1,59 @@ +/* + * 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.apachencamel.quarkus.test.common; + +import io.quarkus.test.junit.QuarkusTest; +import io.quarkus.test.junit.TestProfile; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.TestInstance; + +// replaces CreateCamelContextPerTestTrueTest +//tdoo add check of all callbacks and context creation + the same check with perClass +@QuarkusTest +@TestInstance(TestInstance.Lifecycle.PER_METHOD) +@TestProfile(CallbacksPerTestFalseTest.class) +public class CallbacksPerTestFalseTest extends AbstractCallbacksTest { + + public CallbacksPerTestFalseTest() { + super(CallbacksPerTestFalseTest.class.getSimpleName()); + } + + @AfterAll + public static void shouldTearDown() { + testAfterAll(CallbacksPerTestFalseTest.class.getSimpleName(), (callback, count) -> { + switch (callback) { + case doSetup: + assertCount(2, count, callback, CallbacksPerTestFalseTest.class.getSimpleName()); + break; + case contextCreation: + assertCount(2, count, callback, CallbacksPerTestFalseTest.class.getSimpleName()); + break; + case postSetup: + assertCount(2, count, callback, CallbacksPerTestFalseTest.class.getSimpleName()); + break; + case postTearDown: + assertCount(2, count, callback, CallbacksPerTestFalseTest.class.getSimpleName()); + break; + case preSetup: + assertCount(2, count, callback, CallbacksPerTestFalseTest.class.getSimpleName()); + break; + default: + throw new IllegalArgumentException(); + } + }); + } +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/common/CallbacksPerTestTrueTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/common/CallbacksPerTestTrueTest.java new file mode 100644 index 000000000000..7a4540a08d10 --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/common/CallbacksPerTestTrueTest.java @@ -0,0 +1,58 @@ +/* + * 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.apachencamel.quarkus.test.common; + +import io.quarkus.test.junit.QuarkusTest; +import io.quarkus.test.junit.TestProfile; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.TestInstance; + +// replaces CreateCamelContextPerTestTrueTest +@QuarkusTest +@TestInstance(TestInstance.Lifecycle.PER_CLASS) +@TestProfile(CallbacksPerTestTrueTest.class) +public class CallbacksPerTestTrueTest extends AbstractCallbacksTest { + + public CallbacksPerTestTrueTest() { + super(CallbacksPerTestTrueTest.class.getSimpleName()); + } + + @AfterAll + public static void shouldTearDown() { + testAfterAll(CallbacksPerTestTrueTest.class.getSimpleName(), (callback, count) -> { + switch (callback) { + case doSetup: + assertCount(1, count, callback, CallbacksPerTestTrueTest.class.getSimpleName()); + break; + case contextCreation: + assertCount(1, count, callback, CallbacksPerTestTrueTest.class.getSimpleName()); + break; + case postSetup: + assertCount(1, count, callback, CallbacksPerTestTrueTest.class.getSimpleName()); + break; + case postTearDown: + assertCount(1, count, callback, CallbacksPerTestTrueTest.class.getSimpleName()); + break; + case preSetup: + assertCount(1, count, callback, CallbacksPerTestTrueTest.class.getSimpleName()); + break; + default: + throw new IllegalArgumentException(); + } + }); + } +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/common/JupiterCallbackCorrectTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/common/JupiterCallbackCorrectTest.java new file mode 100644 index 000000000000..0d6b8f4d699f --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/common/JupiterCallbackCorrectTest.java @@ -0,0 +1,33 @@ +/* + * 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.apachencamel.quarkus.test.common; + +import io.quarkus.test.junit.QuarkusTest; +import org.junit.jupiter.api.BeforeEach; + +@QuarkusTest +public class JupiterCallbackCorrectTest extends AbstractSimpleMockTest { + + public JupiterCallbackCorrectTest() { + super("hello", "hi"); + } + + @BeforeEach + public void beforeEach() throws Exception { + setMsgToSend("hi"); + } +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/common/JupiterCallbackWrongTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/common/JupiterCallbackWrongTest.java new file mode 100644 index 000000000000..4499906f6101 --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/common/JupiterCallbackWrongTest.java @@ -0,0 +1,34 @@ +/* + * 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.apachencamel.quarkus.test.common; + +import io.quarkus.test.junit.QuarkusTest; +import org.junit.jupiter.api.extension.BeforeEachCallback; +import org.junit.jupiter.api.extension.ExtensionContext; + +@QuarkusTest +public class JupiterCallbackWrongTest extends AbstractSimpleMockTest implements BeforeEachCallback { + + public JupiterCallbackWrongTest() { + super("hello", "hello"); + } + + @Override + public void beforeEach(ExtensionContext context) throws Exception { + setMsgToSend("hi"); + } +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/CamelTestSupportTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/CamelTestSupportTest.java new file mode 100644 index 000000000000..6e28255aa632 --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/CamelTestSupportTest.java @@ -0,0 +1,80 @@ +/* + * 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.apachencamel.quarkus.test.junit5; + +import io.quarkus.test.junit.QuarkusTest; +import io.quarkus.test.junit.TestProfile; +import org.apache.camel.NoSuchEndpointException; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.component.mock.MockEndpoint; +import org.apache.camel.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertThrows; + +@QuarkusTest +@TestProfile(CamelTestSupportTest.class) +public class CamelTestSupportTest extends CamelQuarkusTestSupport { + + @Override + @BeforeEach + public void setUp() throws Exception { + replaceRouteFromWith("routeId", "direct:start"); + super.setUp(); + } + + @Test + public void replacesFromEndpoint() throws Exception { + getMockEndpoint("mock:result").expectedBodiesReceived("Hello World"); + + template.sendBody("direct:start", "Hello World"); + + assertMockEndpointsSatisfied(); + } + + @Test + public void exceptionThrownWhenEndpointNotFoundAndNoCreate() { + assertThrows(NoSuchEndpointException.class, () -> { + getMockEndpoint("mock:bogus", false); + }); + } + + @Test + public void exceptionThrownWhenEndpointNotAMockEndpoint() { + assertThrows(NoSuchEndpointException.class, () -> { + getMockEndpoint("direct:something", false); + }); + } + + @Test + public void autoCreateNonExisting() { + MockEndpoint mock = getMockEndpoint("mock:bogus2", true); + assertNotNull(mock); + } + + @Override + protected RouteBuilder createRouteBuilder() { + return new RouteBuilder() { + @Override + public void configure() { + from("direct:something").id("routeId").to("mock:result"); + } + }; + } +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/RouteFilterPatternExcludeTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/RouteFilterPatternExcludeTest.java new file mode 100644 index 000000000000..fcb9c0b5d30e --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/RouteFilterPatternExcludeTest.java @@ -0,0 +1,62 @@ +/* + * 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.apachencamel.quarkus.test.junit5; + +import io.quarkus.test.junit.QuarkusTest; +import io.quarkus.test.junit.TestProfile; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.model.Model; +import org.apache.camel.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +@QuarkusTest +@TestProfile(RouteFilterPatternExcludeTest.class) +public class RouteFilterPatternExcludeTest extends CamelQuarkusTestSupport { + + @Override + public String getRouteFilterExcludePattern() { + return "bar*"; + } + + @Test + public void testRouteFilter() throws Exception { + assertEquals(1, context.getRoutes().size()); + assertEquals(1, context.getExtension(Model.class).getRouteDefinitions().size()); + assertEquals("foo", context.getExtension(Model.class).getRouteDefinitions().get(0).getId()); + + getMockEndpoint("mock:foo").expectedMessageCount(1); + + template.sendBody("direct:foo", "Hello World"); + + assertMockEndpointsSatisfied(); + } + + @Override + protected RouteBuilder createRouteBuilder() { + return new RouteBuilder() { + @Override + public void configure() { + from("direct:foo").routeId("foo").to("mock:foo"); + + from("direct:bar").routeId("bar").to("mock:bar"); + } + }; + } + +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/RouteFilterPatternIncludeExcludeTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/RouteFilterPatternIncludeExcludeTest.java new file mode 100644 index 000000000000..232c1dcd5385 --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/RouteFilterPatternIncludeExcludeTest.java @@ -0,0 +1,69 @@ +/* + * 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.apachencamel.quarkus.test.junit5; + +import io.quarkus.test.junit.QuarkusTest; +import io.quarkus.test.junit.TestProfile; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.model.Model; +import org.apache.camel.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +@QuarkusTest +@TestProfile(RouteFilterPatternIncludeExcludeTest.class) +public class RouteFilterPatternIncludeExcludeTest extends CamelQuarkusTestSupport { + + @Override + public String getRouteFilterIncludePattern() { + return "foo*"; + } + + @Override + public String getRouteFilterExcludePattern() { + return "jms:*"; + } + + @Test + public void testRouteFilter() throws Exception { + assertEquals(1, context.getRoutes().size()); + assertEquals(1, context.getExtension(Model.class).getRouteDefinitions().size()); + assertEquals("foo", context.getExtension(Model.class).getRouteDefinitions().get(0).getId()); + + getMockEndpoint("mock:foo").expectedMessageCount(1); + + template.sendBody("direct:foo", "Hello World"); + + assertMockEndpointsSatisfied(); + } + + @Override + protected RouteBuilder createRouteBuilder() { + return new RouteBuilder() { + @Override + public void configure() { + from("direct:foo").routeId("foo").to("mock:foo"); + + from("direct:bar").routeId("bar").to("mock:bar"); + + from("jms:beer").routeId("foolish").to("mock:beer"); + } + }; + } + +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/RouteFilterPatternIncludeTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/RouteFilterPatternIncludeTest.java new file mode 100644 index 000000000000..fc2d0aaa40c5 --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/RouteFilterPatternIncludeTest.java @@ -0,0 +1,62 @@ +/* + * 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.apachencamel.quarkus.test.junit5; + +import io.quarkus.test.junit.QuarkusTest; +import io.quarkus.test.junit.TestProfile; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.model.Model; +import org.apache.camel.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +@QuarkusTest +@TestProfile(RouteFilterPatternIncludeTest.class) +public class RouteFilterPatternIncludeTest extends CamelQuarkusTestSupport { + + @Override + public String getRouteFilterIncludePattern() { + return "foo*"; + } + + @Test + public void testRouteFilter() throws Exception { + assertEquals(1, context.getRoutes().size()); + assertEquals(1, context.getExtension(Model.class).getRouteDefinitions().size()); + assertEquals("foo", context.getExtension(Model.class).getRouteDefinitions().get(0).getId()); + + getMockEndpoint("mock:foo").expectedMessageCount(1); + + template.sendBody("direct:foo", "Hello World"); + + assertMockEndpointsSatisfied(); + } + + @Override + protected RouteBuilder createRouteBuilder() { + return new RouteBuilder() { + @Override + public void configure() { + from("direct:foo").routeId("foo").to("mock:foo"); + + from("direct:bar").routeId("bar").to("mock:bar"); + } + }; + } + +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/AdviceWithLambdaTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/AdviceWithLambdaTest.java new file mode 100644 index 000000000000..3ca121479008 --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/AdviceWithLambdaTest.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.apachencamel.quarkus.test.junit5.patterns; + +import io.quarkus.test.junit.QuarkusTest; +import org.apache.camel.RoutesBuilder; +import org.apache.camel.builder.AdviceWith; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.Test; + +@QuarkusTest +public class AdviceWithLambdaTest extends CamelQuarkusTestSupport { + + @Override + public boolean isUseAdviceWith() { + return true; + } + + @Test + public void testAdviceWith() throws Exception { + getMockEndpoint("mock:result").expectedMessageCount(1); + + // advice the route in one line + AdviceWith.adviceWith(context, "foo", a -> a.weaveAddLast().to("mock:result")); + + template.sendBody("direct:start", "Bye World"); + + assertMockEndpointsSatisfied(); + } + + @Override + protected RoutesBuilder createRouteBuilder() { + return new RouteBuilder() { + @Override + public void configure() { + from("direct:start").routeId("foo").to("log:foo"); + } + }; + } +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/DebugJUnit5Test.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/DebugJUnit5Test.java new file mode 100644 index 000000000000..2e47defe3e55 --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/DebugJUnit5Test.java @@ -0,0 +1,95 @@ +/* + * 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.apachencamel.quarkus.test.junit5.patterns; + +import io.quarkus.test.junit.QuarkusTest; +import io.quarkus.test.junit.TestProfile; +import org.apache.camel.Exchange; +import org.apache.camel.Processor; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.model.ProcessorDefinition; +import org.apache.camel.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@QuarkusTest +@TestInstance(TestInstance.Lifecycle.PER_CLASS) +@TestProfile(DebugJUnit5Test.class) +public class DebugJUnit5Test extends CamelQuarkusTestSupport { + + private static final Logger LOG = LoggerFactory.getLogger(DebugJUnit5Test.class); + + // START SNIPPET: e1 + @Override + public boolean isUseDebugger() { + // must enable debugger + return true; + } + + @Override + protected void debugBefore( + Exchange exchange, Processor processor, ProcessorDefinition definition, String id, String shortName) { + // this method is invoked before we are about to enter the given + // processor + // from your Java editor you can just add a breakpoint in the code line + // below + LOG.info("Before " + definition + " with body " + exchange.getIn().getBody()); + } + // END SNIPPET: e1 + + @Test + public void testDebugger() throws Exception { + // set mock expectations + getMockEndpoint("mock:a").expectedMessageCount(1); + getMockEndpoint("mock:b").expectedMessageCount(1); + + // send a message + template.sendBody("direct:start", "World"); + + // assert mocks + assertMockEndpointsSatisfied(); + } + + @Test + public void testTwo() throws Exception { + // set mock expectations + getMockEndpoint("mock:a").expectedMessageCount(2); + getMockEndpoint("mock:b").expectedMessageCount(2); + + // send a message + template.sendBody("direct:start", "World"); + template.sendBody("direct:start", "Camel"); + + // assert mocks + assertMockEndpointsSatisfied(); + } + + // START SNIPPET: e2 + @Override + protected RouteBuilder createRouteBuilder() { + return new RouteBuilder() { + @Override + public void configure() { + // this is the route we want to debug + from("direct:start").to("mock:a").transform(body().prepend("Hello ")).to("mock:b"); + } + }; + } + // END SNIPPET: e2 +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/DebugNoLazyTypeConverterTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/DebugNoLazyTypeConverterTest.java new file mode 100644 index 000000000000..2499967b317e --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/DebugNoLazyTypeConverterTest.java @@ -0,0 +1,91 @@ +/* + * 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.apachencamel.quarkus.test.junit5.patterns; + +import io.quarkus.test.junit.QuarkusTest; +import org.apache.camel.Exchange; +import org.apache.camel.Processor; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.model.ProcessorDefinition; +import org.apache.camel.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.Test; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@QuarkusTest +public class DebugNoLazyTypeConverterTest extends CamelQuarkusTestSupport { + + private static final Logger LOG = LoggerFactory.getLogger(DebugNoLazyTypeConverterTest.class); + + // START SNIPPET: e1 + @Override + public boolean isUseDebugger() { + // must enable debugger + return true; + } + + @Override + protected void debugBefore( + Exchange exchange, Processor processor, ProcessorDefinition definition, String id, String shortName) { + // this method is invoked before we are about to enter the given + // processor + // from your Java editor you can just add a breakpoint in the code line + // below + LOG.info("Before " + definition + " with body " + exchange.getIn().getBody()); + } + // END SNIPPET: e1 + + @Test + public void testDebugger() throws Exception { + // set mock expectations + getMockEndpoint("mock:a").expectedMessageCount(1); + getMockEndpoint("mock:b").expectedMessageCount(1); + + // send a message + template.sendBody("direct:start", "World"); + + // assert mocks + assertMockEndpointsSatisfied(); + } + + @Test + public void testTwo() throws Exception { + // set mock expectations + getMockEndpoint("mock:a").expectedMessageCount(2); + getMockEndpoint("mock:b").expectedMessageCount(2); + + // send a message + template.sendBody("direct:start", "World"); + template.sendBody("direct:start", "Camel"); + + // assert mocks + assertMockEndpointsSatisfied(); + } + + // START SNIPPET: e2 + @Override + protected RouteBuilder createRouteBuilder() { + return new RouteBuilder() { + @Override + public void configure() { + // this is the route we want to debug + from("direct:start").to("mock:a").transform(body().prepend("Hello ")).to("mock:b"); + } + }; + } + // END SNIPPET: e2 +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/DebugTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/DebugTest.java new file mode 100644 index 000000000000..7fc90b31ae4e --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/DebugTest.java @@ -0,0 +1,98 @@ +/* + * 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.apachencamel.quarkus.test.junit5.patterns; + +import io.quarkus.test.junit.QuarkusTest; +import org.apache.camel.Exchange; +import org.apache.camel.Processor; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.model.ProcessorDefinition; +import org.apache.camel.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.Test; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@QuarkusTest +public class DebugTest extends CamelQuarkusTestSupport { + + private static final Logger LOG = LoggerFactory.getLogger(DebugTest.class); + + @Override + public boolean isUseAdviceWith() { + return true; + } + + // START SNIPPET: e1 + @Override + public boolean isUseDebugger() { + // must enable debugger + return true; + } + + @Override + protected void debugBefore( + Exchange exchange, Processor processor, ProcessorDefinition definition, String id, String shortName) { + // this method is invoked before we are about to enter the given + // processor + // from your Java editor you can just add a breakpoint in the code line + // below + LOG.info("Before " + definition + " with body " + exchange.getIn().getBody()); + } + // END SNIPPET: e1 + + @Test + public void testDebugger() throws Exception { + + // set mock expectations + getMockEndpoint("mock:a").expectedMessageCount(1); + getMockEndpoint("mock:b").expectedMessageCount(1); + + // send a message + template.sendBody("direct:start", "World"); + + // assert mocks + assertMockEndpointsSatisfied(); + } + + @Test + public void testTwo() throws Exception { + + // set mock expectations + getMockEndpoint("mock:a").expectedMessageCount(2); + getMockEndpoint("mock:b").expectedMessageCount(2); + + // send a message + template.sendBody("direct:start", "World"); + template.sendBody("direct:start", "Camel"); + + // assert mocks + assertMockEndpointsSatisfied(); + } + + // START SNIPPET: e2 + @Override + protected RouteBuilder createRouteBuilder() { + return new RouteBuilder() { + @Override + public void configure() { + // this is the route we want to debug + from("direct:start").to("mock:a").transform(body().prepend("Hello ")).to("mock:b").routeId("foo"); + } + }; + } + // END SNIPPET: e2 +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/FilterCreateCamelContextPerClassTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/FilterCreateCamelContextPerClassTest.java new file mode 100644 index 000000000000..8185a8ad90cd --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/FilterCreateCamelContextPerClassTest.java @@ -0,0 +1,63 @@ +/* + * 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.apachencamel.quarkus.test.junit5.patterns; + +import io.quarkus.test.junit.QuarkusTest; +import io.quarkus.test.junit.TestProfile; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; + +/** + * Tests filtering using Camel Test + */ +// START SNIPPET: example +@QuarkusTest +@TestInstance(TestInstance.Lifecycle.PER_CLASS) +@TestProfile(FilterCreateCamelContextPerClassTest.class) +public class FilterCreateCamelContextPerClassTest extends CamelQuarkusTestSupport { + + @Test + public void testSendMatchingMessage() throws Exception { + String expectedBody = ""; + + getMockEndpoint("mock:result").expectedBodiesReceived(expectedBody); + + template.sendBodyAndHeader("direct:start", expectedBody, "foo", "bar"); + + assertMockEndpointsSatisfied(); + } + + @Test + public void testSendNotMatchingMessage() throws Exception { + getMockEndpoint("mock:result").expectedMessageCount(0); + + template.sendBodyAndHeader("direct:start", "", "foo", "notMatchedHeaderValue"); + + assertMockEndpointsSatisfied(); + } + + @Override + protected RouteBuilder createRouteBuilder() { + return new RouteBuilder() { + public void configure() { + from("direct:start").filter(header("foo").isEqualTo("bar")).to("mock:result"); + } + }; + } +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/FilterFluentTemplateTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/FilterFluentTemplateTest.java new file mode 100644 index 000000000000..1b0f34080e27 --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/FilterFluentTemplateTest.java @@ -0,0 +1,81 @@ +/* + * 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.apachencamel.quarkus.test.junit5.patterns; + +import io.quarkus.test.junit.QuarkusTest; +import org.apache.camel.EndpointInject; +import org.apache.camel.FluentProducerTemplate; +import org.apache.camel.Produce; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.component.mock.MockEndpoint; +import org.apache.camel.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.Test; + +/** + * Tests filtering using Camel Test + */ +// START SNIPPET: example +// tag::example[] +@QuarkusTest +public class FilterFluentTemplateTest extends CamelQuarkusTestSupport { + + @EndpointInject("mock:result") + protected MockEndpoint resultEndpoint; + + @Produce("direct:startFluent") + protected FluentProducerTemplate fluentTemplate; + + @Override + public boolean isDumpRouteCoverage() { + return true; + } + + @Test + public void testSendMatchingMessage() throws Exception { + String expectedBody = ""; + + resultEndpoint.expectedBodiesReceived(expectedBody); + + fluentTemplate.withBody(expectedBody).withHeader("foo", "bar").send(); + + resultEndpoint.assertIsSatisfied(); + + resultEndpoint.reset(); + } + + @Test + public void testSendNotMatchingMessage() throws Exception { + resultEndpoint.expectedMessageCount(0); + + fluentTemplate.withBody("").withHeader("foo", "notMatchedHeaderValue").send(); + + resultEndpoint.assertIsSatisfied(); + + resultEndpoint.reset(); + } + + @Override + protected RouteBuilder createRouteBuilder() { + return new RouteBuilder() { + public void configure() { + from("direct:startFluent").filter(header("foo").isEqualTo("bar")).to("mock:result"); + } + }; + } +} +// end::example[] +// END SNIPPET: example diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/FilterJUnit5Test.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/FilterJUnit5Test.java new file mode 100644 index 000000000000..67042247b453 --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/FilterJUnit5Test.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.apachencamel.quarkus.test.junit5.patterns; + +import io.quarkus.test.junit.QuarkusTest; +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.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.Test; + +/** + * Tests filtering using Camel Test + */ +// START SNIPPET: example +@QuarkusTest +public class FilterJUnit5Test extends CamelQuarkusTestSupport { + + @EndpointInject("mock:result") + protected MockEndpoint resultEndpoint; + + @Produce("direct:start") + protected ProducerTemplate template; + + @Test + public void testSendMatchingMessage() throws Exception { + String expectedBody = ""; + + resultEndpoint.expectedBodiesReceived(expectedBody); + + template.sendBodyAndHeader(expectedBody, "foo", "bar"); + + resultEndpoint.assertIsSatisfied(); + + resultEndpoint.reset(); + } + + @Test + public void testSendNotMatchingMessage() throws Exception { + resultEndpoint.expectedMessageCount(0); + + template.sendBodyAndHeader("", "foo", "notMatchedHeaderValue"); + + resultEndpoint.assertIsSatisfied(); + + resultEndpoint.reset(); + } + + @Override + protected RouteBuilder createRouteBuilder() { + return new RouteBuilder() { + public void configure() { + from("direct:start").filter(header("foo").isEqualTo("bar")).to("mock:result"); + } + }; + } + +} +// END SNIPPET: example diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/FilterTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/FilterTest.java new file mode 100644 index 000000000000..5d2c955aca82 --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/FilterTest.java @@ -0,0 +1,81 @@ +/* + * 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.apachencamel.quarkus.test.junit5.patterns; + +import io.quarkus.test.junit.QuarkusTest; +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.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.Test; + +/** + * Tests filtering using Camel Test + */ +// START SNIPPET: example +// tag::example[] +@QuarkusTest +public class FilterTest extends CamelQuarkusTestSupport { + + @EndpointInject("mock:result") + protected MockEndpoint resultEndpoint; + + @Produce("direct:start") + protected ProducerTemplate template; + + @Override + public boolean isDumpRouteCoverage() { + return true; + } + + @Test + public void testSendMatchingMessage() throws Exception { + String expectedBody = ""; + + resultEndpoint.expectedBodiesReceived(expectedBody); + + template.sendBodyAndHeader(expectedBody, "foo", "bar"); + + resultEndpoint.assertIsSatisfied(); + + resultEndpoint.reset(); + } + + @Test + public void testSendNotMatchingMessage() throws Exception { + resultEndpoint.expectedMessageCount(0); + + template.sendBodyAndHeader("", "foo", "notMatchedHeaderValue"); + + resultEndpoint.assertIsSatisfied(); + + resultEndpoint.reset(); + } + + @Override + protected RouteBuilder createRouteBuilder() { + return new RouteBuilder() { + public void configure() { + from("direct:start").filter(header("foo").isEqualTo("bar")).to("mock:result"); + } + }; + } +} +// end::example[] +// END SNIPPET: example diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/GetMockEndpointTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/GetMockEndpointTest.java new file mode 100644 index 000000000000..046870cfc42e --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/GetMockEndpointTest.java @@ -0,0 +1,47 @@ +/* + * 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.apachencamel.quarkus.test.junit5.patterns; + +import io.quarkus.test.junit.QuarkusTest; +import org.apache.camel.RoutesBuilder; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.Test; + +@QuarkusTest +public class GetMockEndpointTest extends CamelQuarkusTestSupport { + + @Test + public void testMock() throws Exception { + getMockEndpoint("mock:result").expectedBodiesReceived("Hello World"); + + template.sendBody("direct:start", "Hello World"); + + assertMockEndpointsSatisfied(); + } + + @Override + protected RoutesBuilder createRouteBuilder() { + return new RouteBuilder() { + @Override + public void configure() { + from("direct:start").to("mock:result?failFast=false"); + } + }; + } + +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/IsMockEndpointsAndSkipJUnit5Test.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/IsMockEndpointsAndSkipJUnit5Test.java new file mode 100644 index 000000000000..8ff8bcb9191c --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/IsMockEndpointsAndSkipJUnit5Test.java @@ -0,0 +1,72 @@ +/* + * 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.apachencamel.quarkus.test.junit5.patterns; + +import io.quarkus.test.junit.QuarkusTest; +import io.quarkus.test.junit.TestProfile; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.component.seda.SedaEndpoint; +import org.apache.camel.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +// START SNIPPET: e1 +// tag::e1[] +@QuarkusTest +@TestProfile(IsMockEndpointsAndSkipJUnit5Test.class) +public class IsMockEndpointsAndSkipJUnit5Test extends CamelQuarkusTestSupport { + + @Override + public String isMockEndpointsAndSkip() { + // override this method and return the pattern for which endpoints to + // mock, + // and skip sending to the original endpoint. + return "direct:foo"; + } + + @Test + public void testMockEndpointAndSkip() throws Exception { + // notice we have automatic mocked the direct:foo endpoints and the name + // of the endpoints is "mock:uri" + getMockEndpoint("mock:result").expectedBodiesReceived("Hello World"); + getMockEndpoint("mock:direct:foo").expectedMessageCount(1); + + template.sendBody("direct:start", "Hello World"); + + assertMockEndpointsSatisfied(); + + // the message was not send to the direct:foo route and thus not sent to + // the seda endpoint + SedaEndpoint seda = context.getEndpoint("seda:foo", SedaEndpoint.class); + assertEquals(0, seda.getCurrentQueueSize()); + } + + @Override + protected RouteBuilder createRouteBuilder() { + return new RouteBuilder() { + @Override + public void configure() { + from("direct:start").to("direct:foo").to("mock:result"); + + from("direct:foo").transform(constant("Bye World")).to("seda:foo"); + } + }; + } +} +// end::e1[] +// END SNIPPET: e1 diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/IsMockEndpointsFileTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/IsMockEndpointsFileTest.java new file mode 100644 index 000000000000..6f481d98108c --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/IsMockEndpointsFileTest.java @@ -0,0 +1,73 @@ +/* + * 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.apachencamel.quarkus.test.junit5.patterns; + +import io.quarkus.test.junit.QuarkusTest; +import org.apache.camel.Exchange; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.component.mock.MockEndpoint; +import org.apache.camel.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.apache.camel.test.junit5.TestSupport.deleteDirectory; + +@QuarkusTest +public class IsMockEndpointsFileTest extends CamelQuarkusTestSupport { + + @Override + @BeforeEach + public void setUp() throws Exception { + deleteDirectory("target/input"); + deleteDirectory("target/messages"); + super.setUp(); + } + + @Override + public String isMockEndpoints() { + // override this method and return the pattern for which endpoints to + // mock. + return "file:target*"; + } + + @Test + public void testMockFileEndpoints() throws Exception { + // notice we have automatic mocked all endpoints and the name of the + // endpoints is "mock:uri" + MockEndpoint camel = getMockEndpoint("mock:file:target/messages/camel"); + camel.expectedMessageCount(1); + + MockEndpoint other = getMockEndpoint("mock:file:target/messages/others"); + other.expectedMessageCount(1); + + template.sendBodyAndHeader("file:target/input", "Hello Camel", Exchange.FILE_NAME, "camel.txt"); + template.sendBodyAndHeader("file:target/input", "Hello World", Exchange.FILE_NAME, "world.txt"); + + assertMockEndpointsSatisfied(); + } + + @Override + protected RouteBuilder createRouteBuilder() { + return new RouteBuilder() { + @Override + public void configure() { + from("file:target/input").choice().when(bodyAs(String.class).contains("Camel")).to("file:target/messages/camel") + .otherwise().to("file:target/messages/others"); + } + }; + } +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/IsMockEndpointsJUnit5Test.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/IsMockEndpointsJUnit5Test.java new file mode 100644 index 000000000000..2d78f0d45eb5 --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/IsMockEndpointsJUnit5Test.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.apachencamel.quarkus.test.junit5.patterns; + +import io.quarkus.test.junit.QuarkusTest; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertNotNull; + +// START SNIPPET: e1 +// tag::e1[] +@QuarkusTest +public class IsMockEndpointsJUnit5Test extends CamelQuarkusTestSupport { + + @Override + public String isMockEndpoints() { + // override this method and return the pattern for which endpoints to + // mock. + // use * to indicate all + return "*"; + } + + @Test + public void testMockAllEndpoints() throws Exception { + // notice we have automatic mocked all endpoints and the name of the + // endpoints is "mock:uri" + getMockEndpoint("mock:direct:start").expectedBodiesReceived("Hello World"); + getMockEndpoint("mock:direct:foo").expectedBodiesReceived("Hello World"); + getMockEndpoint("mock:log:foo").expectedBodiesReceived("Bye World"); + getMockEndpoint("mock:result").expectedBodiesReceived("Bye World"); + + template.sendBody("direct:start", "Hello World"); + + assertMockEndpointsSatisfied(); + + // additional test to ensure correct endpoints in registry + assertNotNull(context.hasEndpoint("direct:start")); + assertNotNull(context.hasEndpoint("direct:foo")); + assertNotNull(context.hasEndpoint("log:foo")); + assertNotNull(context.hasEndpoint("mock:result")); + // all the endpoints was mocked + assertNotNull(context.hasEndpoint("mock:direct:start")); + assertNotNull(context.hasEndpoint("mock:direct:foo")); + assertNotNull(context.hasEndpoint("mock:log:foo")); + } + + @Override + protected RouteBuilder createRouteBuilder() { + return new RouteBuilder() { + @Override + public void configure() { + from("direct:start").to("direct:foo").to("log:foo").to("mock:result"); + + from("direct:foo").transform(constant("Bye World")); + } + }; + } +} +// end::e1[] +// END SNIPPET: e1 diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/IsMockEndpointsTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/IsMockEndpointsTest.java new file mode 100644 index 000000000000..e6ff58122288 --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/IsMockEndpointsTest.java @@ -0,0 +1,67 @@ +/* + * 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.apachencamel.quarkus.test.junit5.patterns; + +import io.quarkus.test.junit.QuarkusTest; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertNotNull; + +@QuarkusTest +public class IsMockEndpointsTest extends CamelQuarkusTestSupport { + + @Override + public String isMockEndpoints() { + return "*"; + } + + @Test + public void testMockAllEndpoints() throws Exception { + getMockEndpoint("mock:direct:start").expectedBodiesReceived("Hello World"); + getMockEndpoint("mock:direct:foo").expectedBodiesReceived("Hello World"); + getMockEndpoint("mock:log:foo").expectedBodiesReceived("Bye World"); + getMockEndpoint("mock:result").expectedBodiesReceived("Bye World"); + + template.sendBody("direct:start", "Hello World"); + + assertMockEndpointsSatisfied(); + + // additional test to ensure correct endpoints in registry + assertNotNull(context.hasEndpoint("direct:start")); + assertNotNull(context.hasEndpoint("direct:foo")); + assertNotNull(context.hasEndpoint("log:foo")); + assertNotNull(context.hasEndpoint("mock:result")); + // all the endpoints was mocked + assertNotNull(context.hasEndpoint("mock:direct:start")); + assertNotNull(context.hasEndpoint("mock:direct:foo")); + assertNotNull(context.hasEndpoint("mock:log:foo")); + } + + @Override + protected RouteBuilder createRouteBuilder() { + return new RouteBuilder() { + @Override + public void configure() { + from("direct:start").to("direct:foo").to("log:foo").to("mock:result"); + + from("direct:foo").transform(constant("Bye World")); + } + }; + } +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/MockEndpointFailNoHeaderTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/MockEndpointFailNoHeaderTest.java new file mode 100644 index 000000000000..681b351df74a --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/MockEndpointFailNoHeaderTest.java @@ -0,0 +1,65 @@ +/* + * 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.apachencamel.quarkus.test.junit5.patterns; + +import io.quarkus.test.junit.QuarkusTest; +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.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.Test; + +@QuarkusTest +public class MockEndpointFailNoHeaderTest extends CamelQuarkusTestSupport { + + @EndpointInject("mock:result") + protected MockEndpoint resultEndpoint; + + @Produce("direct:start") + protected ProducerTemplate template; + + @Override + public boolean isDumpRouteCoverage() { + return true; + } + + @Test + public void withHeaderTestCase() throws InterruptedException { + String expectedBody = ""; + resultEndpoint.expectedHeaderReceived("foo", "bar"); + template.sendBodyAndHeader(expectedBody, "foo", "bar"); + resultEndpoint.assertIsSatisfied(); + } + + @Test + public void noHeaderTestCase() throws InterruptedException { + resultEndpoint.expectedHeaderReceived("foo", "bar"); + resultEndpoint.setResultWaitTime(1); // speedup test + resultEndpoint.assertIsNotSatisfied(); + } + + @Override + protected RouteBuilder createRouteBuilder() { + return new RouteBuilder() { + public void configure() { + from("direct:start").filter(header("foo").isEqualTo("bar")).to("mock:result"); + } + }; + } +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/MyProduceBean.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/MyProduceBean.java new file mode 100644 index 000000000000..a729263cbf13 --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/MyProduceBean.java @@ -0,0 +1,32 @@ +/* + * 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.apachencamel.quarkus.test.junit5.patterns; + +import org.apache.camel.Produce; + +/** + * + */ +public class MyProduceBean { + + @Produce("mock:result") + MySender sender; + + public void doSomething(String body) { + sender.send(body); + } +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/MySender.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/MySender.java new file mode 100644 index 000000000000..604e6d63f5b0 --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/MySender.java @@ -0,0 +1,25 @@ +/* + * 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.apachencamel.quarkus.test.junit5.patterns; + +/** + * + */ +public interface MySender { + + void send(String body); +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/ProduceBeanTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/ProduceBeanTest.java new file mode 100644 index 000000000000..7781e86c345a --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/ProduceBeanTest.java @@ -0,0 +1,45 @@ +/* + * 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.apachencamel.quarkus.test.junit5.patterns; + +import io.quarkus.test.junit.QuarkusTest; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.Test; + +@QuarkusTest +public class ProduceBeanTest extends CamelQuarkusTestSupport { + + @Test + public void testProduceBean() throws Exception { + getMockEndpoint("mock:result").expectedMessageCount(1); + + template.sendBody("direct:start", "Hello World"); + + assertMockEndpointsSatisfied(); + } + + @Override + protected RouteBuilder createRouteBuilder() { + return new RouteBuilder() { + @Override + public void configure() { + from("direct:start").bean(MyProduceBean.class, "doSomething"); + } + }; + } +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/RouteBuilderConfigureExceptionTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/RouteBuilderConfigureExceptionTest.java new file mode 100644 index 000000000000..3295559d5fa0 --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/RouteBuilderConfigureExceptionTest.java @@ -0,0 +1,56 @@ +/* + * 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.apachencamel.quarkus.test.junit5.patterns; + +import io.quarkus.test.junit.QuarkusTest; +import org.apache.camel.Predicate; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.fail; + +@QuarkusTest +public class RouteBuilderConfigureExceptionTest extends CamelQuarkusTestSupport { + + private Predicate iAmNull; + + @Override + @BeforeEach + public void setUp() { + try { + super.setUp(); + fail("Should have thrown exception"); + } catch (Exception e) { + // expected + } + } + + @Test + public void testFoo() { + } + + @Override + protected RouteBuilder createRouteBuilder() { + return new RouteBuilder() { + public void configure() { + from("direct:start").choice().when(iAmNull).to("mock:dead"); + } + }; + } +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/RouteProcessorDumpRouteCoverageTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/RouteProcessorDumpRouteCoverageTest.java new file mode 100644 index 000000000000..870f4452c2bd --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/RouteProcessorDumpRouteCoverageTest.java @@ -0,0 +1,74 @@ +/* + * 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.apachencamel.quarkus.test.junit5.patterns; + +import io.quarkus.test.junit.QuarkusTest; +import io.quarkus.test.junit.TestProfile; +import org.apache.camel.RoutesBuilder; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; +import org.junit.jupiter.api.TestReporter; + +import static org.apache.camel.test.junit5.TestSupport.assertFileExists; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +@QuarkusTest +@TestProfile(RouteProcessorDumpRouteCoverageTest.class) +public class RouteProcessorDumpRouteCoverageTest extends CamelQuarkusTestSupport { + + @Override + public boolean isDumpRouteCoverage() { + return true; + } + + @Test + public void testProcessorJunit5() { + String out = template.requestBody("direct:start", "Hello World", String.class); + assertEquals("Bye World", out); + } + + @Test + public void testProcessorJunit5WithTestParameterInjection(TestInfo info, TestReporter testReporter) { + assertNotNull(info); + assertNotNull(testReporter); + String out = template.requestBody("direct:start", "Hello World", String.class); + assertEquals("Bye World", out); + } + + @AfterAll + public static void checkDumpFilesCreatedAfterTests() { + // should create that file when test is done + assertFileExists("target/camel-route-coverage/RouteProcessorDumpRouteCoverageTest-testProcessorJunit5.xml"); + assertFileExists( + "target/camel-route-coverage/RouteProcessorDumpRouteCoverageTest-testProcessorJunit5WithTestParameterInjection.xml"); + } + + @Override + protected RoutesBuilder createRouteBuilder() { + return new RouteBuilder() { + @Override + public void configure() { + from("direct:start").process(exchange -> exchange.getMessage().setBody("Bye World")); + } + }; + } + +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/SimpleMockEndpointsTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/SimpleMockEndpointsTest.java new file mode 100644 index 000000000000..2965174eb0ac --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/SimpleMockEndpointsTest.java @@ -0,0 +1,57 @@ +/* + * 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.apachencamel.quarkus.test.junit5.patterns; + +import io.quarkus.test.junit.QuarkusTest; +import org.apache.camel.Produce; +import org.apache.camel.ProducerTemplate; +import org.apache.camel.RoutesBuilder; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.Test; + +@QuarkusTest +public class SimpleMockEndpointsTest extends CamelQuarkusTestSupport { + + @Produce("direct:start") + protected ProducerTemplate template; + + @Override + public String isMockEndpointsAndSkip() { + return "seda:queue"; + } + + @Test + public void testMockAndSkip() throws Exception { + getMockEndpoint("mock:seda:queue").expectedBodiesReceived("Bye Camel"); + + template.sendBody("seda:start", "Camel"); + + assertMockEndpointsSatisfied(); + } + + @Override + protected RoutesBuilder createRouteBuilder() { + return new RouteBuilder() { + @Override + public void configure() { + from("seda:start").transform(simple("Bye ${body}")).to("seda:queue"); + } + }; + } + +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/SimpleNotifyBuilderTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/SimpleNotifyBuilderTest.java new file mode 100644 index 000000000000..e3ba4109dfac --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/SimpleNotifyBuilderTest.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.apachencamel.quarkus.test.junit5.patterns; + +import java.util.concurrent.TimeUnit; + +import io.quarkus.test.junit.QuarkusTest; +import org.apache.camel.RoutesBuilder; +import org.apache.camel.builder.NotifyBuilder; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertTrue; + +@QuarkusTest +public class SimpleNotifyBuilderTest extends CamelQuarkusTestSupport { + + @Test + public void testNotifyBuilder() { + NotifyBuilder notify = new NotifyBuilder(context).from("seda:start").wereSentTo("seda:queue").whenDone(10).create(); + + for (int i = 0; i < 10; i++) { + template.sendBody("seda:start", "Camel" + i); + } + + boolean matches = notify.matches(10, TimeUnit.SECONDS); + assertTrue(matches); + } + + @Override + protected RoutesBuilder createRouteBuilder() { + return new RouteBuilder() { + @Override + public void configure() { + from("seda:start").transform(simple("Bye ${body}")).to("seda:queue"); + } + }; + } + +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/SimpleWeaveAddMockLastTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/SimpleWeaveAddMockLastTest.java new file mode 100644 index 000000000000..ad3abaed2ea6 --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/SimpleWeaveAddMockLastTest.java @@ -0,0 +1,65 @@ +/* + * 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.apachencamel.quarkus.test.junit5.patterns; + +import io.quarkus.test.junit.QuarkusTest; +import io.quarkus.test.junit.TestProfile; +import org.apache.camel.RoutesBuilder; +import org.apache.camel.builder.AdviceWith; +import org.apache.camel.builder.AdviceWithRouteBuilder; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.model.Model; +import org.apache.camel.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.Test; + +@QuarkusTest +@TestProfile(SimpleWeaveAddMockLastTest.class) +public class SimpleWeaveAddMockLastTest extends CamelQuarkusTestSupport { + + public boolean isUseAdviceWith() { + return true; + } + + @Test + public void testWeaveAddMockLast() throws Exception { + AdviceWith.adviceWith(context.getExtension(Model.class).getRouteDefinitions().get(0), context, + new AdviceWithRouteBuilder() { + @Override + public void configure() { + weaveAddLast().to("mock:result"); + } + }); + context.start(); + + getMockEndpoint("mock:result").expectedBodiesReceived("Bye Camel"); + + template.sendBody("seda:start", "Camel"); + + assertMockEndpointsSatisfied(); + } + + @Override + protected RoutesBuilder createRouteBuilder() { + return new RouteBuilder() { + @Override + public void configure() { + from("seda:start").transform(simple("Bye ${body}")).to("seda:queue"); + } + }; + } + +} diff --git a/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/UseOverridePropertiesWithPropertiesComponentTest.java b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/UseOverridePropertiesWithPropertiesComponentTest.java new file mode 100644 index 000000000000..10481d64ff0f --- /dev/null +++ b/test-framework/junit5/src/test/java/org/apachencamel/quarkus/test/junit5/patterns/UseOverridePropertiesWithPropertiesComponentTest.java @@ -0,0 +1,79 @@ +/* + * 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.apachencamel.quarkus.test.junit5.patterns; + +import java.util.Properties; + +import io.quarkus.test.junit.QuarkusTest; +import io.quarkus.test.junit.TestProfile; +import org.apache.camel.builder.AdviceWith; +import org.apache.camel.builder.AdviceWithRouteBuilder; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.model.ModelCamelContext; +import org.apache.camel.quarkus.test.CamelQuarkusTestSupport; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +@QuarkusTest +@TestProfile(UseOverridePropertiesWithPropertiesComponentTest.class) +public class UseOverridePropertiesWithPropertiesComponentTest extends CamelQuarkusTestSupport { + + @Override + public boolean isUseAdviceWith() { + return true; + } + + @BeforeEach + public void doSomethingBefore() throws Exception { + AdviceWithRouteBuilder mocker = new AdviceWithRouteBuilder() { + @Override + public void configure() throws Exception { + replaceFromWith("direct:sftp"); + + interceptSendToEndpoint("file:*").skipSendToOriginalEndpoint().to("mock:file"); + } + }; + AdviceWith.adviceWith(this.context.adapt(ModelCamelContext.class).getRouteDefinition("myRoute"), this.context, mocker); + } + + @Override + protected Properties useOverridePropertiesWithPropertiesComponent() { + Properties pc = new Properties(); + pc.put("ftp.username", "scott"); + pc.put("ftp.password", "tiger"); + return pc; + } + + @Test + public void testOverride() throws Exception { + getMockEndpoint("mock:file").expectedMessageCount(1); + + template.sendBody("direct:sftp", "Hello World"); + + assertMockEndpointsSatisfied(); + } + + @Override + protected RouteBuilder createRouteBuilder() { + return new RouteBuilder() { + public void configure() { + from("ftp:somepath?username={{ftp.username}}&password={{ftp.password}}").routeId("myRoute") + .to("file:target/out"); + } + }; + } +} diff --git a/test-framework/pom.xml b/test-framework/pom.xml new file mode 100644 index 000000000000..4f2b2c92e23a --- /dev/null +++ b/test-framework/pom.xml @@ -0,0 +1,68 @@ + + + + + 4.0.0 + + org.apache.camel.quarkus + camel-quarkus-build-parent + 2.11.0-SNAPSHOT + ../poms/build-parent/pom.xml + + + camel-quarkus-test-framework + pom + + Camel Quarkus :: Test Framework :: Parent + Ancillary modules required by some tests. Hosted outside the integration-tests directory + so that we can keep a flat hierarchy in the integration-tests directory. + + + + junit5 + + + + + + io.quarkus + quarkus-bom + ${quarkus.version} + pom + import + + + org.apache.camel.quarkus + camel-quarkus-bom + ${project.version} + pom + import + + + org.apache.camel.quarkus + camel-quarkus-bom-test + ${project.version} + pom + import + + + + +