OTA-1546: Add a serial e2e for accept-risks

.openshift-tests-extension/openshift_payload_cluster-version-operator.json

@@ -1,4 +1,16 @@
 [
+  {
+    "name": "[Jira:\"Cluster Version Operator\"] cluster-version-operator should work with accept risks",
+    "labels": {
+      "Serial": {}
+    },
+    "resources": {
+      "isolation": {}
+    },
+    "source": "openshift:payload:cluster-version-operator",
+    "lifecycle": "blocking",
+    "environmentSelector": {}
+  },
   {
     "name": "[Jira:\"Cluster Version Operator\"] cluster-version-operator-tests should support passing tests",
     "labels": {},

cmd/cluster-version-operator-tests/main.go

@@ -24,7 +24,7 @@ func main() {
 		Name:    "openshift/cluster-version-operator/conformance/parallel",
 		Parents: []string{"openshift/conformance/parallel"},
 		Qualifiers: []string{
-			`!(name.contains("[Serial]") || name.contains("[Slow]"))`,
+			`!(name.contains("[Serial]") || "Serial" in labels || name.contains("[Slow]"))`,
 		},
 	})
 
@@ -33,7 +33,7 @@ func main() {
 		Name:    "openshift/cluster-version-operator/conformance/serial",
 		Parents: []string{"openshift/conformance/serial"},
 		Qualifiers: []string{
-			`name.contains("[Serial]")`,
+			`name.contains("[Serial]") || "Serial" in labels`,
 		},
 	})
 

lib/resourcebuilder/apps.go

@@ -13,6 +13,7 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/klog/v2"
 
+	"github.com/openshift/cluster-version-operator/pkg/external"
 	"github.com/openshift/cluster-version-operator/pkg/payload"
 )
 
@@ -39,7 +40,7 @@ func (b *builder) modifyDeployment(ctx context.Context, deployment *appsv1.Deplo
 	// if we detect the CVO deployment we need to replace the KUBERNETES_SERVICE_HOST env var with the internal load
 	// balancer to be resilient to kube-apiserver rollouts that cause the localhost server to become non-responsive for
 	// multiple minutes.
-	if deployment.Namespace == "openshift-cluster-version" && deployment.Name == "cluster-version-operator" {
+	if deployment.Namespace == external.DefaultCVONamespace && deployment.Name == external.DefaultDeploymentName {
 		infrastructureConfig, err := b.configClientv1.Infrastructures().Get(ctx, "cluster", metav1.GetOptions{})
 		// not found just means that we don't have infrastructure configuration yet, so we should tolerate not found and avoid substitution
 		if err != nil && !errors.IsNotFound(err) {
@@ -63,7 +64,7 @@ func (b *builder) modifyDeployment(ctx context.Context, deployment *appsv1.Deplo
 			}
 			err = updatePodSpecWithInternalLoadBalancerKubeService(
 				&deployment.Spec.Template.Spec,
-				[]string{"cluster-version-operator"},
+				[]string{external.DefaultContainerName},
 				lbHost,
 				lbPort,
 			)

pkg/cvo/sync_worker.go

@@ -26,6 +26,7 @@ import (
 	configv1 "github.com/openshift/api/config/v1"
 
 	"github.com/openshift/cluster-version-operator/lib/capability"
+	"github.com/openshift/cluster-version-operator/pkg/internal"
 	"github.com/openshift/cluster-version-operator/pkg/payload"
 	"github.com/openshift/cluster-version-operator/pkg/payload/precondition"
 )
@@ -329,7 +330,7 @@ func (w *SyncWorker) syncPayload(ctx context.Context, work *SyncWork) ([]configv
 	// The remainder of this logic is for loading a new payload.
 	// Any filtering as to not needing to reload the payload should be done in the switch before this point.
 
-	cvoObjectRef := &corev1.ObjectReference{APIVersion: "config.openshift.io/v1", Kind: "ClusterVersion", Name: "version", Namespace: "openshift-cluster-version"}
+	cvoObjectRef := &corev1.ObjectReference{APIVersion: "config.openshift.io/v1", Kind: "ClusterVersion", Name: internal.DefaultClusterVersionName, Namespace: internal.DefaultCVONamespace}
 	msg := fmt.Sprintf("Retrieving and verifying payload version=%q image=%q", desired.Version, desired.Image)
 	w.eventRecorder.Eventf(cvoObjectRef, corev1.EventTypeNormal, "RetrievePayload", msg)
 	reporter.ReportPayload(LoadPayloadStatus{

pkg/external/constants.go

@@ -0,0 +1,21 @@
+package external
+
+import "github.com/openshift/cluster-version-operator/pkg/internal"
+
+// The constants defined here are used by the components, e.g., e2e tests that have no access
+// to github.com/openshift/cluster-version-operator/pkg/internal
+// See https://pkg.go.dev/cmd/go#hdr-Internal_Directories
+const (
+	// DefaultCVONamespace is the default namespace for the Cluster Version Operator
+	DefaultCVONamespace = internal.DefaultCVONamespace
+	// DefaultClusterVersionName is the default name for the Cluster Version resource managed by the Cluster Version Operator
+	DefaultClusterVersionName = internal.DefaultClusterVersionName
+	// DefaultDeploymentName is the default name of the deployment for the Cluster Version Operator
+	DefaultDeploymentName = internal.DefaultDeploymentName
+	// DefaultContainerName is the default container name in the deployment for the Cluster Version Operator
+	DefaultContainerName = internal.DefaultContainerName
+
+	// ConditionalUpdateConditionTypeRecommended is a type of the condition present on a conditional update
+	// that indicates whether the conditional update is recommended or not
+	ConditionalUpdateConditionTypeRecommended = internal.ConditionalUpdateConditionTypeRecommended
+)

pkg/internal/constants.go

@@ -7,6 +7,15 @@ import (
 )
 
 const (
+	// DefaultCVONamespace is the default namespace for the Cluster Version Operator
+	DefaultCVONamespace = "openshift-cluster-version"
+	// DefaultClusterVersionName is the default name for the Cluster Version resource managed by the Cluster Version Operator
+	DefaultClusterVersionName = "version"
+	// DefaultDeploymentName is the default name of the deployment for the Cluster Version Operator
+	DefaultDeploymentName = "cluster-version-operator"
+	// DefaultContainerName is the default container name in the deployment for the Cluster Version Operator
+	DefaultContainerName = DefaultDeploymentName
+
 	ConfigNamespace        = "openshift-config"
 	ConfigManagedNamespace = "openshift-config-managed"
 	AdminGatesConfigMap    = "admin-gates"

pkg/start/start.go

@@ -49,9 +49,6 @@ import (
 )
 
 const (
-	defaultComponentName      = "version"
-	defaultComponentNamespace = "openshift-cluster-version"
-
 	minResyncPeriod = 2 * time.Minute
 )
 
@@ -122,8 +119,8 @@ func NewOptions() *Options {
 		PromQLTarget:        defaultPromQLTarget,
 
 		// exposed only for testing
-		Namespace:       defaultEnv("CVO_NAMESPACE", defaultComponentNamespace),
-		Name:            defaultEnv("CVO_NAME", defaultComponentName),
+		Namespace:       defaultEnv("CVO_NAMESPACE", internal.DefaultCVONamespace),
+		Name:            defaultEnv("CVO_NAME", internal.DefaultClusterVersionName),
 		PayloadOverride: os.Getenv("PAYLOAD_OVERRIDE"),
 		ResyncInterval:  minResyncPeriod,
 		Exclude:         os.Getenv("EXCLUDE_MANIFESTS"),

test/cvo/accept_risks.go

@@ -0,0 +1,140 @@
+package cvo
+
+import (
+	"context"
+	"time"
+
+	g "github.com/onsi/ginkgo/v2"
+	o "github.com/onsi/gomega"
+
+	configv1 "github.com/openshift/api/config/v1"
+	configv1client "github.com/openshift/client-go/config/clientset/versioned/typed/config/v1"
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/sets"
+	"k8s.io/apimachinery/pkg/util/wait"
+	"k8s.io/client-go/rest"
+
+	"github.com/openshift/cluster-version-operator/pkg/external"
+	"github.com/openshift/cluster-version-operator/test/util"
+)
+
+var _ = g.Describe(`[Jira:"Cluster Version Operator"] cluster-version-operator`, func() {
+
+	var (
+		c            *rest.Config
+		configClient *configv1client.ConfigV1Client
+		err          error
+
+		ctx    = context.TODO()
+		backup configv1.ClusterVersionSpec
+	)
+
+	g.BeforeEach(func() {
+		c, err = util.GetRestConfig()
+		o.Expect(err).To(o.BeNil())
+		configClient, err = configv1client.NewForConfig(c)
+		o.Expect(err).To(o.BeNil())
+
+		util.SkipIfNotTechPreviewNoUpgrade(ctx, c)
+		o.Expect(util.SkipIfHypershift(ctx, c)).To(o.BeNil())
+		o.Expect(util.SkipIfMicroshift(ctx, c)).To(o.BeNil())
+
+		cv, err := configClient.ClusterVersions().Get(ctx, external.DefaultClusterVersionName, metav1.GetOptions{})
+		o.Expect(err).NotTo(o.HaveOccurred())
+		if du := cv.Spec.DesiredUpdate; du != nil {
+			logger.WithValues("AcceptRisks", du.AcceptRisks).Info("Accept risks before testing")
+			o.Expect(du.AcceptRisks).To(o.BeEmpty(), "found accept risks")
+		}
+		backup = *cv.Spec.DeepCopy()
+	})
+
+	g.AfterEach(func() {
+		cv, err := configClient.ClusterVersions().Get(ctx, external.DefaultClusterVersionName, metav1.GetOptions{})
+		o.Expect(err).NotTo(o.HaveOccurred())
+		cv.Spec = backup
+		_, err = configClient.ClusterVersions().Update(ctx, cv, metav1.UpdateOptions{})
+		o.Expect(err).NotTo(o.HaveOccurred())
+	})
+
+	g.It("should work with accept risks", g.Label("Serial"), func() {
+		cv, err := configClient.ClusterVersions().Get(ctx, external.DefaultClusterVersionName, metav1.GetOptions{})
+		o.Expect(err).NotTo(o.HaveOccurred())
+
+		g.By("Using fauxinnati as the upstream and its risks-always channel")
+		cv.Spec.Upstream = util.FauxinnatiAPIURL
+		cv.Spec.Channel = "risks-always"
+
+		_, err = configClient.ClusterVersions().Update(ctx, cv, metav1.UpdateOptions{})
+		o.Expect(err).NotTo(o.HaveOccurred())
+
+		g.By("Checking that conditional updates shows up in status")
+		// waiting for the conditional updates to show up
+		o.Expect(wait.PollUntilContextTimeout(ctx, 30*time.Second, 5*time.Minute, true, func(ctx context.Context) (done bool, err error) {
+			cv, err = configClient.ClusterVersions().Get(ctx, external.DefaultClusterVersionName, metav1.GetOptions{})
+			o.Expect(err).NotTo(o.HaveOccurred())
+			if len(cv.Status.ConditionalUpdates) == 0 {
+				return false, nil
+			}
+			return true, nil
+		})).NotTo(o.HaveOccurred(), "no conditional updates found in status")
+
+		g.By("Checking that no conditional updates are recommended")
+		conditionalUpdatesLength := len(cv.Status.ConditionalUpdates)
+		var acceptRisks []configv1.AcceptRisk
+		var releases []configv1.Release
+		names := sets.New[string]()
+		for _, cu := range cv.Status.ConditionalUpdates {
+			releases = append(releases, cu.Release)
+			o.Expect(cu.RiskNames).NotTo(o.BeEmpty())
+			for _, name := range cu.RiskNames {
+				if names.Has(name) {
+					continue
+				}
+				names.Insert(name)
+				acceptRisks = append(acceptRisks, configv1.AcceptRisk{Name: name})
+			}
+			o.Expect(cu.Risks).NotTo(o.BeEmpty())
+			recommendedCondition := meta.FindStatusCondition(cu.Conditions, external.ConditionalUpdateConditionTypeRecommended)
+			o.Expect(recommendedCondition).NotTo(o.BeNil())
+			o.Expect(recommendedCondition.Status).To(o.Equal(metav1.ConditionFalse))
+		}
+
+		g.By("Accepting all risks")
+		o.Expect(acceptRisks).NotTo(o.BeEmpty())
+		if cv.Spec.DesiredUpdate == nil {
+			cv.Spec.DesiredUpdate = &configv1.Update{
+				Image:        cv.Status.Desired.Image,
+				Version:      cv.Status.Desired.Version,
+				Architecture: cv.Status.Desired.Architecture,
+			}
+		}
+		cv.Spec.DesiredUpdate.AcceptRisks = acceptRisks
+
+		_, err = configClient.ClusterVersions().Update(ctx, cv, metav1.UpdateOptions{})
+		o.Expect(err).NotTo(o.HaveOccurred())
+
+		g.By("Checking that all conditional updates are recommended")
+		var releasesNow []configv1.Release
+		// waiting for the conditional updates to be refreshed
+		o.Expect(wait.PollUntilContextTimeout(ctx, 30*time.Second, 5*time.Minute, true, func(ctx context.Context) (done bool, err error) {
+			cv, err = configClient.ClusterVersions().Get(ctx, external.DefaultClusterVersionName, metav1.GetOptions{})
+			o.Expect(err).NotTo(o.HaveOccurred())
+			o.Expect(cv.Status.ConditionalUpdates).NotTo(o.BeEmpty())
+			releasesNow = nil
+			for _, cu := range cv.Status.ConditionalUpdates {
+				releasesNow = append(releasesNow, cu.Release)
+				recommendedCondition := meta.FindStatusCondition(cu.Conditions, external.ConditionalUpdateConditionTypeRecommended)
+				o.Expect(recommendedCondition).NotTo(o.BeNil())
+				if recommendedCondition.Status != metav1.ConditionTrue {
+					return false, nil
+				}
+			}
+			return true, nil
+		})).NotTo(o.HaveOccurred(), "no conditional updates are recommended in status after accepting risks")
+
+		o.Expect(cv.Spec.DesiredUpdate.AcceptRisks).To(o.Equal(acceptRisks))
+		o.Expect(cv.Status.ConditionalUpdates).To(o.HaveLen(conditionalUpdatesLength))
+		o.Expect(releasesNow).To(o.Equal(releases))
+	})
+})

test/cvo/cvo.go

@@ -1,3 +1,5 @@
+// Package cvo contains end-to-end tests for the Cluster Version Operator.
+// The accept_risks test validates the feature about accept risks for conditional updates.
 package cvo
 
 import (
@@ -10,15 +12,14 @@ import (
 	g "github.com/onsi/ginkgo/v2"
 	o "github.com/onsi/gomega"
 
+	"github.com/openshift/cluster-version-operator/pkg/external"
 	"github.com/openshift/cluster-version-operator/test/oc"
 	ocapi "github.com/openshift/cluster-version-operator/test/oc/api"
 	"github.com/openshift/cluster-version-operator/test/util"
 )
 
 var logger = g.GinkgoLogr.WithName("cluster-version-operator-tests")
 
-const cvoNamespace = "openshift-cluster-version"
-
 var _ = g.Describe(`[Jira:"Cluster Version Operator"] cluster-version-operator-tests`, func() {
 	g.It("should support passing tests", func() {
 		o.Expect(true).To(o.BeTrue())
@@ -66,14 +67,14 @@ var _ = g.Describe(`[Jira:"Cluster Version Operator"] cluster-version-operator`,
 		o.Expect(err).NotTo(o.HaveOccurred(), "Failed to determine if cluster is MicroShift")
 
 		g.By("Checking that the 'openshift.io/run-level' label exists on the namespace and has the empty value")
-		ns, err := kubeClient.CoreV1().Namespaces().Get(ctx, cvoNamespace, metav1.GetOptions{})
-		o.Expect(err).NotTo(o.HaveOccurred(), "Failed to get namespace %s", cvoNamespace)
+		ns, err := kubeClient.CoreV1().Namespaces().Get(ctx, external.DefaultCVONamespace, metav1.GetOptions{})
+		o.Expect(err).NotTo(o.HaveOccurred(), "Failed to get namespace %s", external.DefaultCVONamespace)
 		runLevel, exists := ns.Labels["openshift.io/run-level"]
-		o.Expect(exists).To(o.BeTrue(), "The 'openshift.io/run-level' label on namespace %s does not exist", cvoNamespace)
-		o.Expect(runLevel).To(o.BeEmpty(), "Expected the 'openshift.io/run-level' label value on namespace %s has the empty value, but got %s", cvoNamespace, runLevel)
+		o.Expect(exists).To(o.BeTrue(), "The 'openshift.io/run-level' label on namespace %s does not exist", external.DefaultCVONamespace)
+		o.Expect(runLevel).To(o.BeEmpty(), "Expected the 'openshift.io/run-level' label value on namespace %s has the empty value, but got %s", external.DefaultCVONamespace, runLevel)
 
 		g.By("Checking that the annotation 'openshift.io/scc annotation' on the CVO pod has the value hostaccess")
-		podList, err := kubeClient.CoreV1().Pods(cvoNamespace).List(ctx, metav1.ListOptions{
+		podList, err := kubeClient.CoreV1().Pods(external.DefaultCVONamespace).List(ctx, metav1.ListOptions{
 			LabelSelector: "k8s-app=cluster-version-operator",
 			FieldSelector: "status.phase=Running",
 		})

test/util/util.go

@@ -5,6 +5,8 @@ import (
 	"time"
 
 	g "github.com/onsi/ginkgo/v2"
+	o "github.com/onsi/gomega"
+
 	configv1 "github.com/openshift/api/config/v1"
 	clientconfigv1 "github.com/openshift/client-go/config/clientset/versioned"
 	corev1 "k8s.io/api/core/v1"
@@ -106,3 +108,29 @@ func GetKubeClient(restConfig *rest.Config) (kubernetes.Interface, error) {
 func GetConfigClient(restConfig *rest.Config) (clientconfigv1.Interface, error) {
 	return clientconfigv1.NewForConfig(restConfig)
 }
+
+// IsTechPreviewNoUpgrade checks if a cluster is a TechPreviewNoUpgrade cluster
+func IsTechPreviewNoUpgrade(ctx context.Context, restConfig *rest.Config) bool {
+	configClient, err := GetConfigClient(restConfig)
+	o.Expect(err).NotTo(o.HaveOccurred())
+	featureGate, err := configClient.ConfigV1().FeatureGates().Get(ctx, "cluster", metav1.GetOptions{})
+	if err != nil {
+		if apierrors.IsNotFound(err) {
+			return false
+		}
+		o.Expect(err).NotTo(o.HaveOccurred(), "could not retrieve feature-gate: %v", err)
+	}
+	return featureGate.Spec.FeatureSet == configv1.TechPreviewNoUpgrade
+}
+
+// SkipIfNotTechPreviewNoUpgrade skips the test if a cluster is not a TechPreviewNoUpgrade cluster
+func SkipIfNotTechPreviewNoUpgrade(ctx context.Context, restConfig *rest.Config) {
+	if !IsTechPreviewNoUpgrade(ctx, restConfig) {
+		g.Skip("This test is skipped because the Tech Preview NoUpgrade is not enabled")
+	}
+}
+
+const (
+	// fauxinnati mocks Cincinnati Update Graph Server for OpenShift
+	FauxinnatiAPIURL = "https://fauxinnati-fauxinnati.apps.ota-stage.q2z4.p1.openshiftapps.com/api/upgrades_info/graph"
+)