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

luigidemasi pushed a commit to branch camel-4.18.x
in repository https://gitbox.apache.org/repos/asf/camel.git

commit f7735e7efc3d67dd96b6eeba4f3b84eb890af02b
Author: Luigi De Masi <[email protected]>
AuthorDate: Sat Nov 14 10:29:17 2026 +0100

    [backport camel-4.22.x] CAMEL-26926: Keep runtime catalogs on the selected 
Camel version (#29905)
    
    * CAMEL-26926: Keep runtime catalogs on the selected Camel version
    
    Co-authored-by: Codex <[email protected]>
    Signed-off-by: Luigi De Masi <[email protected]>
    (cherry picked from commit 6604df2a95a08b1634dcab39b6bcb0ebb3ab4c08)
    Signed-off-by: Luigi De Masi <[email protected]>
    
    * CAMEL-26926: Address catalog loading review feedback
    
    Reject absent and blank BOM catalog versions with actionable errors.
    Cover Spring Boot export versions and retain explicit core overrides.
    Document the retained fallback and isolate tests from global properties.
    
    Co-authored-by: Codex <[email protected]>
    Signed-off-by: Luigi De Masi <[email protected]>
    (cherry picked from commit b7d3bd2a5b336cc01dc75bae1c9de8d0ff75fe1f)
    Signed-off-by: Luigi De Masi <[email protected]>
    
    ---------
    
    Signed-off-by: Luigi De Masi <[email protected]>
    Co-authored-by: Codex <[email protected]>
    (cherry picked from commit 5949ac542efd0ecd2ad8c7f7bc7abaf5d4c6dbc9)
    Signed-off-by: Luigi De Masi <[email protected]>
---
 .../camel/dsl/jbang/core/common/CatalogLoader.java | 163 +++++++++++---------
 .../camel/dsl/jbang/core/commands/ExportTest.java  |  31 ++++
 .../jbang/core/common/CatalogLoaderBomTest.java    |  81 ++++++++++
 .../dsl/jbang/core/common/CatalogLoaderTest.java   | 167 +++++++++++++++++++++
 .../jbang/core/commands/mcp/CatalogToolsTest.java  |  51 +++++++
 5 files changed, 420 insertions(+), 73 deletions(-)

diff --git 
a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/common/CatalogLoader.java
 
b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/common/CatalogLoader.java
index d7c91fb88563..e3cfe96ed977 100644
--- 
a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/common/CatalogLoader.java
+++ 
b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/common/CatalogLoader.java
@@ -20,12 +20,14 @@ import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.List;
+import java.util.function.Function;
 
 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
 
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;
+import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;
 
 import org.apache.camel.catalog.CamelCatalog;
@@ -37,11 +39,11 @@ import org.apache.camel.main.download.DownloadException;
 import org.apache.camel.main.download.MavenDependencyDownloader;
 import org.apache.camel.support.ObjectHelper;
 import org.apache.camel.tooling.maven.MavenArtifact;
+import org.apache.camel.tooling.maven.MavenGav;
 
 public final class CatalogLoader {
 
     public static final String QUARKUS_GROUP_ID = "io.quarkus.platform";
-    private static final String DEFAULT_CAMEL_CATALOG = 
"org.apache.camel.catalog.DefaultCamelCatalog";
 
     private static final String SPRING_BOOT_CATALOG_PROVIDER = 
"org.apache.camel.springboot.catalog.SpringBootRuntimeProvider";
 
@@ -73,15 +75,8 @@ public final class CatalogLoader {
                 throw new IOException("Cannot download 
org.apache.camel:camel-catalog:" + version);
             }
 
-            // re-create answer with the classloader to be able to load 
resources in this catalog
-            Class<RuntimeProvider> clazz = (Class<RuntimeProvider>) 
cl.loadClass(DEFAULT_CAMEL_CATALOG);
-            if (clazz != null) {
-                answer.setVersionManager(new 
DownloadCatalogVersionManager(version, cl));
-                RuntimeProvider provider = ObjectHelper.newInstance(clazz);
-                if (provider != null) {
-                    answer.setRuntimeProvider(provider);
-                }
-            }
+            // Keep the running catalog API and use the downloaded artifact 
only for resources.
+            answer.setVersionManager(new 
DownloadCatalogVersionManager(version, cl));
             answer.enableCache();
         } finally {
             downloader.stop();
@@ -98,6 +93,8 @@ public final class CatalogLoader {
         }
 
         DependencyDownloaderClassLoader cl = new 
DependencyDownloaderClassLoader(CatalogLoader.class.getClassLoader());
+        // Provider classes share the running catalog API; resources must come 
only from the selected artifacts.
+        DependencyDownloaderClassLoader resources = new 
DependencyDownloaderClassLoader(null);
         MavenDependencyDownloader downloader = new MavenDependencyDownloader();
         downloader.setClassLoader(cl);
         downloader.setRepositories(repos);
@@ -115,33 +112,30 @@ public final class CatalogLoader {
                 ma = downloader.downloadArtifact("org.apache.camel", 
"camel-catalog", camelCatalogVersion);
             }
             if (ma != null) {
-                cl.addFile(ma.getFile());
+                resources.addFile(ma.getFile());
             } else {
                 throw new IOException("Cannot download 
org.apache.camel:camel-catalog:" + camelCatalogVersion);
             }
 
             final String camelVersion = version;
-            ma = downloader.downloadArtifact("org.apache.camel.springboot", 
"camel-catalog-provider-springboot",
-                    
PropertyResolver.fromSystemProperty(CamelJBangConstants.CAMEL_SPRING_BOOT_VERSION,
 () -> camelVersion));
+            final String sbVersion = PropertyResolver.fromSystemProperty(
+                    CamelJBangConstants.CAMEL_SPRING_BOOT_VERSION, () -> 
camelVersion);
+            ma = downloader.downloadArtifact("org.apache.camel.springboot", 
"camel-catalog-provider-springboot", sbVersion);
             if (ma != null) {
                 cl.addFile(ma.getFile());
+                resources.addFile(ma.getFile());
             } else {
                 throw new IOException(
-                        "Cannot download 
org.apache.camel.springboot:camel-catalog-provider-springboot:" + version);
+                        "Cannot download 
org.apache.camel.springboot:camel-catalog-provider-springboot:" + sbVersion);
             }
 
             Class<RuntimeProvider> clazz = (Class<RuntimeProvider>) 
cl.loadClass(SPRING_BOOT_CATALOG_PROVIDER);
             if (clazz != null) {
-                Class<CamelCatalog> clazz2 = (Class<CamelCatalog>) 
cl.loadClass(DEFAULT_CAMEL_CATALOG);
-                if (clazz2 != null) {
-                    answer = ObjectHelper.newInstance(clazz2);
-                }
                 RuntimeProvider provider = ObjectHelper.newInstance(clazz);
                 if (provider != null) {
                     answer.setRuntimeProvider(provider);
                 }
-                // use classloader that loaded spring-boot provider to ensure 
we can load its resources
-                answer.getVersionManager().setClassLoader(cl);
+                answer.setVersionManager(new 
DownloadCatalogVersionManager(camelCatalogVersion, sbVersion, resources));
             }
             answer.enableCache();
         } finally {
@@ -154,11 +148,8 @@ public final class CatalogLoader {
 
     public static CamelCatalog loadQuarkusCatalog(String repos, String 
quarkusVersion, String quarkusGroupId, boolean download)
             throws Exception {
-        String camelQuarkusVersion = null;
-        CamelCatalog answer = new DefaultCamelCatalog();
-
         if (quarkusVersion == null) {
-            return answer;
+            return new DefaultCamelCatalog();
         }
         // quarkus 3.2.x and older must have .Final
         boolean finalSuffix = VersionHelper.isLE(quarkusVersion, "3.2.0");
@@ -173,63 +164,83 @@ public final class CatalogLoader {
         downloader.setDownload(download);
         try {
             downloader.start();
-
-            // shrinkwrap does not return POM file as result (they are 
hardcoded to be filtered out)
-            // so after this we download a JAR and then use its File location 
to compute the file for the downloaded POM
             if (quarkusGroupId == null) {
                 quarkusGroupId = QUARKUS_GROUP_ID;
             }
-            MavenArtifact ma = downloader.downloadArtifact(quarkusGroupId, 
"quarkus-camel-bom:pom", quarkusVersion);
-            if (ma != null && ma.getFile() != null) {
-                String name = ma.getFile().getAbsolutePath();
-                File file = new File(name);
-                if (file.exists()) {
-                    DocumentBuilderFactory dbf = 
XmlHelper.createDocumentBuilderFactory();
-                    DocumentBuilder db = dbf.newDocumentBuilder();
-                    Document dom = db.parse(file);
-
-                    // grab what exact camelVersion and camelQuarkusVersion we 
are using
-                    NodeList nl = dom.getElementsByTagName("dependency");
-                    for (int i = 0; i < nl.getLength(); i++) {
-                        Element node = (Element) nl.item(i);
-                        String g = 
node.getElementsByTagName("groupId").item(0).getTextContent();
-                        String a = 
node.getElementsByTagName("artifactId").item(0).getTextContent();
-                        if ("org.apache.camel.quarkus".equals(g) && 
"camel-quarkus-catalog".equals(a)) {
-                            camelQuarkusVersion = 
node.getElementsByTagName("version").item(0).getTextContent();
-                        }
-                    }
-                }
-            }
+            MavenGav bom = MavenGav.fromCoordinates(quarkusGroupId, 
"quarkus-camel-bom", quarkusVersion, "pom", null);
+            return loadQuarkusCatalog(bom, gav -> downloader.downloadArtifact(
+                    gav.getGroupId(), gav.getArtifactId() + 
("pom".equals(gav.getPackaging()) ? ":pom" : ""),
+                    gav.getVersion()));
+        } finally {
+            downloader.stop();
+            downloader.close();
+        }
+    }
 
-            if (camelQuarkusVersion != null) {
-                // download camel-quarkus-catalog we use to know if we have an 
extension or not
-                List<MavenArtifact> artifacts = 
downloader.downloadArtifacts("org.apache.camel.quarkus",
-                        "camel-quarkus-catalog", camelQuarkusVersion, true);
-                if (artifacts != null) {
-                    // this will add to classpath
-                    downloader.downloadDependency("org.apache.camel.quarkus", 
"camel-quarkus-catalog", camelQuarkusVersion);
-
-                    Class<RuntimeProvider> clazz = (Class<RuntimeProvider>) 
cl.loadClass(QUARKUS_CATALOG_PROVIDER);
-                    if (clazz != null) {
-                        Class<CamelCatalog> clazz2 = (Class<CamelCatalog>) 
cl.loadClass(DEFAULT_CAMEL_CATALOG);
-                        if (clazz2 != null) {
-                            answer = ObjectHelper.newInstance(clazz2);
-                        }
-                        RuntimeProvider provider = 
ObjectHelper.newInstance(clazz);
-                        if (provider != null) {
-                            answer.setRuntimeProvider(provider);
-                        }
-                        // use classloader that loaded quarkus provider to 
ensure we can load its resources
-                        answer.getVersionManager().setClassLoader(cl);
+    static CamelCatalog loadQuarkusCatalog(MavenGav quarkusCamelBom, 
Function<MavenGav, MavenArtifact> downloader)
+            throws Exception {
+        String camelQuarkusVersion = null;
+        String camelVersion = null;
+        CamelCatalog answer = new DefaultCamelCatalog();
+
+        // shrinkwrap does not return POM file as result (they are hardcoded 
to be filtered out)
+        // so after this we download a JAR and then use its File location to 
compute the file for the downloaded POM
+        MavenArtifact ma = downloader.apply(quarkusCamelBom);
+        if (ma != null && ma.getFile() != null) {
+            String name = ma.getFile().getAbsolutePath();
+            File file = new File(name);
+            if (file.exists()) {
+                DocumentBuilderFactory dbf = 
XmlHelper.createDocumentBuilderFactory();
+                DocumentBuilder db = dbf.newDocumentBuilder();
+                Document dom = db.parse(file);
+
+                // grab what exact camelVersion and camelQuarkusVersion we are 
using
+                NodeList nl = dom.getElementsByTagName("dependency");
+                for (int i = 0; i < nl.getLength(); i++) {
+                    Element node = (Element) nl.item(i);
+                    String g = 
node.getElementsByTagName("groupId").item(0).getTextContent();
+                    String a = 
node.getElementsByTagName("artifactId").item(0).getTextContent();
+                    if ("org.apache.camel.quarkus".equals(g) && 
"camel-quarkus-catalog".equals(a)) {
+                        Node version = 
node.getElementsByTagName("version").item(0);
+                        camelQuarkusVersion = version != null ? 
version.getTextContent().trim() : null;
+                    } else if ("org.apache.camel".equals(g) && 
"camel-catalog".equals(a)) {
+                        Node version = 
node.getElementsByTagName("version").item(0);
+                        camelVersion = version != null ? 
version.getTextContent().trim() : null;
                     }
                 }
             }
-            answer.enableCache();
-        } finally {
-            downloader.stop();
-            downloader.close();
         }
 
+        if (camelQuarkusVersion == null || camelQuarkusVersion.isEmpty() || 
camelVersion == null || camelVersion.isEmpty()) {
+            throw new IOException(
+                    "Cannot determine Camel and Camel Quarkus catalog versions 
from " + quarkusCamelBom
+                                  + "; expected org.apache.camel:camel-catalog 
and org.apache.camel.quarkus:camel-quarkus-catalog"
+                                  + " dependencies with non-empty versions");
+        }
+
+        // download camel-quarkus-catalog we use to know if we have an 
extension or not
+        MavenArtifact artifact = 
downloader.apply(MavenGav.fromCoordinates("org.apache.camel.quarkus",
+                "camel-quarkus-catalog", camelQuarkusVersion, "jar", null));
+        if (artifact == null || artifact.getFile() == null) {
+            throw new IOException("Cannot download 
org.apache.camel.quarkus:camel-quarkus-catalog:" + camelQuarkusVersion);
+        }
+        DependencyDownloaderClassLoader cl
+                = new 
DependencyDownloaderClassLoader(CatalogLoader.class.getClassLoader());
+        cl.addFile(artifact.getFile());
+        DependencyDownloaderClassLoader resources = new 
DependencyDownloaderClassLoader(null);
+        MavenArtifact coreCatalog
+                = 
downloader.apply(MavenGav.fromCoordinates("org.apache.camel", "camel-catalog", 
camelVersion, "jar", null));
+        if (coreCatalog == null || coreCatalog.getFile() == null) {
+            throw new IOException("Cannot download 
org.apache.camel:camel-catalog:" + camelVersion);
+        }
+        resources.addFile(coreCatalog.getFile());
+        resources.addFile(artifact.getFile());
+        Class<RuntimeProvider> clazz = (Class<RuntimeProvider>) 
cl.loadClass(QUARKUS_CATALOG_PROVIDER);
+        RuntimeProvider provider = ObjectHelper.newInstance(clazz);
+        answer.setRuntimeProvider(provider);
+        answer.setVersionManager(new 
DownloadCatalogVersionManager(camelVersion, camelQuarkusVersion, resources));
+        answer.enableCache();
+
         return answer;
     }
 
@@ -321,9 +332,15 @@ public final class CatalogLoader {
 
         private ClassLoader classLoader;
         private final String version;
+        private final String providerVersion;
 
         public DownloadCatalogVersionManager(String version, ClassLoader 
classLoader) {
+            this(version, version, classLoader);
+        }
+
+        public DownloadCatalogVersionManager(String version, String 
providerVersion, ClassLoader classLoader) {
             this.version = version;
+            this.providerVersion = providerVersion;
             this.classLoader = classLoader;
         }
 
@@ -349,7 +366,7 @@ public final class CatalogLoader {
 
         @Override
         public String getRuntimeProviderLoadedVersion() {
-            return version;
+            return providerVersion;
         }
 
         @Override
diff --git 
a/dsl/camel-jbang/camel-jbang-core/src/test/java/org/apache/camel/dsl/jbang/core/commands/ExportTest.java
 
b/dsl/camel-jbang/camel-jbang-core/src/test/java/org/apache/camel/dsl/jbang/core/commands/ExportTest.java
index 38465f968ef6..feb1231e2851 100644
--- 
a/dsl/camel-jbang/camel-jbang-core/src/test/java/org/apache/camel/dsl/jbang/core/commands/ExportTest.java
+++ 
b/dsl/camel-jbang/camel-jbang-core/src/test/java/org/apache/camel/dsl/jbang/core/commands/ExportTest.java
@@ -21,6 +21,7 @@ import java.io.FileInputStream;
 import java.io.FileReader;
 import java.io.IOException;
 import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Properties;
@@ -28,6 +29,7 @@ import java.util.Scanner;
 import java.util.stream.Stream;
 
 import org.apache.camel.dsl.jbang.core.common.CamelJBangConstants;
+import org.apache.camel.dsl.jbang.core.common.CommandLineHelper;
 import org.apache.camel.dsl.jbang.core.common.HawtioVersion;
 import org.apache.camel.dsl.jbang.core.common.RuntimeType;
 import org.apache.camel.util.FileUtil;
@@ -42,6 +44,8 @@ import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.NullSource;
+import org.junit.jupiter.params.provider.ValueSource;
 import org.junitpioneer.jupiter.SetSystemProperty;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -53,15 +57,19 @@ class ExportTest {
 
     private static final Logger LOG = 
LoggerFactory.getLogger(ExportTest.class);
     private File workingDir;
+    private Path originalHome;
 
     @BeforeEach
     public void setup() throws IOException {
         LOG.info("Preparing ExportTest");
         workingDir = Files.createTempDirectory("camel-export").toFile();
+        originalHome = CommandLineHelper.getHomeDir();
+        CommandLineHelper.useHomeDir(workingDir.toString());
     }
 
     @AfterEach
     public void end() throws IOException {
+        CommandLineHelper.useHomeDir(originalHome.toString());
         // force removing, since deleteOnExit is not removing.
         org.apache.camel.util.FileUtil.removeDir(workingDir);
         // clean up export work dir to prevent ENOENT race with docs gulp 
scanning ../dsl/**
@@ -175,6 +183,29 @@ class ExportTest {
         command.printConfigurationValues("export command");
     }
 
+    @ParameterizedTest
+    @NullSource
+    @ValueSource(strings = "4.10.0")
+    @SetSystemProperty(key = CamelJBangConstants.CAMEL_SPRING_BOOT_VERSION, 
value = "4.8.0")
+    void springBootExportUsesResolvedCoreVersionUnlessExplicit(String 
camelVersion) throws Exception {
+        Export command = createCommand(RuntimeType.springBoot, new String[] { 
"classpath:route.yaml" },
+                "--camel-spring-boot-version=4.8.0", "--dep=camel:util", 
"--dir=" + workingDir, "--quiet");
+        command.camelVersion = camelVersion;
+
+        assertThat(command.doCall()).isZero();
+
+        Model model = readMavenModel();
+        assertThat(model.getDependencies()).anySatisfy(dependency -> {
+            assertThat(dependency.getGroupId()).isEqualTo("org.apache.camel");
+            assertThat(dependency.getArtifactId()).isEqualTo("camel-util");
+            assertThat(dependency.getVersion()).isEqualTo(camelVersion == null 
? "4.8.0" : camelVersion);
+        });
+        
assertThat(model.getDependencyManagement().getDependencies()).anySatisfy(dependency
 -> {
+            
assertThat(dependency.getArtifactId()).isEqualTo("camel-spring-boot-bom");
+            assertThat(dependency.getVersion()).isEqualTo("4.8.0");
+        });
+    }
+
     private Export createCommand(RuntimeType rt, String[] files, String... 
args) {
         Export command = new Export(new CamelJBangMain());
         CommandLine.populateCommand(command, "--gav=examples:route:1.0.0", 
"--dir=" + workingDir, "--quiet",
diff --git 
a/dsl/camel-jbang/camel-jbang-core/src/test/java/org/apache/camel/dsl/jbang/core/common/CatalogLoaderBomTest.java
 
b/dsl/camel-jbang/camel-jbang-core/src/test/java/org/apache/camel/dsl/jbang/core/common/CatalogLoaderBomTest.java
new file mode 100644
index 000000000000..e5dedad46aa1
--- /dev/null
+++ 
b/dsl/camel-jbang/camel-jbang-core/src/test/java/org/apache/camel/dsl/jbang/core/common/CatalogLoaderBomTest.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.apache.camel.dsl.jbang.core.common;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import org.apache.camel.tooling.maven.MavenArtifact;
+import org.apache.camel.tooling.maven.MavenGav;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.NullAndEmptySource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class CatalogLoaderBomTest {
+
+    @ParameterizedTest
+    @NullAndEmptySource
+    @ValueSource(strings = "   ")
+    void rejectsMissingOrBlankCatalogVersions(String version, @TempDir Path 
directory) throws Exception {
+        String versionElement = version == null ? "" : "<version>" + version + 
"</version>";
+        for (boolean core : new boolean[] { true, false }) {
+            Path bom = directory.resolve("bom.pom");
+            Files.writeString(bom,
+                    """
+                            <project><dependencyManagement><dependencies>
+                              
<dependency><groupId>org.apache.camel</groupId><artifactId>camel-catalog</artifactId>%s</dependency>
+                              
<dependency><groupId>org.apache.camel.quarkus</groupId><artifactId>camel-quarkus-catalog</artifactId>%s</dependency>
+                            </dependencies></dependencyManagement></project>
+                            """
+                            .formatted(core ? versionElement : 
"<version>4.8.0</version>",
+                                    core ? "<version>3.15.0</version>" : 
versionElement));
+            MavenGav gav = MavenGav.fromCoordinates("test", "bom", "1", "pom", 
null);
+            assertThatThrownBy(() -> CatalogLoader.loadQuarkusCatalog(gav, 
requested -> {
+                assertThat(requested).as("only the BOM should be 
requested").isEqualTo(gav);
+                return new MavenArtifact(requested, bom.toFile());
+            })).as("invalid %s catalog version: [%s]", core ? "core" : 
"Quarkus", version)
+                    .isInstanceOf(IOException.class)
+                    .hasMessageContaining("Cannot determine Camel and Camel 
Quarkus catalog versions")
+                    .hasMessageContaining(gav.toString())
+                    .hasMessageContaining("org.apache.camel:camel-catalog")
+                    
.hasMessageContaining("org.apache.camel.quarkus:camel-quarkus-catalog");
+        }
+    }
+
+    @Test
+    void quarkusBomWithoutCoreCatalogVersionFails(@TempDir Path directory) 
throws Exception {
+        Path bom = directory.resolve("bom.pom");
+        Files.writeString(bom, """
+                <project><dependencyManagement><dependencies><dependency>
+                  <groupId>org.apache.camel.quarkus</groupId>
+                  
<artifactId>camel-quarkus-catalog</artifactId><version>3.15.0</version>
+                </dependency></dependencies></dependencyManagement></project>
+                """);
+        MavenGav gav = MavenGav.fromCoordinates("test", "bom", "1", "pom", 
null);
+        assertThatThrownBy(() -> CatalogLoader.loadQuarkusCatalog(gav, 
requested -> {
+            assertThat(requested).isEqualTo(gav);
+            return new MavenArtifact(requested, bom.toFile());
+        })).isInstanceOf(IOException.class).hasMessageContaining("Cannot 
determine Camel and Camel Quarkus catalog versions");
+    }
+
+}
diff --git 
a/dsl/camel-jbang/camel-jbang-core/src/test/java/org/apache/camel/dsl/jbang/core/common/CatalogLoaderTest.java
 
b/dsl/camel-jbang/camel-jbang-core/src/test/java/org/apache/camel/dsl/jbang/core/common/CatalogLoaderTest.java
new file mode 100644
index 000000000000..4c67599aa22b
--- /dev/null
+++ 
b/dsl/camel-jbang/camel-jbang-core/src/test/java/org/apache/camel/dsl/jbang/core/common/CatalogLoaderTest.java
@@ -0,0 +1,167 @@
+/*
+ * 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.dsl.jbang.core.common;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.zip.ZipFile;
+
+import org.apache.camel.catalog.CamelCatalog;
+import org.apache.camel.catalog.DefaultCamelCatalog;
+import org.apache.camel.main.download.MavenDependencyDownloader;
+import org.apache.camel.tooling.maven.MavenArtifact;
+import org.apache.camel.tooling.maven.MavenGav;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junitpioneer.jupiter.SetSystemProperty;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+@SetSystemProperty(key = CamelJBangConstants.CAMEL_SPRING_BOOT_VERSION, value 
= "4.8.0")
+class CatalogLoaderTest {
+
+    private static final String CAMEL_VERSION = "4.8.0";
+    private static MavenDependencyDownloader downloader;
+    private static MavenArtifact coreCatalog;
+
+    // These released-artifact comparisons deliberately run in CI to catch 
catalog resource mixing.
+    @BeforeAll
+    static void downloadCatalog() throws Exception {
+        downloader = new MavenDependencyDownloader();
+        downloader.start();
+        coreCatalog = artifact("org.apache.camel", "camel-catalog", 
CAMEL_VERSION);
+    }
+
+    @AfterAll
+    static void closeDownloader() throws Exception {
+        if (downloader != null) {
+            downloader.stop();
+            downloader.close();
+        }
+    }
+
+    @Test
+    void mainCatalogUsesTargetResources() throws Exception {
+        CamelCatalog catalog = CatalogLoader.loadCatalog(null, CAMEL_VERSION, 
true);
+        assertCoreCatalog(catalog);
+        assertProvider(catalog, coreCatalog, "org/apache/camel/catalog", 
"org.apache.camel", "camel-http", CAMEL_VERSION);
+    }
+
+    @Test
+    void springBootCatalogUsesTargetResources() throws Exception {
+        CamelCatalog catalog = CatalogLoader.loadSpringBootCatalog(null, 
CAMEL_VERSION, true);
+        assertCoreCatalog(catalog);
+        assertProvider(catalog, artifact("org.apache.camel.springboot", 
"camel-catalog-provider-springboot", CAMEL_VERSION),
+                "org/apache/camel/springboot/catalog", 
"org.apache.camel.springboot", "camel-http-starter", CAMEL_VERSION);
+        
assertThat(catalog.getRuntimeProviderLoadedVersion()).isEqualTo(CAMEL_VERSION);
+    }
+
+    @Test
+    void quarkusCatalogUsesBomCoreAndProviderVersions() throws Exception {
+        CamelCatalog catalog = CatalogLoader.loadQuarkusCatalog(null, 
"3.15.1", null, true);
+        assertCoreCatalog(catalog);
+        assertProvider(catalog, artifact("org.apache.camel.quarkus", 
"camel-quarkus-catalog", "3.15.0"),
+                "org/apache/camel/catalog/quarkus", 
"org.apache.camel.quarkus", "camel-quarkus-http", "3.15.0");
+        
assertThat(catalog.getRuntimeProviderLoadedVersion()).isEqualTo("3.15.0");
+    }
+
+    @Test
+    void springBootProviderVersionCanDifferFromCore() throws Exception {
+        CamelCatalog current = new DefaultCamelCatalog();
+        CamelCatalog catalog
+                = CatalogLoader.loadSpringBootCatalog(null, 
current.getCatalogVersion(), true);
+        
assertThat(catalog.getCatalogVersion()).isEqualTo(current.getCatalogVersion());
+        
assertThat(catalog.modelJSonSchema("split")).isEqualTo(current.modelJSonSchema("split"));
+        
assertThat(catalog.getRuntimeProviderLoadedVersion()).isEqualTo(CAMEL_VERSION);
+        assertProvider(catalog, artifact("org.apache.camel.springboot", 
"camel-catalog-provider-springboot", CAMEL_VERSION),
+                "org/apache/camel/springboot/catalog", 
"org.apache.camel.springboot", "camel-http-starter", CAMEL_VERSION);
+    }
+
+    @Test
+    void quarkusMissingCoreCatalogFails() {
+        MavenGav bom = MavenGav.fromCoordinates("io.quarkus.platform", 
"quarkus-camel-bom", "3.15.1", "pom", null);
+        assertThatThrownBy(() -> CatalogLoader.loadQuarkusCatalog(bom, gav -> {
+            if ("org.apache.camel".equals(gav.getGroupId()) && 
"camel-catalog".equals(gav.getArtifactId())) {
+                return null;
+            }
+            return resolve(gav);
+        })).isInstanceOf(IOException.class).hasMessageContaining("Cannot 
download org.apache.camel:camel-catalog:4.8.0");
+    }
+
+    @Test
+    void quarkusWithoutVersionKeepsBuiltinCatalog() throws Exception {
+        CamelCatalog catalog = CatalogLoader.loadQuarkusCatalog(null, null, 
null, false);
+        assertThat(catalog.getCatalogVersion()).isEqualTo(new 
DefaultCamelCatalog().getCatalogVersion());
+    }
+
+    private static MavenArtifact resolve(MavenGav gav) {
+        return downloader.downloadArtifact(gav.getGroupId(),
+                gav.getArtifactId() + ("pom".equals(gav.getPackaging()) ? 
":pom" : ""), gav.getVersion());
+    }
+
+    private static MavenArtifact artifact(String groupId, String artifactId, 
String version) {
+        return downloader.downloadArtifact(groupId, artifactId, version);
+    }
+
+    private static void assertCoreCatalog(CamelCatalog catalog) throws 
IOException {
+        assertThat(catalog.getCatalogVersion()).isEqualTo(CAMEL_VERSION);
+        assertThat(new 
DefaultCamelCatalog().modelJSonSchema("split")).contains("\"note\"");
+        
assertThat(catalog.modelJSonSchema("split")).doesNotContain("\"note\"");
+        try (ZipFile jar = new ZipFile(coreCatalog.getFile())) {
+            for (String name : catalog.findModelNames()) {
+                assertThat(catalog.modelJSonSchema(name)).as("model %s", name)
+                        .isEqualTo(resource(jar, 
"org/apache/camel/catalog/models/" + name + ".json"));
+            }
+        }
+        assertThat(new 
DefaultCamelCatalog().modelJSonSchema("tokenizer")).isNotNull();
+        assertThat(catalog.modelJSonSchema("tokenizer")).isNull();
+        assertThat(catalog.findModelNames()).doesNotContain("tokenizer");
+    }
+
+    private static void assertProvider(
+            CamelCatalog catalog, MavenArtifact artifact, String resourcePath, 
String groupId, String artifactId,
+            String version)
+            throws IOException {
+        try (ZipFile jar = new ZipFile(artifact.getFile())) {
+            for (String name : catalog.findComponentNames()) {
+                assertThat(catalog.componentJSonSchema(name)).as("component 
%s", name)
+                        .isEqualTo(resource(jar, resourcePath + "/components/" 
+ name + ".json"));
+            }
+            for (String name : catalog.findDataFormatNames()) {
+                assertThat(catalog.dataFormatJSonSchema(name)).as("data format 
%s", name)
+                        .isEqualTo(resource(jar, resourcePath + 
"/dataformats/" + name + ".json"));
+            }
+            for (String name : catalog.findLanguageNames()) {
+                assertThat(catalog.languageJSonSchema(name)).as("language %s", 
name)
+                        .isEqualTo(resource(jar, resourcePath + "/languages/" 
+ name + ".json"));
+            }
+        }
+        
assertThat(catalog.componentModel("http").getGroupId()).isEqualTo(groupId);
+        
assertThat(catalog.componentModel("http").getArtifactId()).isEqualTo(artifactId);
+        
assertThat(catalog.componentModel("http").getVersion()).isEqualTo(version);
+    }
+
+    private static String resource(ZipFile jar, String name) throws 
IOException {
+        assertThat(jar.getEntry(name)).as("target resource %s", 
name).isNotNull();
+        try (InputStream stream = jar.getInputStream(jar.getEntry(name))) {
+            return new String(stream.readAllBytes(), StandardCharsets.UTF_8);
+        }
+    }
+}
diff --git 
a/dsl/camel-jbang/camel-jbang-mcp/src/test/java/org/apache/camel/dsl/jbang/core/commands/mcp/CatalogToolsTest.java
 
b/dsl/camel-jbang/camel-jbang-mcp/src/test/java/org/apache/camel/dsl/jbang/core/commands/mcp/CatalogToolsTest.java
new file mode 100644
index 000000000000..73caab4b3244
--- /dev/null
+++ 
b/dsl/camel-jbang/camel-jbang-mcp/src/test/java/org/apache/camel/dsl/jbang/core/commands/mcp/CatalogToolsTest.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.dsl.jbang.core.commands.mcp;
+
+import org.apache.camel.catalog.DefaultCamelCatalog;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.DisabledIfSystemProperty;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class CatalogToolsTest {
+
+    @Test
+    @DisabledIfSystemProperty(named = "ci.env.name", matches = ".*",
+                              disabledReason = "Runs only local - requires 
Maven Central access")
+    void mixedRuntimeRequestsKeepTheirCoreVersionAndProviderCoordinates() {
+        CatalogTools tools = new CatalogTools();
+        String[][] requests = {
+                { "spring-boot", "4.8.0", "4.8.0", "camel-http-starter", 
"4.8.0" },
+                { "quarkus", "3.15.1", "4.8.0", "camel-quarkus-http", "3.15.0" 
},
+                { "main", "4.8.0", "4.8.0", "camel-http", "4.8.0" },
+                {
+                        "main", null, new 
DefaultCamelCatalog().getCatalogVersion(), "camel-http",
+                        new DefaultCamelCatalog().getCatalogVersion() }
+        };
+        for (int pass = 0; pass < 2; pass++) {
+            for (String[] request : requests) {
+                String scenario = "runtime=" + request[0] + ", version=" + 
request[1] + ", pass=" + pass;
+                var components = tools.camel_catalog_components("http", null, 
10, request[0], request[1]);
+                assertThat(components.camelVersion()).as("%s: core version", 
scenario).isEqualTo(request[2]);
+                var component = tools.camel_catalog_component_doc("http", 
request[0], request[1]);
+                assertThat(component.artifactId()).as("%s: provider artifact", 
scenario).isEqualTo(request[3]);
+                assertThat(component.version()).as("%s: provider version", 
scenario).isEqualTo(request[4]);
+            }
+        }
+    }
+}

Reply via email to