|
| 1 | +package e2e |
| 2 | + |
| 3 | +import ( |
| 4 | + "context" |
| 5 | + "fmt" |
| 6 | + "os" |
| 7 | + "testing" |
| 8 | + |
| 9 | + "github.com/stretchr/testify/assert" |
| 10 | + "github.com/stretchr/testify/require" |
| 11 | + appsv1 "k8s.io/api/apps/v1" |
| 12 | + corev1 "k8s.io/api/core/v1" |
| 13 | + rbacv1 "k8s.io/api/rbac/v1" |
| 14 | + apimeta "k8s.io/apimachinery/pkg/api/meta" |
| 15 | + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" |
| 16 | + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" |
| 17 | + "k8s.io/apimachinery/pkg/runtime/schema" |
| 18 | + "k8s.io/apimachinery/pkg/types" |
| 19 | + "k8s.io/client-go/dynamic" |
| 20 | + "k8s.io/utils/ptr" |
| 21 | + |
| 22 | + ocv1 "github.com/operator-framework/operator-controller/api/v1" |
| 23 | + utils "github.com/operator-framework/operator-controller/internal/shared/util/testutils" |
| 24 | +) |
| 25 | + |
| 26 | +var dynamicClient dynamic.Interface |
| 27 | + |
| 28 | +func TestNoop(t *testing.T) { |
| 29 | + t.Log("Running experimental-e2e tests") |
| 30 | + defer utils.CollectTestArtifacts(t, artifactName, c, cfg) |
| 31 | +} |
| 32 | + |
| 33 | +func TestWebhookSupport(t *testing.T) { |
| 34 | + t.Log("Test support for bundles with webhooks") |
| 35 | + defer utils.CollectTestArtifacts(t, artifactName, c, cfg) |
| 36 | + |
| 37 | + if dynamicClient == nil { |
| 38 | + var err error |
| 39 | + dynamicClient, err = dynamic.NewForConfig(cfg) |
| 40 | + require.NoError(t, err) |
| 41 | + } |
| 42 | + |
| 43 | + t.Log("By creating install namespace, and necessary rbac resources") |
| 44 | + namespace := corev1.Namespace{ |
| 45 | + ObjectMeta: metav1.ObjectMeta{ |
| 46 | + Name: "webhook-operator", |
| 47 | + }, |
| 48 | + } |
| 49 | + require.NoError(t, c.Create(t.Context(), &namespace)) |
| 50 | + t.Cleanup(func() { |
| 51 | + require.NoError(t, c.Delete(context.Background(), &namespace)) |
| 52 | + }) |
| 53 | + |
| 54 | + serviceAccount := corev1.ServiceAccount{ |
| 55 | + ObjectMeta: metav1.ObjectMeta{ |
| 56 | + Name: "webhook-operator-installer", |
| 57 | + Namespace: namespace.GetName(), |
| 58 | + }, |
| 59 | + } |
| 60 | + require.NoError(t, c.Create(t.Context(), &serviceAccount)) |
| 61 | + t.Cleanup(func() { |
| 62 | + require.NoError(t, c.Delete(context.Background(), &serviceAccount)) |
| 63 | + }) |
| 64 | + |
| 65 | + clusterRoleBinding := &rbacv1.ClusterRoleBinding{ |
| 66 | + ObjectMeta: metav1.ObjectMeta{ |
| 67 | + Name: "webhook-operator-installer", |
| 68 | + }, |
| 69 | + Subjects: []rbacv1.Subject{ |
| 70 | + { |
| 71 | + Kind: "ServiceAccount", |
| 72 | + APIGroup: corev1.GroupName, |
| 73 | + Name: serviceAccount.GetName(), |
| 74 | + Namespace: serviceAccount.GetNamespace(), |
| 75 | + }, |
| 76 | + }, |
| 77 | + RoleRef: rbacv1.RoleRef{ |
| 78 | + APIGroup: rbacv1.GroupName, |
| 79 | + Kind: "ClusterRole", |
| 80 | + Name: "cluster-admin", |
| 81 | + }, |
| 82 | + } |
| 83 | + require.NoError(t, c.Create(t.Context(), clusterRoleBinding)) |
| 84 | + t.Cleanup(func() { |
| 85 | + require.NoError(t, c.Delete(context.Background(), clusterRoleBinding)) |
| 86 | + }) |
| 87 | + |
| 88 | + t.Log("By creating the webhook-operator ClusterCatalog") |
| 89 | + extensionCatalog := &ocv1.ClusterCatalog{ |
| 90 | + ObjectMeta: metav1.ObjectMeta{ |
| 91 | + Name: "webhook-operator-catalog", |
| 92 | + }, |
| 93 | + Spec: ocv1.ClusterCatalogSpec{ |
| 94 | + Source: ocv1.CatalogSource{ |
| 95 | + Type: ocv1.SourceTypeImage, |
| 96 | + Image: &ocv1.ImageSource{ |
| 97 | + Ref: fmt.Sprintf("%s/e2e/test-catalog:v1", os.Getenv("CLUSTER_REGISTRY_HOST")), |
| 98 | + PollIntervalMinutes: ptr.To(1), |
| 99 | + }, |
| 100 | + }, |
| 101 | + }, |
| 102 | + } |
| 103 | + require.NoError(t, c.Create(t.Context(), extensionCatalog)) |
| 104 | + t.Cleanup(func() { |
| 105 | + require.NoError(t, c.Delete(context.Background(), extensionCatalog)) |
| 106 | + }) |
| 107 | + |
| 108 | + t.Log("By waiting for the catalog to serve its metadata") |
| 109 | + require.EventuallyWithT(t, func(ct *assert.CollectT) { |
| 110 | + require.NoError(ct, c.Get(context.Background(), types.NamespacedName{Name: extensionCatalog.GetName()}, extensionCatalog)) |
| 111 | + cond := apimeta.FindStatusCondition(extensionCatalog.Status.Conditions, ocv1.TypeServing) |
| 112 | + require.NotNil(ct, cond) |
| 113 | + require.Equal(ct, metav1.ConditionTrue, cond.Status) |
| 114 | + require.Equal(ct, ocv1.ReasonAvailable, cond.Reason) |
| 115 | + }, pollDuration, pollInterval) |
| 116 | + |
| 117 | + t.Log("By installing the webhook-operator ClusterExtension") |
| 118 | + clusterExtension := &ocv1.ClusterExtension{ |
| 119 | + ObjectMeta: metav1.ObjectMeta{ |
| 120 | + Name: "webhook-operator-extension", |
| 121 | + }, |
| 122 | + Spec: ocv1.ClusterExtensionSpec{ |
| 123 | + Source: ocv1.SourceConfig{ |
| 124 | + SourceType: "Catalog", |
| 125 | + Catalog: &ocv1.CatalogFilter{ |
| 126 | + PackageName: "webhook-operator", |
| 127 | + Selector: &metav1.LabelSelector{ |
| 128 | + MatchLabels: map[string]string{"olm.operatorframework.io/metadata.name": extensionCatalog.Name}, |
| 129 | + }, |
| 130 | + }, |
| 131 | + }, |
| 132 | + Namespace: namespace.GetName(), |
| 133 | + ServiceAccount: ocv1.ServiceAccountReference{ |
| 134 | + Name: serviceAccount.GetName(), |
| 135 | + }, |
| 136 | + }, |
| 137 | + } |
| 138 | + require.NoError(t, c.Create(t.Context(), clusterExtension)) |
| 139 | + t.Cleanup(func() { |
| 140 | + require.NoError(t, c.Delete(context.Background(), clusterExtension)) |
| 141 | + }) |
| 142 | + |
| 143 | + t.Log("By waiting for webhook-operator extension to be installed successfully") |
| 144 | + require.EventuallyWithT(t, func(ct *assert.CollectT) { |
| 145 | + require.NoError(ct, c.Get(t.Context(), types.NamespacedName{Name: clusterExtension.Name}, clusterExtension)) |
| 146 | + cond := apimeta.FindStatusCondition(clusterExtension.Status.Conditions, ocv1.TypeInstalled) |
| 147 | + require.NotNil(ct, cond) |
| 148 | + require.Equal(ct, metav1.ConditionTrue, cond.Status) |
| 149 | + require.Equal(ct, ocv1.ReasonSucceeded, cond.Reason) |
| 150 | + require.Contains(ct, cond.Message, "Installed bundle") |
| 151 | + require.NotNil(ct, clusterExtension.Status.Install) |
| 152 | + require.NotEmpty(ct, clusterExtension.Status.Install.Bundle) |
| 153 | + }, pollDuration, pollInterval) |
| 154 | + |
| 155 | + t.Log("By waiting for webhook-operator deployment to be available") |
| 156 | + require.EventuallyWithT(t, func(ct *assert.CollectT) { |
| 157 | + deployment := &appsv1.Deployment{} |
| 158 | + require.NoError(ct, c.Get(t.Context(), types.NamespacedName{Namespace: namespace.GetName(), Name: "webhook-operator-controller-manager"}, deployment)) |
| 159 | + available := false |
| 160 | + for _, cond := range deployment.Status.Conditions { |
| 161 | + if cond.Type == appsv1.DeploymentAvailable { |
| 162 | + available = cond.Status == corev1.ConditionTrue |
| 163 | + } |
| 164 | + } |
| 165 | + require.True(ct, available) |
| 166 | + }, pollDuration, pollInterval) |
| 167 | + |
| 168 | + v1Gvr := schema.GroupVersionResource{ |
| 169 | + Group: "webhook.operators.coreos.io", |
| 170 | + Version: "v1", |
| 171 | + Resource: "webhooktests", |
| 172 | + } |
| 173 | + v1Client := dynamicClient.Resource(v1Gvr).Namespace(namespace.GetName()) |
| 174 | + |
| 175 | + t.Log("By eventually seeing that invalid CR creation is rejected by the validating webhook") |
| 176 | + require.EventuallyWithT(t, func(ct *assert.CollectT) { |
| 177 | + obj := getWebhookOperatorResource("invalid-test-cr", namespace.GetName(), false) |
| 178 | + _, err := v1Client.Create(t.Context(), obj, metav1.CreateOptions{}) |
| 179 | + require.Error(ct, err) |
| 180 | + require.Contains(ct, err.Error(), "Invalid value: false: Spec.Valid must be true") |
| 181 | + }, pollDuration, pollInterval) |
| 182 | + |
| 183 | + var ( |
| 184 | + res *unstructured.Unstructured |
| 185 | + err error |
| 186 | + obj = getWebhookOperatorResource("valid-test-cr", namespace.GetName(), true) |
| 187 | + ) |
| 188 | + |
| 189 | + t.Log("By eventually creating a valid CR") |
| 190 | + require.EventuallyWithT(t, func(ct *assert.CollectT) { |
| 191 | + res, err = v1Client.Create(t.Context(), obj, metav1.CreateOptions{}) |
| 192 | + require.NoError(ct, err) |
| 193 | + }, pollDuration, pollInterval) |
| 194 | + t.Cleanup(func() { |
| 195 | + require.NoError(t, v1Client.Delete(context.Background(), obj.GetName(), metav1.DeleteOptions{})) |
| 196 | + }) |
| 197 | + |
| 198 | + require.Equal(t, map[string]interface{}{ |
| 199 | + "valid": true, |
| 200 | + "mutate": true, |
| 201 | + }, res.Object["spec"]) |
| 202 | + |
| 203 | + t.Log("By checking a valid CR is converted to v2 by the conversion webhook") |
| 204 | + v2Gvr := schema.GroupVersionResource{ |
| 205 | + Group: "webhook.operators.coreos.io", |
| 206 | + Version: "v2", |
| 207 | + Resource: "webhooktests", |
| 208 | + } |
| 209 | + v2Client := dynamicClient.Resource(v2Gvr).Namespace(namespace.GetName()) |
| 210 | + |
| 211 | + t.Log("By eventually getting the valid CR with a v2 client") |
| 212 | + require.EventuallyWithT(t, func(ct *assert.CollectT) { |
| 213 | + res, err = v2Client.Get(t.Context(), obj.GetName(), metav1.GetOptions{}) |
| 214 | + require.NoError(ct, err) |
| 215 | + }, pollDuration, pollInterval) |
| 216 | + |
| 217 | + t.Log("and verifying that the CR is correctly converted") |
| 218 | + require.Equal(t, map[string]interface{}{ |
| 219 | + "conversion": map[string]interface{}{ |
| 220 | + "valid": true, |
| 221 | + "mutate": true, |
| 222 | + }, |
| 223 | + }, res.Object["spec"]) |
| 224 | +} |
| 225 | + |
| 226 | +func getWebhookOperatorResource(name string, namespace string, valid bool) *unstructured.Unstructured { |
| 227 | + return &unstructured.Unstructured{ |
| 228 | + Object: map[string]interface{}{ |
| 229 | + "apiVersion": "webhook.operators.coreos.io/v1", |
| 230 | + "kind": "webhooktests", |
| 231 | + "metadata": map[string]interface{}{ |
| 232 | + "name": name, |
| 233 | + "namespace": namespace, |
| 234 | + }, |
| 235 | + "spec": map[string]interface{}{ |
| 236 | + "valid": valid, |
| 237 | + }, |
| 238 | + }, |
| 239 | + } |
| 240 | +} |
0 commit comments