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();
+ }
+ }
+}