Calculate latest OCP version for e2e tests

test/util/framework/deployment_params.go

@@ -43,7 +43,6 @@ const (
 	// Default OpenShift channel group, version, and node pool version for the E2E test
 	DefaultOCPChannelGroup         = "candidate"
 	DefaultOCPVersionId            = "4.20"
-	DefaultOCPNodePoolVersionId    = "4.20.15"
 	DefaultOCPNodePoolChannelGroup = "candidate"
 
 	DefaultPodCIDR      = "10.128.0.0/14"
@@ -89,17 +88,13 @@ type NetworkConfig struct {
 func DefaultOpenshiftControlPlaneVersionId() string {
 	version := os.Getenv("ARO_HCP_OPENSHIFT_CONTROLPLANE_VERSION")
 	if len(version) == 0 {
-		version = DefaultOCPVersionId
-		// For nightly channel, calculate the latest version for the default Y stream
-		if DefaultOpenshiftChannelGroup() == "nightly" {
-			var err error
-			version, err = GetLatestInstallVersionForNightlyChannel(version)
-			if err != nil {
-				if errors.Is(err, ErrNightlyReleaseStreamNotFound) || errors.Is(err, ErrNoAcceptedNightlyTags) {
-					Skip(fmt.Sprintf("No install version found for %s in nightly channel (%s)", version, err.Error()))
-				} else {
-					Fail(fmt.Sprintf("failed to get latest install version for nightly channel: %s", err.Error()))
-				}
+		var err error
+		version, err = GetLatestInstallVersion(DefaultOpenshiftChannelGroup(), DefaultOCPVersionId)
+		if err != nil {
+			if errors.Is(err, ErrNightlyReleaseStreamNotFound) || errors.Is(err, ErrNoAcceptedNightlyTags) {
+				Skip(fmt.Sprintf("No install version found for %s in nightly channel (%s)", version, err.Error()))
+			} else {
+				Fail(fmt.Sprintf("failed to get latest install version for nightly channel: %s", err.Error()))
 			}
 		}
 	}
@@ -117,17 +112,13 @@ func DefaultOpenshiftChannelGroup() string {
 func DefaultOpenshiftNodePoolVersionId() string {
 	version := os.Getenv("ARO_HCP_OPENSHIFT_NODEPOOL_VERSION")
 	if len(version) == 0 {
-		version = DefaultOCPNodePoolVersionId
-		// For nightly channel, calculate the latest version for the default Y stream (it's the same as the control plane version)
-		if DefaultOpenshiftNodePoolChannelGroup() == "nightly" {
-			var err error
-			version, err = GetLatestInstallVersionForNightlyChannel(DefaultOCPVersionId)
-			if err != nil {
-				if errors.Is(err, ErrNightlyReleaseStreamNotFound) || errors.Is(err, ErrNoAcceptedNightlyTags) {
-					Skip(fmt.Sprintf("No node pool install version found for %s in nightly channel (%s)", version, err.Error()))
-				} else {
-					Fail(fmt.Sprintf("failed to get latest node pool install version for nightly channel: %s", err.Error()))
-				}
+		var err error
+		version, err = GetLatestInstallVersion(DefaultOpenshiftNodePoolChannelGroup(), DefaultOCPVersionId)
+		if err != nil {
+			if errors.Is(err, ErrNightlyReleaseStreamNotFound) || errors.Is(err, ErrNoAcceptedNightlyTags) {
+				Skip(fmt.Sprintf("No node pool install version found for %s in nightly channel (%s)", version, err.Error()))
+			} else {
+				Fail(fmt.Sprintf("failed to get latest node pool install version for nightly channel: %s", err.Error()))
 			}
 		}
 	}

test/util/framework/version_helper.go

@@ -198,6 +198,87 @@ func GetUpgradeCandidatesInMaxMinorFromCincinnati(ctx context.Context, channelGr
 	return out, nil
 }
 
+func GetLatestInstallVersion(channelGroup string, version string) (string, error) {
+	switch channelGroup {
+	case "nightly":
+		return GetLatestInstallVersionForNightlyChannel(version)
+	case "stable":
+		return GetLatestInstallVersionForGraphChannel("stable", version)
+	case "candidate":
+		return GetLatestInstallVersionForGraphChannel("candidate", version)
+	case "fast":
+		return GetLatestInstallVersionForGraphChannel("fast", version)
+	default:
+		return "", fmt.Errorf("invalid channel group: %s", channelGroup)
+	}
+}
+
+func GetLatestInstallVersionForGraphChannel(channelGroup string, version string) (string, error) {
+	channel := fmt.Sprintf("%s-%s", channelGroup, version)
+	graphURL := fmt.Sprintf("https://api.openshift.com/api/upgrades_info/v1/graph?channel=%s", url.QueryEscape(channel))
+
+	req, err := http.NewRequest(http.MethodGet, graphURL, nil)
+	if err != nil {
+		return "", fmt.Errorf("create %s graph request for %s: %w", channelGroup, channel, err)
+	}
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("query %s graph for %s: %w", channelGroup, channel, err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return "", fmt.Errorf("query %s graph for %s returned %s: %s", channelGroup, channel, resp.Status, strings.TrimSpace(string(body)))
+	}
+
+	var payload struct {
+		Nodes []struct {
+			Version string `json:"version"`
+		} `json:"nodes"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
+		return "", fmt.Errorf("decode %s graph response for %s: %w", channelGroup, channel, err)
+	}
+	if len(payload.Nodes) == 0 {
+		return "", fmt.Errorf("no graph nodes found for %s", channel)
+	}
+
+	requestedMinor, err := semver.ParseTolerant(version)
+	if err != nil {
+		return "", fmt.Errorf("parse requested %s minor %q: %w", channelGroup, version, err)
+	}
+
+	var latestVersion semver.Version
+	latestVersionID := ""
+	for _, node := range payload.Nodes {
+		nodeVersion, parseErr := semver.ParseTolerant(node.Version)
+		if parseErr != nil {
+			continue
+		}
+		if nodeVersion.Major != requestedMinor.Major || nodeVersion.Minor != requestedMinor.Minor {
+			continue
+		}
+		if latestVersionID == "" || nodeVersion.GT(latestVersion) {
+			latestVersion = nodeVersion
+			latestVersionID = node.Version
+		}
+	}
+
+	if latestVersionID == "" {
+		return "", fmt.Errorf("no %s versions found in %s for requested minor %s", channelGroup, channel, version)
+	}
+
+	// For stable channel, return the latest version in the minor
+	if channelGroup == "stable" {
+		return fmt.Sprintf("%d.%d", latestVersion.Major, latestVersion.Minor), nil
+	}
+
+	return latestVersionID, nil
+}
+
+
 // GetLatestInstallVersionForNightlyChannel returns the latest accepted nightly tag for the given minor version
 // (for example "4.19" -> "4.19.0-0.nightly-multi-YYYY-MM-DD-HHMMSS").
 func GetLatestInstallVersionForNightlyChannel(version string) (string, error) {