This is an automated email from the ASF dual-hosted git repository.

christophd pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git

commit ae70f2fa99f729e449bfaeeaac1e37f8764ba7c1
Author: Christoph Deppisch <[email protected]>
AuthorDate: Fri Nov 13 15:30:23 2026 +0100

    CAMEL-26918: camel-jbang - TestPluginExporter uses Citrus CodeAnalyzer for 
dependency detection
    
    Uses the Citrus DelegatingCodeAnalyzer to scan test sources (YAML,
    XML, Groovy) and auto-detect required Citrus modules and Camel
    test-infra dependencies from the Citrus catalog.
    
    Co-Authored-By: Claude Opus 4.6 <[email protected]>
---
 .../core/commands/test/TestPluginExporter.java     |  92 ++++++++++---
 .../jbang/core/commands/test/TestPluginTest.java   | 143 ++++++++++++++++++++-
 2 files changed, 216 insertions(+), 19 deletions(-)

diff --git 
a/dsl/camel-jbang/camel-jbang-plugin-test/src/main/java/org/apache/camel/dsl/jbang/core/commands/test/TestPluginExporter.java
 
b/dsl/camel-jbang/camel-jbang-plugin-test/src/main/java/org/apache/camel/dsl/jbang/core/commands/test/TestPluginExporter.java
index 46ab4e856394..609b9cef63ae 100644
--- 
a/dsl/camel-jbang/camel-jbang-plugin-test/src/main/java/org/apache/camel/dsl/jbang/core/commands/test/TestPluginExporter.java
+++ 
b/dsl/camel-jbang/camel-jbang-plugin-test/src/main/java/org/apache/camel/dsl/jbang/core/commands/test/TestPluginExporter.java
@@ -41,6 +41,8 @@ import org.apache.camel.util.IOHelper;
 import org.apache.camel.util.StringHelper;
 import org.citrusframework.CitrusSettings;
 import org.citrusframework.CitrusVersion;
+import org.citrusframework.jbang.cli.util.CodeAnalyzer;
+import org.citrusframework.jbang.cli.util.DelegatingCodeAnalyzer;
 import org.citrusframework.util.FileUtils;
 
 /**
@@ -79,18 +81,19 @@ public class TestPluginExporter implements PluginExporter {
         }
 
         // add default Citrus dependencies as defined in Citrus JBang
-        deps.add(asDependency("citrus-base"));
-        deps.add(asDependency("citrus-junit-jupiter"));
-        deps.add(asDependency("citrus-http"));
-        deps.add(asDependency("citrus-yaml"));
-        deps.add(asDependency("citrus-xml"));
-        deps.add(asDependency("citrus-groovy"));
-        deps.add(asDependency("citrus-validation-text"));
-        deps.add(asDependency("citrus-validation-xml"));
-        deps.add(asDependency("citrus-validation-json"));
-        deps.add(asDependency("citrus-validation-yaml"));
+        deps.add(asCitrusDependency("citrus-base"));
+        deps.add(asCitrusDependency("citrus-junit-jupiter"));
+        deps.add(asCitrusDependency("citrus-yaml"));
+        deps.add(asCitrusDependency("citrus-xml"));
+        deps.add(asCitrusDependency("citrus-groovy"));
+        deps.add(asCitrusDependency("citrus-validation-text"));
+        deps.add(asCitrusDependency("citrus-validation-xml"));
+        deps.add(asCitrusDependency("citrus-validation-json"));
+        deps.add(asCitrusDependency("citrus-validation-yaml"));
 
         Path testDir = Path.of(".").resolve("test");
+        deps.addAll(detectDependenciesFromTestSources(testDir));
+
         if (Files.exists(testDir.resolve("jbang.properties"))) {
             try (FileInputStream fis = new 
FileInputStream(testDir.resolve("jbang.properties").toFile())) {
                 Properties props = new Properties();
@@ -104,14 +107,14 @@ public class TestPluginExporter implements PluginExporter 
{
                     }
                     if (dependency.startsWith("org.citrusframework:")) {
                         // construct proper Citrus Maven GAV from just the 
artifact id
-                        deps.add(asDependency(extractArtifactId(dependency)));
+                        
deps.add(asCitrusDependency(extractArtifactId(dependency)));
                     } else if (dependency.startsWith("org.apache.camel")) {
                         // remove version from GAV, because we generally use 
the Camel bom
                         String[] parts = dependency.split(":");
-                        deps.add("mvn@test:%s:%s".formatted(parts[0], 
parts[1]));
+                        deps.add(asDependency(parts[0], parts[1]));
                     } else {
                         // add as test scoped dependency
-                        deps.add("mvn@test:" + dependency);
+                        deps.add(asDependency(dependency));
                     }
                 }
             } catch (IOException e) {
@@ -194,6 +197,53 @@ public class TestPluginExporter implements PluginExporter {
 
     }
 
+    /**
+     * Scans Citrus test files in the given directory using the Citrus code 
analyzer to detect required modules and
+     * dependencies. Supports YAML, XML and Groovy test sources.
+     */
+    private Set<String> detectDependenciesFromTestSources(Path testDir) {
+        Set<String> deps = new HashSet<>();
+        DelegatingCodeAnalyzer analyzer = new DelegatingCodeAnalyzer();
+        try (Stream<Path> paths = Files.list(testDir)) {
+            paths.filter(p -> !p.getFileName().toString().startsWith("."))
+                    .filter(p -> {
+                        String ext = 
FileUtils.getFileExtension(p.getFileName().toString());
+                        return CitrusSettings.getTestFileNamePattern(ext)
+                                .stream()
+                                .map(Pattern::compile)
+                                .anyMatch(pattern -> 
pattern.matcher(p.getFileName().toString()).matches());
+                    })
+                    .forEach(path -> {
+                        try {
+                            CodeAnalyzer.ScanResult result = 
analyzer.scan(path);
+                            for (String module : result.modules()) {
+                                deps.add(asCitrusDependency(module));
+                            }
+                            for (String dependency : result.dependencies()) {
+                                deps.add(asScannedDependency(dependency));
+                            }
+                        } catch (Exception e) {
+                            // ignore scan errors for unsupported file types 
or missing catalog
+                        }
+                    });
+        } catch (IOException e) {
+            // ignore if test directory cannot be listed
+        }
+
+        return deps;
+    }
+
+    private String asScannedDependency(String dependency) {
+        String[] parts = dependency.split(":");
+        if (parts[0].equals("org.citrusframework")) {
+            return asCitrusDependency(parts[1]);
+        } else if (parts[0].startsWith("org.apache.camel")) {
+            return asDependency(parts[0], parts[1]);
+        } else {
+            return asDependency(dependency);
+        }
+    }
+
     /**
      * Read and process given test source. Apply common postprocessing steps 
on test source code. For instance makes
      * sure that relative file paths get replaced with proper classpath 
resource paths.
@@ -241,7 +291,19 @@ public class TestPluginExporter implements PluginExporter {
         return dependency.split(":")[1];
     }
 
-    private String asDependency(String artifactName) {
-        return 
"mvn@test:org.citrusframework:%s:${citrus.version}".formatted(artifactName);
+    private String asCitrusDependency(String artifactName) {
+        return asDependency("org.citrusframework", artifactName, 
"${citrus.version}");
+    }
+
+    private String asDependency(String gav) {
+        return "mvn@test:%s".formatted(gav);
+    }
+
+    private String asDependency(String groupId, String artifactName) {
+        return "mvn@test:%s:%s".formatted(groupId, artifactName);
+    }
+
+    private String asDependency(String groupId, String artifactName, String 
version) {
+        return "mvn@test:%s:%s:%s".formatted(groupId, artifactName, version);
     }
 }
diff --git 
a/dsl/camel-jbang/camel-jbang-plugin-test/src/test/java/org/apache/camel/dsl/jbang/core/commands/test/TestPluginTest.java
 
b/dsl/camel-jbang/camel-jbang-plugin-test/src/test/java/org/apache/camel/dsl/jbang/core/commands/test/TestPluginTest.java
index 211de06d226d..c248f1d0b1d0 100644
--- 
a/dsl/camel-jbang/camel-jbang-plugin-test/src/test/java/org/apache/camel/dsl/jbang/core/commands/test/TestPluginTest.java
+++ 
b/dsl/camel-jbang/camel-jbang-plugin-test/src/test/java/org/apache/camel/dsl/jbang/core/commands/test/TestPluginTest.java
@@ -131,6 +131,37 @@ class TestPluginTest {
                 """.trim(), printer.getOutput().trim());
     }
 
+    @Test
+    public void shouldAlwaysIncludeDefaultDependencies() throws IOException {
+        Path testDir = Path.of(".").resolve("test");
+        Files.createDirectories(testDir);
+        try {
+            TestPluginExporter exporter = new TestPluginExporter();
+            Set<String> deps = exporter.getDependencies(RuntimeType.quarkus);
+
+            
Assertions.assertTrue(deps.contains("mvn@test:org.citrusframework:citrus-base:${citrus.version}"),
+                    "Should always include citrus-base as default dependency");
+            
Assertions.assertTrue(deps.contains("mvn@test:org.citrusframework:citrus-junit-jupiter:${citrus.version}"),
+                    "Should always include citrus-junit-jupiter as default 
dependency");
+            
Assertions.assertTrue(deps.contains("mvn@test:org.citrusframework:citrus-yaml:${citrus.version}"),
+                    "Should always include citrus-yaml as default dependency");
+            
Assertions.assertTrue(deps.contains("mvn@test:org.citrusframework:citrus-xml:${citrus.version}"),
+                    "Should always include citrus-xml as default dependency");
+            
Assertions.assertTrue(deps.contains("mvn@test:org.citrusframework:citrus-groovy:${citrus.version}"),
+                    "Should always include citrus-groovy as default 
dependency");
+            
Assertions.assertTrue(deps.contains("mvn@test:org.citrusframework:citrus-validation-text:${citrus.version}"),
+                    "Should always include citrus-validation-text as default 
dependency");
+            
Assertions.assertTrue(deps.contains("mvn@test:org.citrusframework:citrus-validation-xml:${citrus.version}"),
+                    "Should always include citrus-validation-xml as default 
dependency");
+            
Assertions.assertTrue(deps.contains("mvn@test:org.citrusframework:citrus-validation-json:${citrus.version}"),
+                    "Should always include citrus-validation-json as default 
dependency");
+            
Assertions.assertTrue(deps.contains("mvn@test:org.citrusframework:citrus-validation-yaml:${citrus.version}"),
+                    "Should always include citrus-validation-yaml as default 
dependency");
+        } finally {
+            Files.deleteIfExists(testDir);
+        }
+    }
+
     @Test
     public void shouldProduceValidMavenPropertyReferences() throws IOException 
{
         Path testDir = Path.of(".").resolve("test");
@@ -144,16 +175,120 @@ class TestPluginTest {
             
Assertions.assertFalse(deps.contains("mvn@test:org.citrusframework:citrus-junit5:${citrus.version}"),
                     "Should not include legacy citrus-junit5 dependency");
             for (String dep : deps) {
-                Assertions.assertFalse(dep.contains("\\"),
-                        "Dependency should not contain backslash escapes: " + 
dep);
-                Assertions.assertTrue(dep.contains("${citrus.version}"),
-                        "Dependency should contain valid Maven property 
reference: " + dep);
+                if (dep.contains("org.citrusframework")) {
+                    Assertions.assertFalse(dep.contains("\\"),
+                            "Dependency should not contain backslash escapes: 
" + dep);
+                    Assertions.assertTrue(dep.contains("${citrus.version}"),
+                            "Dependency should contain valid Maven property 
reference: " + dep);
+                }
             }
         } finally {
             Files.deleteIfExists(testDir);
         }
     }
 
+    @Test
+    public void shouldDetectDependenciesFromYamlTestSources() throws 
IOException {
+        Path testDir = Path.of(".").resolve("test");
+        Files.createDirectories(testDir);
+        Path yamlFile = testDir.resolve("my-test.citrus.it.yaml");
+        try {
+            Files.writeString(yamlFile, """
+                    name: my-test
+                    actions:
+                      - sql:
+                          datasource: "myDataSource"
+                      - send:
+                          endpoint: "kafka:myTopic"
+                      - echo:
+                          message: "Hello"
+                    """);
+
+            TestPluginExporter exporter = new TestPluginExporter();
+            Set<String> deps = exporter.getDependencies(RuntimeType.quarkus);
+
+            
Assertions.assertTrue(deps.contains("mvn@test:org.citrusframework:citrus-sql:${citrus.version}"),
+                    "Should auto-detect citrus-sql from sql action");
+            
Assertions.assertTrue(deps.contains("mvn@test:org.citrusframework:citrus-kafka:${citrus.version}"),
+                    "Should auto-detect citrus-kafka from kafka endpoint");
+
+            
Assertions.assertTrue(deps.contains("mvn@test:org.citrusframework:citrus-base:${citrus.version}"),
+                    "Should still include default citrus-base dependency");
+            
Assertions.assertTrue(deps.contains("mvn@test:org.citrusframework:citrus-junit-jupiter:${citrus.version}"),
+                    "Should still include default citrus-junit-jupiter 
dependency");
+        } finally {
+            Files.deleteIfExists(yamlFile);
+            Files.deleteIfExists(testDir);
+        }
+    }
+
+    @Test
+    public void shouldNotAddExtraDepsWithoutMatchingActions() throws 
IOException {
+        Path testDir = Path.of(".").resolve("test");
+        Files.createDirectories(testDir);
+        Path yamlFile = testDir.resolve("simple.citrus.it.yaml");
+        try {
+            Files.writeString(yamlFile, """
+                    name: simple-test
+                    actions:
+                      - echo:
+                          message: "Hello"
+                    """);
+
+            TestPluginExporter exporter = new TestPluginExporter();
+            Set<String> deps = exporter.getDependencies(RuntimeType.quarkus);
+
+            
Assertions.assertTrue(deps.contains("mvn@test:org.citrusframework:citrus-base:${citrus.version}"),
+                    "Should still include default citrus-base dependency");
+            
Assertions.assertTrue(deps.contains("mvn@test:org.citrusframework:citrus-junit-jupiter:${citrus.version}"),
+                    "Should still include default citrus-junit-jupiter 
dependency");
+            
Assertions.assertFalse(deps.contains("mvn@test:org.citrusframework:citrus-kafka:${citrus.version}"),
+                    "Should not include citrus-kafka when no kafka endpoint is 
used");
+            
Assertions.assertFalse(deps.contains("mvn@test:org.citrusframework:citrus-sql:${citrus.version}"),
+                    "Should not include citrus-sql when no sql action is 
used");
+        } finally {
+            Files.deleteIfExists(yamlFile);
+            Files.deleteIfExists(testDir);
+        }
+    }
+
+    @Test
+    public void shouldDetectDependenciesFromMultipleYamlFiles() throws 
IOException {
+        Path testDir = Path.of(".").resolve("test");
+        Files.createDirectories(testDir);
+        Path sqlTest = testDir.resolve("sql-test.citrus.it.yaml");
+        Path kafkaTest = testDir.resolve("kafka-test.citrus.yaml");
+        try {
+            Files.writeString(sqlTest, """
+                    name: sql-test
+                    actions:
+                      - sql:
+                          datasource: "myDataSource"
+                    """);
+            Files.writeString(kafkaTest, """
+                    name: kafka-test
+                    endpoints:
+                      - kafka:
+                          topic: "myTopic"
+                    actions:
+                      - echo:
+                          message: "Hello"
+                    """);
+
+            TestPluginExporter exporter = new TestPluginExporter();
+            Set<String> deps = exporter.getDependencies(RuntimeType.quarkus);
+
+            
Assertions.assertTrue(deps.contains("mvn@test:org.citrusframework:citrus-sql:${citrus.version}"),
+                    "Should detect citrus-sql from first YAML file");
+            
Assertions.assertTrue(deps.contains("mvn@test:org.citrusframework:citrus-kafka:${citrus.version}"),
+                    "Should detect citrus-kafka from second YAML file");
+        } finally {
+            Files.deleteIfExists(sqlTest);
+            Files.deleteIfExists(kafkaTest);
+            Files.deleteIfExists(testDir);
+        }
+    }
+
     /**
      * Creates CamelJBangMain instance ready for unit testing. Automatically 
adds test plugin commands. Automatically
      * sets the out printer.

Reply via email to