Make webhook support e2es more robust

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

Author: Per Goncalves da Silva

test/experimental-e2e/experimental_e2e_test.go

@@ -2,7 +2,6 @@ package experimental_e2e
 
 import (
 	"context"
-	"fmt"
 	"os"
 	"testing"
 	"time"
@@ -119,7 +118,8 @@ func TestWebhookSupport(t *testing.T) {
 			Source: ocv1.CatalogSource{
 				Type: ocv1.SourceTypeImage,
 				Image: &ocv1.ImageSource{
-					Ref:                 fmt.Sprintf("%s/e2e/test-catalog:v1", os.Getenv("LOCAL_REGISTRY_HOST")),
+					// Ref:                 fmt.Sprintf("%s/e2e/test-catalog:v1", os.Getenv("LOCAL_REGISTRY_HOST")),
+					Ref:                 "quay.io/operator-framework/webhook-operator-index:0.0.3",
 					PollIntervalMinutes: ptr.To(1),
 				},
 			},
@@ -132,11 +132,11 @@ func TestWebhookSupport(t *testing.T) {
 
 	t.Log("By waiting for the catalog to serve its metadata")
 	require.EventuallyWithT(t, func(ct *assert.CollectT) {
-		assert.NoError(t, c.Get(context.Background(), types.NamespacedName{Name: extensionCatalog.GetName()}, extensionCatalog))
+		require.NoError(ct, c.Get(context.Background(), types.NamespacedName{Name: extensionCatalog.GetName()}, extensionCatalog))
 		cond := apimeta.FindStatusCondition(extensionCatalog.Status.Conditions, ocv1.TypeServing)
-		assert.NotNil(t, cond)
-		assert.Equal(t, metav1.ConditionTrue, cond.Status)
-		assert.Equal(t, ocv1.ReasonAvailable, cond.Reason)
+		require.NotNil(ct, cond)
+		require.Equal(ct, metav1.ConditionTrue, cond.Status)
+		require.Equal(ct, ocv1.ReasonAvailable, cond.Reason)
 	}, pollDuration, pollInterval)
 
 	t.Log("By installing the webhook-operator ClusterExtension")
@@ -167,27 +167,27 @@ func TestWebhookSupport(t *testing.T) {
 
 	t.Log("By waiting for webhook-operator extension to be installed successfully")
 	require.EventuallyWithT(t, func(ct *assert.CollectT) {
-		assert.NoError(ct, c.Get(t.Context(), types.NamespacedName{Name: clusterExtension.Name}, clusterExtension))
+		require.NoError(ct, c.Get(t.Context(), types.NamespacedName{Name: clusterExtension.Name}, clusterExtension))
 		cond := apimeta.FindStatusCondition(clusterExtension.Status.Conditions, ocv1.TypeInstalled)
-		if assert.NotNil(ct, cond) {
-			assert.Equal(ct, metav1.ConditionTrue, cond.Status)
-			assert.Equal(ct, ocv1.ReasonSucceeded, cond.Reason)
-			assert.Contains(ct, cond.Message, "Installed bundle")
-			assert.NotEmpty(ct, clusterExtension.Status.Install.Bundle)
-		}
+		require.NotNil(ct, cond)
+		require.Equal(ct, metav1.ConditionTrue, cond.Status)
+		require.Equal(ct, ocv1.ReasonSucceeded, cond.Reason)
+		require.Contains(ct, cond.Message, "Installed bundle")
+		require.NotNil(ct, clusterExtension.Status.Install)
+		require.NotEmpty(ct, clusterExtension.Status.Install.Bundle)
 	}, pollDuration, pollInterval)
 
 	t.Log("By waiting for webhook-operator deployment to be available")
 	require.EventuallyWithT(t, func(ct *assert.CollectT) {
 		deployment := &appsv1.Deployment{}
-		assert.NoError(ct, c.Get(t.Context(), types.NamespacedName{Namespace: namespace.GetName(), Name: "webhook-operator-webhook"}, deployment))
+		require.NoError(ct, c.Get(t.Context(), types.NamespacedName{Namespace: namespace.GetName(), Name: "webhook-operator-webhook"}, deployment))
 		available := false
 		for _, cond := range deployment.Status.Conditions {
 			if cond.Type == appsv1.DeploymentAvailable {
 				available = cond.Status == corev1.ConditionTrue
 			}
 		}
-		assert.True(ct, available)
+		require.True(ct, available)
 	}, pollDuration, pollInterval)
 
 	v1Gvr := schema.GroupVersionResource{
@@ -197,21 +197,29 @@ func TestWebhookSupport(t *testing.T) {
 	}
 	v1Client := dynamicClient.Resource(v1Gvr).Namespace(namespace.GetName())
 
-	t.Log("By checking an invalid CR is rejected by the validating webhook")
-	obj := getWebhookOperatorResource("invalid-test-cr", namespace.GetName(), false)
-	_, err := v1Client.Create(t.Context(), obj, metav1.CreateOptions{})
-	require.Error(t, err)
-	require.Contains(t, err.Error(), "Invalid value: false: Spec.Valid must be true")
+	t.Log("By eventually seeing that invalid CR creation is rejected by the validating webhook")
+	require.EventuallyWithT(t, func(ct *assert.CollectT) {
+		obj := getWebhookOperatorResource("invalid-test-cr", namespace.GetName(), false)
+		_, err := v1Client.Create(t.Context(), obj, metav1.CreateOptions{})
+		require.Error(ct, err)
+		require.Contains(ct, err.Error(), "Invalid value: false: Spec.Valid must be true")
+	}, pollDuration, pollInterval)
 
-	t.Log("By checking a valid CR is mutated by the mutating webhook")
-	obj = getWebhookOperatorResource("valid-test-cr", namespace.GetName(), true)
-	_, err = v1Client.Create(t.Context(), obj, metav1.CreateOptions{})
-	require.NoError(t, err)
+	var (
+		res *unstructured.Unstructured
+		err error
+		obj = getWebhookOperatorResource("valid-test-cr", namespace.GetName(), true)
+	)
+
+	t.Log("By eventually creating a valid CR")
+	require.EventuallyWithT(t, func(ct *assert.CollectT) {
+		res, err = v1Client.Create(t.Context(), obj, metav1.CreateOptions{})
+		require.NoError(ct, err)
+	}, pollDuration, pollInterval)
 	t.Cleanup(func() {
-		require.NoError(t, dynamicClient.Resource(v1Gvr).Namespace(namespace.GetName()).Delete(context.Background(), obj.GetName(), metav1.DeleteOptions{}))
+		require.NoError(t, v1Client.Delete(context.Background(), obj.GetName(), metav1.DeleteOptions{}))
 	})
-	res, err := v1Client.Get(t.Context(), obj.GetName(), metav1.GetOptions{})
-	require.NoError(t, err)
+
 	require.Equal(t, map[string]interface{}{
 		"valid":  true,
 		"mutate": true,
@@ -225,8 +233,13 @@ func TestWebhookSupport(t *testing.T) {
 	}
 	v2Client := dynamicClient.Resource(v2Gvr).Namespace(namespace.GetName())
 
-	res, err = v2Client.Get(t.Context(), obj.GetName(), metav1.GetOptions{})
-	require.NoError(t, err)
+	t.Log("By eventually getting the valid CR with a v2 client")
+	require.EventuallyWithT(t, func(ct *assert.CollectT) {
+		res, err = v2Client.Get(t.Context(), obj.GetName(), metav1.GetOptions{})
+		require.NoError(ct, err)
+	}, pollDuration, pollInterval)
+
+	t.Log("and verifying that the CR is correctly converted")
 	require.Equal(t, map[string]interface{}{
 		"conversion": map[string]interface{}{
 			"valid":  true,