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

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


The following commit(s) were added to refs/heads/camel-4.22.x by this push:
     new 5949ac542efd [backport camel-4.22.x] CAMEL-26926: Keep runtime 
catalogs on the selected Camel version (#29905)
5949ac542efd is described below

commit 5949ac542efd0ecd2ad8c7f7bc7abaf5d4c6dbc9
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]>
---
 .../camel/dsl/jbang/core/common/CatalogLoader.java |  87 +++++++-----
 .../camel/dsl/jbang/core/commands/ExportTest.java  |  26 ++++
 .../jbang/core/common/CatalogLoaderBomTest.java    |  81 +++++++++++
 .../dsl/jbang/core/common/CatalogLoaderTest.java   | 158 +++++++++++++++++++++
 .../core/commands/mcp/CatalogServiceTest.java      |  73 ++++++++++
 5 files changed, 388 insertions(+), 37 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 e581eb20479d..6a09baf547bd 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
@@ -27,6 +27,7 @@ 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;
@@ -42,8 +43,6 @@ import org.apache.camel.tooling.maven.MavenGav;
 
 public final class CatalogLoader {
 
-    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";
 
     private static final String QUARKUS_CATALOG_PROVIDER = 
"org.apache.camel.catalog.quarkus.QuarkusRuntimeProvider";
@@ -119,6 +118,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);
@@ -136,27 +137,27 @@ 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(springBootGroupId, 
"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(springBootGroupId, 
"camel-catalog-provider-springboot", sbVersion);
             if (ma != null) {
                 cl.addFile(ma.getFile());
+                resources.addFile(ma.getFile());
             } else {
                 throw new IOException(
-                        "Cannot download " + springBootGroupId + 
":camel-catalog-provider-springboot:" + version);
+                        "Cannot download " + springBootGroupId + 
":camel-catalog-provider-springboot:" + sbVersion);
             }
 
             Class<RuntimeProvider> clazz;
             try {
                 clazz = (Class<RuntimeProvider>) 
cl.loadClass(SPRING_BOOT_CATALOG_PROVIDER);
             } catch (UnsupportedClassVersionError e) {
-                String sbVersion = PropertyResolver.fromSystemProperty(
-                        CamelJBangConstants.CAMEL_SPRING_BOOT_VERSION, () -> 
camelVersion);
                 throw new IOException(
                         "Cannot load camel-catalog-provider-springboot:" + 
sbVersion
                                       + " on Java " + Runtime.version()
@@ -164,16 +165,11 @@ public final class CatalogLoader {
                                       + " Use 
--camel-spring-boot-version=4.18.x for JDK 17 compatibility, or run on JDK 
21+.");
             }
             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 {
@@ -187,6 +183,7 @@ public final class CatalogLoader {
     public 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)
@@ -207,34 +204,44 @@ public final class CatalogLoader {
                     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();
-                        break;
+                        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;
                     }
                 }
             }
         }
 
-        if (camelQuarkusVersion != null) {
-            // 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));
-            DependencyDownloaderClassLoader cl
-                    = new 
DependencyDownloaderClassLoader(Thread.currentThread().getContextClassLoader());
-            cl.addFile(artifact.getFile());
-            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);
-            }
+        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(Thread.currentThread().getContextClassLoader());
+        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;
@@ -301,9 +308,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;
         }
 
@@ -329,7 +342,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 6ddbfd25ae4c..eeb79d6a4f37 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
@@ -46,6 +46,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;
@@ -243,6 +245,30 @@ 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");
+        // The general helper pins a released core version; exercise an 
omitted version as well as an explicit one.
+        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..5545b9ca1424
--- /dev/null
+++ 
b/dsl/camel-jbang/camel-jbang-core/src/test/java/org/apache/camel/dsl/jbang/core/common/CatalogLoaderTest.java
@@ -0,0 +1,158 @@
+/*
+ * 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.tooling.maven.MavenArtifact;
+import org.apache.camel.tooling.maven.MavenDownloader;
+import org.apache.camel.tooling.maven.MavenDownloaderImpl;
+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 MavenDownloader downloader;
+    private static MavenArtifact coreCatalog;
+
+    // These released-artifact comparisons deliberately run in CI to catch 
catalog resource mixing.
+    @BeforeAll
+    static void downloadCatalog() {
+        downloader = new MavenDownloaderImpl();
+        downloader.build();
+        coreCatalog = artifact("org.apache.camel", "camel-catalog", 
CAMEL_VERSION);
+    }
+
+    @AfterAll
+    static void closeDownloader() throws Exception {
+        if (downloader != null) {
+            downloader.stop();
+        }
+    }
+
+    @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(
+                MavenGav.fromCoordinates("io.quarkus.platform", 
"quarkus-camel-bom", "3.15.1", "pom", null),
+                downloader::resolveArtifact);
+        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 downloader.resolveArtifact(gav);
+        })).isInstanceOf(IOException.class).hasMessageContaining("Cannot 
download org.apache.camel:camel-catalog:4.8.0");
+    }
+
+    private static MavenArtifact artifact(String groupId, String artifactId, 
String version) {
+        return downloader.resolveArtifact(MavenGav.fromCoordinates(groupId, 
artifactId, version, "jar", null));
+    }
+
+    private static void assertCoreCatalog(CamelCatalog catalog) throws 
IOException {
+        assertThat(catalog.getCatalogVersion()).isEqualTo(CAMEL_VERSION);
+        assertThat(new 
DefaultCamelCatalog().modelJSonSchema("split")).contains("errorThreshold");
+        
assertThat(catalog.modelJSonSchema("split")).doesNotContain("errorThreshold");
+        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/CatalogServiceTest.java
 
b/dsl/camel-jbang/camel-jbang-mcp/src/test/java/org/apache/camel/dsl/jbang/core/commands/mcp/CatalogServiceTest.java
new file mode 100644
index 000000000000..35a70f6ca11d
--- /dev/null
+++ 
b/dsl/camel-jbang/camel-jbang-mcp/src/test/java/org/apache/camel/dsl/jbang/core/commands/mcp/CatalogServiceTest.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.apache.camel.dsl.jbang.core.commands.mcp;
+
+import java.util.Optional;
+
+import org.apache.camel.catalog.CamelCatalog;
+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 CatalogServiceTest {
+
+    private static final String BUILTIN_VERSION = new 
DefaultCamelCatalog().getCatalogVersion();
+
+    @Test
+    @DisabledIfSystemProperty(named = "ci.env.name", matches = ".*",
+                              disabledReason = "Runs only local — requires 
Maven Central access")
+    void mixedRuntimeRequestsKeepTheirCoreSchemasAndProviderCoordinates() 
throws Exception {
+        CatalogService service = new CatalogService();
+        service.catalogRepos = Optional.empty();
+        String targetSplit = service.loadCatalog("main", "4.8.0", 
null).modelJSonSchema("split");
+        ConfigurationValidateTools tools = new ConfigurationValidateTools();
+        tools.catalogService = service;
+        String[][] requests = {
+                { "spring-boot", "4.8.0", null, "camel-http-starter", "4.8.0" 
},
+                { "quarkus", null, 
"io.quarkus.platform:quarkus-camel-bom:3.15.1", "camel-quarkus-http", "3.15.0" 
},
+                { "main", "4.8.0", null, "camel-http", "4.8.0" },
+                {
+                        "spring-boot", "4.8.0", 
"org.apache.camel.springboot:camel-spring-boot-bom:4.8.0",
+                        "camel-http-starter", "4.8.0" }
+        };
+        for (int pass = 0; pass < 2; pass++) {
+            for (String[] request : requests) {
+                String scenario = "runtime=" + request[0] + ", camelVersion=" 
+ request[1]
+                                  + ", platformBom=" + request[2] + ", pass=" 
+ pass;
+                CamelCatalog catalog = service.loadCatalog(request[0], 
request[1], request[2]);
+                assertThat(catalog.getCatalogVersion()).as("%s: core version", 
scenario).isEqualTo("4.8.0");
+                assertThat(catalog.modelJSonSchema("split")).as("%s: split 
schema", scenario).isEqualTo(targetSplit)
+                        .doesNotContain("errorThreshold");
+                assertThat(catalog.modelJSonSchema("tokenizer")).as("%s: 
missing tokenizer schema", scenario).isNull();
+                
assertThat(catalog.componentModel("http").getArtifactId()).as("%s: provider 
artifact", scenario)
+                        .isEqualTo(request[3]);
+                
assertThat(catalog.componentModel("http").getVersion()).as("%s: provider 
version", scenario)
+                        .isEqualTo(request[4]);
+                var result = 
tools.camel_configuration_validate("camel.component.http.max-total-connections=20",
+                        request[0], request[1], request[2]);
+                assertThat(result.camelVersion()).as("%s: validation version", 
scenario).isEqualTo("4.8.0");
+                assertThat(result.summary().valid()).as("%s: valid 
configurations", scenario).isEqualTo(1);
+            }
+            CamelCatalog current = service.loadCatalog("main", 
BUILTIN_VERSION, null);
+            assertThat(current.getCatalogVersion()).isEqualTo(BUILTIN_VERSION);
+            
assertThat(current.modelJSonSchema("split")).contains("errorThreshold");
+            assertThat(current.modelJSonSchema("tokenizer")).isNotNull();
+        }
+    }
+}

Reply via email to