fix: tomcat falls back to manifest default when Java version undetectable

When JAVA_HOME is set but the release file cannot be read (e.g. IBM JRE,
non-standard layout, missing file), the previous code silently assumed
Java 17 and selected Tomcat 10.x. This could break Java EE 8 apps running
on Java 8 that expect Tomcat 9.x.

Extract SelectTomcatVersionPattern() and return ("", nil) on detection
failure so the caller falls back to DefaultVersion("tomcat") — matching
the Ruby buildpack behaviour, which always deferred to the manifest default.
An explicitly configured tomcat version is still honoured even without Java
version info.

Author: stokpop

src/java/containers/tomcat.go

@@ -63,47 +63,23 @@ func (t *TomcatContainer) Supply() error {
 	}
 
 	if javaHome != "" {
-		javaMajorVersion, versionErr := common.DetermineJavaVersion(javaHome)
+		versionPattern, versionErr := SelectTomcatVersionPattern(javaHome, DetermineTomcatVersion(t.config.Tomcat.Version))
 		if versionErr != nil {
-			t.context.Log.Warning("Unable to determine Java version: %s (defaulting to 17)", versionErr.Error())
-			javaMajorVersion = 17
+			return versionErr
 		}
 
-		tomcatVersion := DetermineTomcatVersion(t.config.Tomcat.Version)
-		t.context.Log.Debug("Detected Java major version: %d", javaMajorVersion)
-
-		// Select Tomcat version pattern based on Java version
-		var versionPattern string
-		if tomcatVersion == "" {
-			t.context.Log.Info("Tomcat version not specified")
-			if javaMajorVersion >= 11 {
-				// Java 11+: Use Tomcat 10.x (Jakarta EE 9+)
-				versionPattern = "10.x"
-				t.context.Log.Info("Using Tomcat 10.x for Java %d", javaMajorVersion)
-			} else {
-				// Java 8-10: Use Tomcat 9.x (Java EE 8)
-				versionPattern = "9.x"
-				t.context.Log.Info("Using Tomcat 9.x for Java %d", javaMajorVersion)
+		if versionPattern != "" {
+			allVersions := t.context.Manifest.AllDependencyVersions("tomcat")
+			resolvedVersion, err := libbuildpack.FindMatchingVersion(versionPattern, allVersions)
+			if err != nil {
+				return fmt.Errorf("tomcat version resolution error for pattern %q: %w", versionPattern, err)
 			}
+			dep.Name = "tomcat"
+			dep.Version = resolvedVersion
+			t.context.Log.Debug("Resolved Tomcat version pattern '%s' to %s", versionPattern, resolvedVersion)
 		} else {
-			versionPattern = tomcatVersion
-			t.context.Log.Info("Using Tomcat %s for Java %d", versionPattern, javaMajorVersion)
-		}
-
-		if strings.HasPrefix(versionPattern, "10.") && javaMajorVersion < 11 {
-			return fmt.Errorf("Tomcat 10.x requires Java 11+, but Java %d detected", javaMajorVersion)
-		}
-
-		// Resolve the version pattern to actual version using libbuildpack
-		allVersions := t.context.Manifest.AllDependencyVersions("tomcat")
-		resolvedVersion, err := libbuildpack.FindMatchingVersion(versionPattern, allVersions)
-		if err != nil {
-			return fmt.Errorf("tomcat version resolution error for pattern %q: %w", versionPattern, err)
+			t.context.Log.Warning("Unable to determine Java version from JAVA_HOME, falling back to manifest default Tomcat version")
 		}
-
-		dep.Name = "tomcat"
-		dep.Version = resolvedVersion
-		t.context.Log.Debug("Resolved Tomcat version pattern '%s' to %s", versionPattern, resolvedVersion)
 	}
 
 	// Fallback to default version if we couldn't determine Java version
@@ -463,7 +439,37 @@ func getKeys(m map[string]string) []string {
 	return keys
 }
 
-// DetermineTomcatVersion determines the version of the tomcat
+// SelectTomcatVersionPattern determines the Tomcat version pattern to use based on the
+// detected Java version and any user-configured Tomcat version.
+// Returns ("", nil) when Java version cannot be determined — the caller should fall back
+// to the manifest default (matching Ruby buildpack behaviour).
+func SelectTomcatVersionPattern(javaHome, configVersion string) (string, error) {
+	if javaHome == "" {
+		return "", nil
+	}
+
+	javaMajorVersion, err := common.DetermineJavaVersion(javaHome)
+	if err != nil {
+		if configVersion != "" {
+			return configVersion, nil
+		}
+		return "", nil
+	}
+
+	if configVersion != "" {
+		if strings.HasPrefix(configVersion, "10.") && javaMajorVersion < 11 {
+			return "", fmt.Errorf("Tomcat 10.x requires Java 11+, but Java %d detected", javaMajorVersion)
+		}
+		return configVersion, nil
+	}
+
+	if javaMajorVersion >= 11 {
+		return "10.x", nil
+	}
+	return "9.x", nil
+}
+
+
 // based on the JBP_CONFIG_TOMCAT field from manifest.
 // It looks for a tomcat block with a version of the form "<major>.+" (e.g. "9.+", "10.+", "10.1.+").
 // Returns the pattern with "+" replaced by "*" (e.g. "9.*", "10.*", "10.1.*") so libbuildpack can resolve it.

src/java/containers/tomcat_test.go

@@ -197,6 +197,62 @@ var _ = Describe("Tomcat Container", func() {
 		})
 	})
 
+	Describe("SelectTomcatVersionPattern", func() {
+		var javaHome string
+
+		BeforeEach(func() {
+			var err error
+			javaHome, err = os.MkdirTemp("", "javahome")
+			Expect(err).NotTo(HaveOccurred())
+		})
+
+		AfterEach(func() {
+			os.RemoveAll(javaHome)
+		})
+
+		writeReleaseFile := func(content string) {
+			err := os.WriteFile(filepath.Join(javaHome, "release"), []byte(content), 0644)
+			Expect(err).NotTo(HaveOccurred())
+		}
+
+		Context("when release file is missing", func() {
+			It("returns empty pattern to fall back to manifest default, not assume Java 17", func() {
+				pattern, err := containers.SelectTomcatVersionPattern(javaHome, "")
+				Expect(err).NotTo(HaveOccurred())
+				Expect(pattern).To(Equal(""))
+			})
+
+			It("still honours an explicitly configured tomcat version", func() {
+				pattern, err := containers.SelectTomcatVersionPattern(javaHome, "9.*")
+				Expect(err).NotTo(HaveOccurred())
+				Expect(pattern).To(Equal("9.*"))
+			})
+		})
+
+		Context("happy path version selection", func() {
+			It("selects Tomcat 10.x for Java 11+", func() {
+				writeReleaseFile("JAVA_VERSION=\"11.0.20\"\n")
+				pattern, err := containers.SelectTomcatVersionPattern(javaHome, "")
+				Expect(err).NotTo(HaveOccurred())
+				Expect(pattern).To(Equal("10.x"))
+			})
+
+			It("selects Tomcat 9.x for Java 8", func() {
+				writeReleaseFile("JAVA_VERSION=\"1.8.0_372\"\n")
+				pattern, err := containers.SelectTomcatVersionPattern(javaHome, "")
+				Expect(err).NotTo(HaveOccurred())
+				Expect(pattern).To(Equal("9.x"))
+			})
+
+			It("errors when Tomcat 10.x is requested but Java 8 detected", func() {
+				writeReleaseFile("JAVA_VERSION=\"1.8.0_372\"\n")
+				_, err := containers.SelectTomcatVersionPattern(javaHome, "10.*")
+				Expect(err).To(HaveOccurred())
+				Expect(err.Error()).To(ContainSubstring("Java 11+"))
+			})
+		})
+	})
+
 	Describe("determineTomcatVersion", func() {
 		It("returns empty string when JBP_CONFIG_TOMCAT is empty", func() {
 			v := containers.DetermineTomcatVersion("")

src/java/supply/supply_test.go

@@ -107,6 +107,8 @@ dependencies: []
 			Expect(os.MkdirAll(filepath.Join(jdkInstallDir, "jre-17.0.15", "bin"), 0755)).To(Succeed())
 			javaBin := filepath.Join(jdkInstallDir, "jre-17.0.15", "bin", "java")
 			Expect(os.WriteFile(javaBin, []byte("mockfile"), 0644)).To(Succeed())
+			releaseFile := filepath.Join(jdkInstallDir, "jre-17.0.15", "release")
+			Expect(os.WriteFile(releaseFile, []byte("JAVA_VERSION=\"17.0.15\"\n"), 0644)).To(Succeed())
 
 			// adjust JRE  component mocks used during supply
 			depJre := libbuildpack.Dependency{Name: "openjdk", Version: "17.0.15"}