Add olmv1 webhook support origin tests

Signed-off-by: Per Goncalves da Silva <[email protected]>

Author: Per Goncalves da Silva

test/extended/olm/olmv1-webhook-support.go

@@ -0,0 +1,257 @@
+package operators
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"path/filepath"
+	"time"
+
+	g "github.com/onsi/ginkgo/v2"
+	o "github.com/onsi/gomega"
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/wait"
+
+	exutil "github.com/openshift/origin/test/extended/util"
+)
+
+const (
+	conditionTypeServing   = "Serving"
+	conditionTypeInstalled = "Installed"
+)
+
+var (
+	webhookTestBaseDir = exutil.FixturePath("testdata", "olmv1", "webhook-support")
+)
+
+var _ = g.Describe("[sig-olmv1][OCPFeatureGate:NewOLMWebhookProviderOpenshiftServiceCA][Skipped:Disconnected] OLMv1 support for bundles with webhooks", g.Ordered, func() {
+	var (
+		cleanUpCatalog, cleanUpExtension = func() {}, func() {}
+	)
+	defer g.GinkgoRecover()
+
+	oc := exutil.NewCLI("openshift-operator-controller")
+
+	g.BeforeAll(func(ctx g.SpecContext) {
+		checkFeatureCapability(oc)
+		cleanUpCatalog = installWebhookOperatorClusterCatalog(ctx, oc)
+		cleanUpExtension = installWebhookOperator(ctx, oc)
+	})
+
+	g.BeforeEach(func() {
+		exutil.PreTestDump()
+	})
+
+	g.AfterEach(func() {
+		if g.CurrentSpecReport().Failed() {
+			exutil.DumpPodLogsStartingWith("", oc)
+		}
+	})
+
+	g.AfterAll(func(ctx g.SpecContext) {
+		cleanUpExtension()
+		cleanUpCatalog()
+	})
+
+	g.It("should have working validating webhook", func(ctx g.SpecContext) {
+		g.By("creating a webhook test resource that will be rejected by the validating webhook")
+		file := filepath.Join(webhookTestBaseDir, "webhook-test-validating-reject.yaml")
+		_, err := applyResourceFileByPath(oc, file)
+		o.Expect(err).To(o.HaveOccurred())
+
+		g.By("validating the error message")
+		o.Expect(err.Error()).To(o.ContainSubstring("Invalid value: false: Spec.Valid must be true"))
+	})
+
+	g.It("should have working mutating webhook", func(ctx g.SpecContext) {
+		g.By("creating a valid webhook test resource")
+		file := filepath.Join(webhookTestBaseDir, "webhook-test-accept.yaml")
+		cleanup, err := applyResourceFileByPath(oc, file)
+		g.DeferCleanup(cleanup)
+		o.Expect(err).ToNot(o.HaveOccurred())
+
+		g.By("getting the created resource in v1 schema")
+		obj, err := getWebhookTestResource(ctx, oc, "v1", "webhook-test")
+		o.Expect(err).ToNot(o.HaveOccurred())
+		o.Expect(obj).ToNot(o.BeNil())
+
+		g.By("validating the resource spec")
+		spec := obj.Object["spec"].(map[string]interface{})
+		o.Expect(spec).To(o.Equal(map[string]interface{}{
+			"valid":  true,
+			"mutate": true,
+		}))
+	})
+
+	g.It("should have working conversion webhook", func(ctx g.SpecContext) {
+		file := filepath.Join(webhookTestBaseDir, "webhook-test-accept.yaml")
+		g.By("creating a valid webhook test resource")
+		cleanup, err := applyResourceFileByPath(oc, file)
+		g.DeferCleanup(cleanup)
+		o.Expect(err).ToNot(o.HaveOccurred())
+
+		g.By("getting the created resource in v2 schema")
+		obj, err := getWebhookTestResource(ctx, oc, "v2", "webhook-test")
+		o.Expect(err).ToNot(o.HaveOccurred())
+		o.Expect(obj).ToNot(o.BeNil())
+
+		g.By("validating the resource spec")
+		spec := obj.Object["spec"].(map[string]interface{})
+		o.Expect(spec).To(o.Equal(map[string]interface{}{
+			"conversion": map[string]interface{}{
+				"valid":  true,
+				"mutate": true,
+			},
+		}))
+	})
+
+	g.It("should have cert secret", func(ctx g.SpecContext) {
+
+	})
+
+	g.It("should do one last thing for some reason", func(ctx g.SpecContext) {
+
+	})
+})
+
+func installWebhookOperatorClusterCatalog(ctx g.SpecContext, oc *exutil.CLI) func() {
+	webhookCatalogYaml := filepath.Join(webhookTestBaseDir, "webhook-operator-catalog.yaml")
+	cleanup, err := applyResourceFileByPath(oc, webhookCatalogYaml)
+	o.Expect(err).NotTo(o.HaveOccurred())
+
+	g.By("waiting for the webhook-operator ClusterCatalog to be serving")
+	var lastReason string
+	err = wait.PollUntilContextTimeout(ctx, 5*time.Second, 5*time.Minute, true,
+		func(ctx context.Context) (bool, error) {
+			isDone, err, status := checkWebhookCatalogServing(oc)
+			if lastReason != status {
+				g.GinkgoLogr.Info(fmt.Sprintf("waitForWebhookOperatorCatalogServing: %q", status))
+				lastReason = status
+			}
+			return isDone, err
+		})
+	o.Expect(lastReason).To(o.BeEmpty())
+	o.Expect(err).NotTo(o.HaveOccurred())
+	return cleanup
+}
+
+func installWebhookOperator(ctx g.SpecContext, oc *exutil.CLI) func() {
+	file := filepath.Join(webhookTestBaseDir, "webhook-operator.yaml")
+	cleanup, err := applyResourceFileByPath(oc, file)
+	o.Expect(err).NotTo(o.HaveOccurred())
+
+	g.By("waiting for the webhook-operator bundle to be installed")
+	var lastReason string
+	err = wait.PollUntilContextTimeout(ctx, 5*time.Second, 5*time.Minute, true,
+		func(ctx context.Context) (bool, error) {
+			isDone, err, status := checkWebhookOperatorInstalled(oc)
+			if lastReason != status {
+				g.GinkgoLogr.Info(fmt.Sprintf("waitForWebhookOperatorInstalled: %q", status))
+				lastReason = status
+			}
+			return isDone, err
+		})
+	o.Expect(lastReason).To(o.BeEmpty())
+	o.Expect(err).NotTo(o.HaveOccurred())
+	return cleanup
+}
+
+func applyResourceFileByPath(oc *exutil.CLI, filePath string) (func(), error) {
+	g.By(fmt.Sprintf("applying the necessary %q resources", filePath))
+	err := oc.AsAdmin().WithoutNamespace().Run("apply").Args("-f", filePath).Execute()
+	return func() {
+		g.By(fmt.Sprintf("cleaning the necessary %q resources", filePath))
+		err := oc.AsAdmin().WithoutNamespace().Run("delete").Args("-f", filePath).Execute()
+		o.Expect(err).NotTo(o.HaveOccurred())
+	}, err
+}
+
+func checkWebhookCatalogServing(oc *exutil.CLI) (bool, error, string) {
+	cmdArgs := []string{
+		"clustercatalogs.olm.operatorframework.io",
+		"webhook-operator-catalog",
+		"-o=jsonpath={.status.conditions}",
+	}
+
+	output, err := oc.AsAdmin().WithoutNamespace().Run("get").Args(cmdArgs...).Output()
+	if err != nil {
+		return false, err, ""
+	}
+	// no data yet, so try again
+	if output == "" {
+		return false, nil, "no output"
+	}
+
+	var conditions []metav1.Condition
+	if err := json.Unmarshal([]byte(output), &conditions); err != nil {
+		return false, fmt.Errorf("error in json.Unmarshal(%v): %v", output, err), ""
+	}
+	c := meta.FindStatusCondition(conditions, conditionTypeServing)
+	if c == nil {
+		return false, nil, fmt.Sprintf("condition not present: %q", conditionTypeServing)
+	}
+	if c.Status != metav1.ConditionTrue {
+		return false, nil, fmt.Sprintf("expected status to be %q: %+v", metav1.ConditionTrue, c)
+	}
+	return true, nil, ""
+}
+
+func checkWebhookOperatorInstalled(oc *exutil.CLI) (bool, error, string) {
+	cmdArgs := []string{
+		"clusterextensions.olm.operatorframework.io",
+		"webhook-operator",
+		"-o=jsonpath={.status.conditions}",
+	}
+
+	output, err := oc.AsAdmin().WithoutNamespace().Run("get").Args(cmdArgs...).Output()
+	if err != nil {
+		return false, err, ""
+	}
+	// no data yet, so try again
+	if output == "" {
+		return false, nil, "no output"
+	}
+
+	var conditions []metav1.Condition
+	if err := json.Unmarshal([]byte(output), &conditions); err != nil {
+		return false, fmt.Errorf("error in json.Unmarshal(%v): %v", output, err), ""
+	}
+	c := meta.FindStatusCondition(conditions, conditionTypeInstalled)
+	if c == nil {
+		return false, nil, fmt.Sprintf("condition not present: %q", conditionTypeInstalled)
+	}
+	if c.Status != metav1.ConditionTrue {
+		return false, nil, fmt.Sprintf("expected status to be %q: %+v", metav1.ConditionTrue, c)
+	}
+	return true, nil, ""
+}
+
+func getWebhookTestResource(ctx g.SpecContext, oc *exutil.CLI, name, version string) (*unstructured.Unstructured, error) {
+	return getResource(ctx, oc, fmt.Sprintf("webhooktests.%s.webhook.operators.coreos.io", version), "webhook-operator", name)
+}
+
+func getResource(ctx g.SpecContext, oc *exutil.CLI, kind, namespace, name string) (*unstructured.Unstructured, error) {
+	var obj *unstructured.Unstructured
+	return obj, wait.PollUntilContextTimeout(ctx, 5*time.Second, 5*time.Minute, true,
+		func(ctx context.Context) (bool, error) {
+			cmdArgs := []string{
+				kind,
+				name,
+				fmt.Sprintf("--namespace='%s'", namespace),
+				"-o=json",
+			}
+
+			output, err := oc.AsAdmin().WithoutNamespace().Run("get").Args(cmdArgs...).Output()
+			if err != nil {
+				g.GinkgoLogr.Info(fmt.Sprintf("error getting resource kind='%s' namespace='%s' name='%s': %q", kind, namespace, name, err))
+				return false, err
+			}
+			if err := json.Unmarshal([]byte(output), obj); err != nil {
+				g.GinkgoLogr.Info(fmt.Sprintf("error unmarshalling kind='%s' namespace='%s' name='%s': %q", kind, namespace, name, err))
+				return false, fmt.Errorf("error in json.Unmarshal(%v): %v", output, err)
+			}
+			return true, nil
+		})
+}