Fix silent version fallback: error when requested JRE version not found

- Parse JBP_CONFIG_* version constraint and fail if version doesn't exist
- Remove hardcoded Tomcat 9.0.98 fallback, return error instead
- Convert Ruby buildpack '+' wildcard to '*' for libbuildpack semver
- Add tests for JBP_CONFIG parsing and version-not-found error

Author: ramonskie

src/java/containers/tomcat.go

@@ -93,10 +93,7 @@ func (t *TomcatContainer) Supply() error {
 	if dep.Version == "" {
 		dep, err = t.context.Manifest.DefaultVersion("tomcat")
 		if err != nil {
-			t.context.Log.Warning("Unable to determine default Tomcat version")
-			// Final fallback to a known version
-			dep.Name = "tomcat"
-			dep.Version = "9.0.98"
+			return fmt.Errorf("failed to determine Tomcat version: no JAVA_HOME set and no default version in manifest: %w", err)
 		}
 	}
 

src/java/jres/jre.go

@@ -2,11 +2,12 @@ package jres
 
 import (
 	"fmt"
-	"github.com/cloudfoundry/java-buildpack/src/java/common"
 	"os"
 	"path/filepath"
+	"regexp"
 	"strings"
 
+	"github.com/cloudfoundry/java-buildpack/src/java/common"
 	"github.com/cloudfoundry/libbuildpack"
 )
 
@@ -214,10 +215,23 @@ func GetJREVersion(ctx *common.Context, jreName string) (libbuildpack.Dependency
 	// Check for legacy JBP_CONFIG_<JRE_NAME> environment variable
 	envKey := fmt.Sprintf("JBP_CONFIG_%s", strings.ToUpper(strings.ReplaceAll(jreName, "-", "_")))
 	if envVal := os.Getenv(envKey); envVal != "" {
-		// Parse version from env (e.g., '{jre: {version: 11.+}}')
-		// For now, simplified - just log it
-		ctx.Log.Debug("JRE version override from %s: %s", envKey, envVal)
-		// TODO: Parse YAML-like config from envVal
+		versionPattern := parseJBPConfigVersion(envVal)
+		if versionPattern == "" {
+			return libbuildpack.Dependency{}, fmt.Errorf("could not parse version from %s='%s'", envKey, envVal)
+		}
+
+		normalizedPattern := normalizeVersionPattern(versionPattern)
+		availableVersions := ctx.Manifest.AllDependencyVersions(jreName)
+		if len(availableVersions) == 0 {
+			return libbuildpack.Dependency{}, fmt.Errorf("no versions of %s found in manifest", jreName)
+		}
+
+		matchedVersion, err := libbuildpack.FindMatchingVersion(normalizedPattern, availableVersions)
+		if err != nil {
+			return libbuildpack.Dependency{}, fmt.Errorf("no version of %s matching '%s' found in manifest. Available versions: %v", jreName, versionPattern, availableVersions)
+		}
+
+		return libbuildpack.Dependency{Name: jreName, Version: matchedVersion}, nil
 	}
 
 	// Get default version from manifest (no version constraint)
@@ -229,18 +243,25 @@ func GetJREVersion(ctx *common.Context, jreName string) (libbuildpack.Dependency
 	return dep, nil
 }
 
-// normalizeVersionPattern converts user-friendly version strings to manifest patterns
-// Examples: "8" -> "8.*", "11" -> "11.*", "17.0" -> "17.0.*", "11.+" -> "11.+"
 func normalizeVersionPattern(version string) string {
-	// If already has wildcard, return as-is
-	if strings.Contains(version, "*") || strings.Contains(version, "+") {
+	if strings.Contains(version, "+") {
+		return strings.ReplaceAll(version, "+", "*")
+	}
+	if strings.Contains(version, "*") {
 		return version
 	}
-
-	// Otherwise append ".*" to match any patch version
 	return version + ".*"
 }
 
+func parseJBPConfigVersion(configValue string) string {
+	re := regexp.MustCompile(`version:\s*['"]?([0-9]+[0-9.*+]*)['"]?`)
+	matches := re.FindStringSubmatch(configValue)
+	if len(matches) >= 2 {
+		return strings.TrimSpace(matches[1])
+	}
+	return ""
+}
+
 // WriteJavaOpts writes JAVA_OPTS to a .opts file for centralized assembly
 // JRE components use priority 05 to run early (before frameworks)
 func WriteJavaOpts(ctx *common.Context, opts string) error {

src/java/jres/jre_test.go

@@ -268,10 +268,37 @@ dependencies:
 				dep, err := jres.GetJREVersion(ctx, "openjdk")
 				Expect(err).NotTo(HaveOccurred())
 				Expect(dep.Name).To(Equal("openjdk"))
-				// Should match default version 17.x
 				Expect(dep.Version).To(ContainSubstring("17."))
 			})
 		})
+
+		Context("with JBP_CONFIG_OPENJDK", func() {
+			AfterEach(func() {
+				os.Unsetenv("JBP_CONFIG_OPENJDK")
+			})
+
+			It("resolves version from JBP_CONFIG", func() {
+				os.Setenv("JBP_CONFIG_OPENJDK", "{jre: {version: 11.+}}")
+				dep, err := jres.GetJREVersion(ctx, "openjdk")
+				Expect(err).NotTo(HaveOccurred())
+				Expect(dep.Name).To(Equal("openjdk"))
+				Expect(dep.Version).To(Equal("11.0.25"))
+			})
+
+			It("fails when requested version does not exist", func() {
+				os.Setenv("JBP_CONFIG_OPENJDK", "{jre: {version: 99.+}}")
+				_, err := jres.GetJREVersion(ctx, "openjdk")
+				Expect(err).To(HaveOccurred())
+				Expect(err.Error()).To(ContainSubstring("no version of openjdk matching"))
+			})
+
+			It("fails when config format is invalid", func() {
+				os.Setenv("JBP_CONFIG_OPENJDK", "invalid config")
+				_, err := jres.GetJREVersion(ctx, "openjdk")
+				Expect(err).To(HaveOccurred())
+				Expect(err.Error()).To(ContainSubstring("could not parse version"))
+			})
+		})
 	})
 
 	Describe("DetermineJavaVersion", func() {