Automate OCP-42543: should not install resources annotated with release.openshift.io/delete=true

Author: JianLi-RH

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

@@ -28,5 +28,19 @@
     "source": "openshift:payload:cluster-version-operator",
     "lifecycle": "blocking",
     "environmentSelector": {}
+  },
+  {
+    "name": "[Jira:\"Cluster Version Operator\"] cluster-version-operator should not install resources annotated with release.openshift.io/delete=true",
+    "labels": {
+      "42543": {},
+      "Conformance": {},
+      "High": {}
+    },
+    "resources": {
+      "isolation": {}
+    },
+    "source": "openshift:payload:cluster-version-operator",
+    "lifecycle": "blocking",
+    "environmentSelector": {}
   }
 ]

test/cvo/cvo.go

@@ -1,7 +1,12 @@
 package cvo
 
 import (
+	"bytes"
 	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes"
@@ -13,6 +18,7 @@ import (
 	"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"
+	"github.com/openshift/library-go/pkg/manifest"
 )
 
 var logger = g.GinkgoLogr.WithName("cluster-version-operator-tests")
@@ -80,4 +86,56 @@ var _ = g.Describe(`[Jira:"Cluster Version Operator"] cluster-version-operator`,
 		sccAnnotation := cvoPod.Annotations["openshift.io/scc"]
 		o.Expect(sccAnnotation).To(o.Equal("hostaccess"), "Expected the annotation 'openshift.io/scc annotation' on pod %s to have the value 'hostaccess', but got %s", cvoPod.Name, sccAnnotation)
 	})
+
+	g.It(`should not install resources annotated with release.openshift.io/delete=true`, g.Label("Conformance", "High", "42543"), func() {
+		// Initialize the ocapi.OC instance
+		g.By("Setting up oc")
+		err := os.Setenv("OC_CLI_TIMEOUT", "90s")
+		o.Expect(err).NotTo(o.HaveOccurred(), "Setup environment variable OC_CLI_TIMEOUT failed")
+		ocClient, err := oc.NewOC(logger)
+		o.Expect(err).NotTo(o.HaveOccurred())
+		o.Expect(ocClient).NotTo(o.BeNil())
+		defer func() {
+			err = os.Unsetenv("OC_CLI_TIMEOUT")
+			o.Expect(err).NotTo(o.HaveOccurred(), "Unset environment variable OC_CLI_TIMEOUT failed")
+		}()
+
+		g.By("Extracting manifests in the release")
+		annotation := "release.openshift.io/delete"
+		manifestDir := ocapi.ReleaseExtractOptions{To: "/tmp/OTA-42543-manifest"}
+		logger.Info(fmt.Sprintf("Extract manifests to: %s", manifestDir.To))
+		defer func() { _ = os.RemoveAll(manifestDir.To) }()
+		err = ocClient.AdmReleaseExtract(manifestDir)
+		o.Expect(err).NotTo(o.HaveOccurred(), "extracting manifests failed")
+
+		files, err := os.ReadDir(manifestDir.To)
+		o.Expect(err).NotTo(o.HaveOccurred())
+		g.By(fmt.Sprintf("Checking if getting manifests with %s on the cluster led to not-found error", annotation))
+		for _, manifestFile := range files {
+			if strings.Contains(strings.ToLower(manifestFile.Name()), "cleanup") {
+				logger.Info(fmt.Sprintf("skipping file %s because it matches cleanup filter", manifestFile.Name()))
+				continue
+			}
+
+			filePath := filepath.Join(manifestDir.To, manifestFile.Name())
+			raw, err := os.ReadFile(filePath)
+			if err != nil {
+				o.Expect(err).NotTo(o.HaveOccurred(), "failed to read manifest file")
+			}
+			manifests, err := manifest.ParseManifests(bytes.NewReader(raw))
+			if err != nil {
+				// files like release-metadata are not manifest file, so skip them
+				logger.Error(err, "failed to parse manifest file: "+filePath)
+			}
+
+			for _, ms := range manifests {
+				ann := ms.Obj.GetAnnotations()
+				if ann == nil || ann[annotation] != "true" {
+					continue
+				}
+				_, err := ocClient.Run("get", "-f", filePath)
+				o.Expect(err).To(o.HaveOccurred(), "The deleted manifest should not be installed, but actually installed")
+			}
+		}
+	})
 })

test/oc/api/api.go

@@ -11,4 +11,5 @@ type VersionOptions struct {
 type OC interface {
 	AdmReleaseExtract(o ReleaseExtractOptions) error
 	Version(o VersionOptions) (string, error)
+	Run(args ...string) ([]byte, error)
 }

test/oc/cli/cli.go

@@ -20,7 +20,7 @@ type client struct {
 }
 
 type executor interface {
-	Run(args ...string) ([]byte, error)
+	run(args ...string) ([]byte, error)
 }
 
 type ocExecutor struct {
@@ -32,7 +32,7 @@ type ocExecutor struct {
 	execute func(dir, command string, args ...string) ([]byte, error)
 }
 
-func (e *ocExecutor) Run(args ...string) ([]byte, error) {
+func (e *ocExecutor) run(args ...string) ([]byte, error) {
 	logger := e.logger.WithValues("cmd", e.oc, "args", strings.Join(args, " "))
 	b, err := e.execute("", e.oc, args...)
 	if err != nil {
@@ -70,12 +70,13 @@ func NewOCCli(logger logr.Logger) (api.OC, error) {
 	timeout := 30 * time.Second
 	timeoutStr := os.Getenv("OC_CLI_TIMEOUT")
 	if timeoutStr != "" {
+		logger.Info(fmt.Sprintf("will use the environment timeout variable to run command: %s", timeoutStr))
 		timeout, err = time.ParseDuration(timeoutStr)
 		if err != nil {
 			return nil, err
 		}
 	}
-
+	logger.Info(fmt.Sprintf("timeout is: %s", timeout))
 	executor, err := newOCExecutor(oc, timeout, logger)
 	if err != nil {
 		return nil, err
@@ -88,8 +89,17 @@ func NewOCCli(logger logr.Logger) (api.OC, error) {
 }
 
 func (c *client) AdmReleaseExtract(o api.ReleaseExtractOptions) error {
+	_, err := os.Stat(o.To)
+	if errors.Is(err, os.ErrNotExist) {
+		c.logger.Info(fmt.Sprintf("the output directory does not exist, will create it: %s", o.To))
+		if err = os.Mkdir(o.To, 0755); err != nil {
+			err = fmt.Errorf("failed to create directory: %v", err)
+			return err
+		}
+		c.logger.Info(fmt.Sprintf("the output directory has been created: %s", o.To))
+	}
 	args := []string{"adm", "release", "extract", fmt.Sprintf("--to=%s", o.To)}
-	_, err := c.executor.Run(args...)
+	_, err = c.executor.run(args...)
 	if err != nil {
 		return err
 	}
@@ -98,9 +108,13 @@ func (c *client) AdmReleaseExtract(o api.ReleaseExtractOptions) error {
 
 func (c *client) Version(o api.VersionOptions) (string, error) {
 	args := []string{"version", fmt.Sprintf("--client=%t", o.Client)}
-	output, err := c.executor.Run(args...)
+	output, err := c.executor.run(args...)
 	if err != nil {
 		return "", err
 	}
 	return string(output), nil
 }
+
+func (c *client) Run(args ...string) ([]byte, error) {
+	return c.executor.run(args...)
+}