[SRVKP-7207] verify olmskiprange path

Author: manthinasai

pkg/oc/oc.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"log"
+	"os"
 	"slices"
 	"strings"
 	"time"
@@ -169,3 +170,218 @@ func CopySecret(secretName string, sourceNamespace string, destNamespace string)
 	cmd.MustSucceed("bash", "-c", fmt.Sprintf(`echo '%s' | kubectl apply -n %s -f -`, cmdOutput, destNamespace))
 	log.Printf("Successfully copied secret %s from %s to %s", secretName, sourceNamespace, destNamespace)
 }
+
+func FetchOlmSkipRange() (map[string]string, error) {
+	skipRangesJson := cmd.MustSucceed("bash", "-c", `oc get packagemanifests openshift-pipelines-operator-rh -n openshift-marketplace -o json | jq -r '.status.channels[].currentCSVDesc.annotations["olm.skipRange"]'`).Stdout()
+	skipRanges := strings.Split(strings.TrimSpace(skipRangesJson), "\n")
+	channelsJson := cmd.MustSucceed("bash", "-c", `oc get packagemanifests openshift-pipelines-operator-rh -n openshift-marketplace -o json | jq -r '.status.channels[].name'`).Stdout()
+	channels := strings.Split(strings.TrimSpace(channelsJson), "\n")
+
+	if len(channels) != len(skipRanges) {
+		return nil, fmt.Errorf("mismatch between number of channels (%d) and skipRanges (%d)", len(channels), len(skipRanges))
+	}
+
+	channelSkipRangeMap := make(map[string]string)
+	for i, channel := range channels {
+		if skipRanges[i] != "null" && skipRanges[i] != "" {
+			channelSkipRangeMap[channel] = skipRanges[i]
+		}
+	}
+
+	if len(channelSkipRangeMap) == 0 {
+		return nil, fmt.Errorf("no valid OLM Skip Ranges found")
+	}
+	return channelSkipRangeMap, nil
+}
+
+func GetOlmSkipRange(upgradeType, fieldName, fileName string) {
+	skipRangeMap, err := FetchOlmSkipRange()
+	if err != nil {
+		log.Printf("Error fetching OLM Skip Range: %v", err)
+		return
+	}
+	file, err := os.OpenFile(config.Path(fileName), os.O_RDWR, 0644)
+	if err != nil {
+		log.Printf("Error opening file %s: %v", fileName, err)
+		return
+	}
+	defer file.Close()
+	var existingData map[string]interface{}
+	if err := json.NewDecoder(file).Decode(&existingData); err != nil {
+		log.Printf("Error decoding existing data from file %s: %v", fileName, err)
+		return
+	}
+	switch upgradeType {
+	case "pre-upgrade":
+		existingData["pre-upgrade-olm-skip-range"] = skipRangeMap
+		log.Printf("Pre-upgrade OLM Skip Range is stored as: %+v", skipRangeMap)
+	case "post-upgrade":
+		existingData["post-upgrade-olm-skip-range"] = skipRangeMap
+		log.Printf("Post-upgrade OLM Skip Range is stored as: %+v", skipRangeMap)
+	}
+	if _, err := file.Seek(0, 0); err != nil {
+		log.Printf("Error seeking file %s: %v", fileName, err)
+		return
+	}
+	encoder := json.NewEncoder(file)
+	encoder.SetIndent("", "  ") // Pretty-print the JSON output
+	if err := encoder.Encode(existingData); err != nil {
+		log.Printf("Error writing updated data to file %s: %v", fileName, err)
+		return
+	}
+	log.Printf("OLM Skip Range for '%s' has been saved to file %s", fieldName, fileName)
+}
+
+func ValidateOlmSkipRange() {
+	skipRangeMap, err := FetchOlmSkipRange()
+	if err != nil {
+		log.Printf("Error fetching OLM Skip Range: %v", err)
+		return
+	}
+
+	ospVersion := os.Getenv("OSP_VERSION")
+	log.Printf("Validating OSP_VERSION: %s", ospVersion)
+	found := false
+
+	if ospVersion == "5.0.5" {
+		log.Printf("Detected nightly build (OSP_VERSION=5.0.5), validating only skipRange, not channel name")
+		for channel, skipRange := range skipRangeMap {
+			if channel == "latest" {
+				log.Printf("Skipping 'latest' channel as requested")
+				continue
+			}
+			skipRangeContainsVersion := strings.Contains(skipRange, ospVersion)
+			log.Printf("Channel: %s, SkipRange: %s", channel, skipRange)
+			log.Printf("  - SkipRange contains OSP_VERSION '%s': %v", ospVersion, skipRangeContainsVersion)
+
+			if skipRangeContainsVersion {
+				log.Printf("Success: OSP_VERSION '%s' found in skipRange for channel '%s': '%s'", ospVersion, channel, skipRange)
+				found = true
+				break
+			}
+		}
+	} else {
+		log.Printf("Regular release build, validating both channel name and skipRange")
+		for channel, skipRange := range skipRangeMap {
+			if channel == "latest" {
+				log.Printf("Skipping 'latest' channel as requested")
+				continue
+			}
+			channelContainsVersion := strings.Contains(channel, ospVersion)
+			skipRangeContainsVersion := strings.Contains(skipRange, ospVersion)
+			log.Printf("Channel: %s, SkipRange: %s", channel, skipRange)
+			log.Printf("  - Channel contains OSP_VERSION '%s': %v", ospVersion, channelContainsVersion)
+			log.Printf("  - SkipRange contains OSP_VERSION '%s': %v", ospVersion, skipRangeContainsVersion)
+			if channelContainsVersion && skipRangeContainsVersion {
+				log.Printf("Success: OSP_VERSION '%s' found in both channel '%s' and its skipRange '%s'", ospVersion, channel, skipRange)
+				found = true
+				break
+			}
+		}
+	}
+
+	if !found {
+		log.Printf("Available channels and their skipRanges:")
+		for channel, skipRange := range skipRangeMap {
+			if channel != "latest" {
+				log.Printf("  - Channel: %s, SkipRange: %s", channel, skipRange)
+			}
+		}
+
+		if ospVersion == "5.0.5" {
+			testsuit.T.Fail(fmt.Errorf("Error: OSP_VERSION '%s' not found in skipRange for any non-latest channel", ospVersion))
+		} else {
+			testsuit.T.Fail(fmt.Errorf("Error: OSP_VERSION '%s' not found in both channel name and skipRange for any non-latest channel", ospVersion))
+		}
+	}
+}
+
+func ValidateOlmSkipRangeDiff(fileName string, preUpgradeSkipRange string, postUpgradeSkipRange string) {
+	file, err := os.Open(config.Path(fileName))
+	if err != nil {
+		log.Printf("Error opening file %s: %v", fileName, err)
+		testsuit.T.Fail(fmt.Errorf("Error opening file %s: %v", fileName, err))
+		return
+	}
+	defer file.Close()
+	var skipRangeData map[string]interface{}
+	decoder := json.NewDecoder(file)
+	if err := decoder.Decode(&skipRangeData); err != nil {
+		log.Printf("Error decoding JSON from file %s: %v", fileName, err)
+		testsuit.T.Fail(fmt.Errorf("Error decoding JSON from file %s: %v", fileName, err))
+		return
+	}
+	preUpgradeData, preExists := skipRangeData[preUpgradeSkipRange]
+	postUpgradeData, postExists := skipRangeData[postUpgradeSkipRange]
+	if !preExists || !postExists {
+		log.Printf("Error: One of the skip ranges is missing. Pre-Upgrade exists: %v, Post-Upgrade exists: %v", preExists, postExists)
+		testsuit.T.Fail(fmt.Errorf("One of the skip ranges is missing. Pre-Upgrade exists: %v, Post-Upgrade exists: %v", preExists, postExists))
+		return
+	}
+
+	preUpgradeMap, ok1 := preUpgradeData.(map[string]interface{})
+	postUpgradeMap, ok2 := postUpgradeData.(map[string]interface{})
+
+	if !ok1 || !ok2 {
+		log.Printf("Error: Skip range data is not in expected map format")
+		testsuit.T.Fail(fmt.Errorf("Skip range data is not in expected map format"))
+		return
+	}
+
+	log.Printf("Pre-Upgrade Skip Range: %+v", preUpgradeMap)
+	log.Printf("Post-Upgrade Skip Range: %+v", postUpgradeMap)
+
+	// Validate that all pre-upgrade channels (except 'latest') are preserved in post-upgrade
+	// Ignore 'latest' channel in post-upgrade data completely
+	validationErrors := []string{}
+
+	log.Printf("Validating that all pre-upgrade channels are preserved in post-upgrade (ignoring 'latest' channel)")
+
+	// Check each channel from pre-upgrade data
+	for preChannel, preSkipRange := range preUpgradeMap {
+		// Skip 'latest' channel from pre-upgrade validation
+		if preChannel == "latest" {
+			log.Printf("Skipping 'latest' channel from pre-upgrade data as requested")
+			continue
+		}
+
+		// Check if this pre-upgrade channel exists in post-upgrade with same skipRange
+		if postSkipRange, exists := postUpgradeMap[preChannel]; exists {
+			if preSkipRange == postSkipRange {
+				log.Printf("✅ Success: Channel '%s' preserved with skipRange: %v", preChannel, preSkipRange)
+			} else {
+				validationErrors = append(validationErrors, fmt.Sprintf("Channel '%s' skipRange changed from '%v' to '%v' (should remain unchanged)", preChannel, preSkipRange, postSkipRange))
+			}
+		} else {
+			validationErrors = append(validationErrors, fmt.Sprintf("Pre-upgrade channel '%s' is missing in post-upgrade data", preChannel))
+		}
+	}
+
+	// Log additional channels in post-upgrade (for information only, not validation errors)
+	log.Printf("Additional channels found in post-upgrade data:")
+	for postChannel, postSkipRange := range postUpgradeMap {
+		// Skip channels that were in pre-upgrade (already validated above)
+		if _, existedInPre := preUpgradeMap[postChannel]; existedInPre {
+			continue
+		}
+
+		// Skip 'latest' channel as requested
+		if postChannel == "latest" {
+			log.Printf("  - Ignoring 'latest' channel in post-upgrade as requested")
+			continue
+		}
+
+		log.Printf("  - New channel '%s' with skipRange: %v", postChannel, postSkipRange)
+	}
+
+	// Report results
+	if len(validationErrors) > 0 {
+		log.Printf("❌ OLM Skip Range validation failed with errors:")
+		for _, err := range validationErrors {
+			log.Printf("  - %s", err)
+		}
+		testsuit.T.Fail(fmt.Errorf("OLM Skip Range validation failed: %v", strings.Join(validationErrors, "; ")))
+	} else {
+		log.Printf("✅ Success: OLM Skip Range validation passed - all expected changes detected correctly")
+	}
+}

specs/operator/post-upgrade.spec

@@ -83,4 +83,15 @@ Importance: Critical
 Steps:
   * Switch to project "releasetest-upgrade-s2i"
   * Get tags of the imagestream "golang" from namespace "openshift" and store to variable "golang-tags"
-  * Start and verify pipeline "s2i-go-pipeline" with param "VERSION" with values stored in variable "golang-tags" with workspace "name=source,claimName=shared-pvc"
+  * Start and verify pipeline "s2i-go-pipeline" with param "VERSION" with values stored in variable "golang-tags" with workspace "name=source,claimName=shared-pvc"
+
+## Validate olm skiprange post upgrade: PIPELINES-19-TC06
+Tags: post-upgrade, olm
+Component: Pipelines
+Level: Integration
+Type: Functional
+Importance: Critical
+
+Steps:
+ * Get olm-skip-range "post-upgrade" and save to field "post-upgrade-olm-skip-range" in file "testdata/olm/skiprange.json"
+ * Validate the fields "pre-upgrade-olm-skip-range" and "post-upgrade-olm-skip-range" are same in file "testdata/olm/skiprange.json"

specs/operator/pre-upgrade.spec

@@ -126,4 +126,14 @@ Steps:
       |S.NO|resource_dir                                          |
       |----|------------------------------------------------------|
       |1   |testdata/ecosystem/pipelines/s2i-go.yaml|
-      |2   |testdata/pvc/pvc.yaml                                 |
+      |2   |testdata/pvc/pvc.yaml                                 |
+
+## Validate olm skiprange pre upgrade: PIPELINES-18-TC06
+Tags: pre-upgrade, olm
+Component: Pipelines
+Level: Integration
+Type: Functional
+Importance: Critical
+
+Steps:
+ * Get olm-skip-range "pre-upgrade" and save to field "pre-upgrade-olm-skip-range" in file "testdata/olm/skiprange.json"

specs/versions.spec

@@ -30,3 +30,12 @@ Steps:
   * Check "tkn-pac" version
   * Check "opc" client version
   * Check "opc" server version
+
+## Check OperatorVersion in OlmSkipRange : PIPELINES-22-TC03
+Tags: e2e, sanity, olm
+Component: Operator
+Level: Integration
+Type: Functional
+Importance: High
+Steps: 
+  * Validate OperatorVersion in OlmSkipRange

steps/olm/operator.go

@@ -194,3 +194,15 @@ var _ = gauge.Step("Store Cosign public key in file", func() {
 var _ = gauge.Step("Verify <binary> version from the pipelinerun logs", func(binary string) {
 	pipelines.CheckLogVersion(store.Clients(), binary, store.Namespace())
 })
+
+var _ = gauge.Step("Get olm-skip-range <upgradeType> and save to field <fieldName> in file <fileName>", func(upgradeType string, fieldName string, filename string) {
+	oc.GetOlmSkipRange(upgradeType, fieldName, filename)
+})
+
+var _ = gauge.Step("Validate the fields <preUpgradeSkipRange> and <postUpgradeSkipRange> are same in file <fileName>", func(preUpgradeSkipRange string, postUpgradeSkipRange string, fileName string) {
+	oc.ValidateOlmSkipRangeDiff(fileName, preUpgradeSkipRange, postUpgradeSkipRange)
+})
+
+var _ = gauge.Step("Validate OperatorVersion in OlmSkipRange", func() {
+	oc.ValidateOlmSkipRange()
+})

testdata/olm/skiprange.json

@@ -0,0 +1,4 @@
+{
+  "post-upgrade-olm-skip-range": {},
+  "pre-upgrade-olm-skip-range": {}
+}