NE-2097: e2e - Add cleanup helpers for GatewayAPI resources

This commit introduces helper functions to clean up Gateway, GatewayClass,
and OLM operator after e2e tests. These functions are integrated into
the GatewayAPI and GatewayAPI upgrade tests to prevent conflicts
and ensure a clean environment for subsequent runs.

Author: alebedev87

test/e2e/gateway_api_test.go

@@ -83,14 +83,19 @@ func TestGatewayAPI(t *testing.T) {
 
 	// Defer the cleanup of the test gateway.
 	t.Cleanup(func() {
-		testGateway := gatewayapiv1.Gateway{ObjectMeta: metav1.ObjectMeta{Name: testGatewayName, Namespace: operatorcontroller.DefaultOperandNamespace}}
-		if err := kclient.Delete(context.TODO(), &testGateway); err != nil {
-			if errors.IsNotFound(err) {
-				return
+		// Keeping test resources for must-gather if test failed.
+		if !t.Failed() {
+			t.Logf("Cleaning Gateway, GatewayClass and OSSM operator...")
+			if err := cleanupGateway(t, "openshift-ingress", "test-gateway", "openshift-default"); err != nil {
+				t.Errorf("Failed to cleanup gateway: %v", err)
+			}
+			if err := cleanupGatewayClass(t, "openshift-default"); err != nil {
+				t.Errorf("Failed to cleanup gatewayclass: %v", err)
+			}
+			if err := cleanupOLMOperator(t, "openshift-operators", "servicemeshoperator3.openshift-operators"); err != nil {
+				t.Errorf("Failed to cleanup OSSM operator: %v", err)
 			}
-			t.Errorf("failed to delete gateway %q: %v", testGateway.Name, err)
 		}
-		// TODO: Uninstall OSSM after test is completed.
 	})
 
 	t.Run("testGatewayAPIResources", testGatewayAPIResources)

test/e2e/gateway_api_upgrade_test.go

@@ -35,6 +35,19 @@ func TestOSSMOperatorUpgradeViaIntermediateVersions(t *testing.T) {
 		t.Skip("Gateway API featuregates are not enabled, skipping TestOSSMOperatorUpgradeViaIntermediateVersions")
 	}
 
+	t.Cleanup(func() {
+		// Keeping test resources for must-gather if test failed.
+		if !t.Failed() {
+			t.Logf("Cleaning GatewayClass and OSSM operator...")
+			if err := cleanupGatewayClass(t, "openshift-default"); err != nil {
+				t.Errorf("Failed to cleanup gatewayclass: %v", err)
+			}
+			if err := cleanupOLMOperator(t, "openshift-operators", "servicemeshoperator3.openshift-operators"); err != nil {
+				t.Errorf("Failed to cleanup OSSM operator: %v", err)
+			}
+		}
+	})
+
 	var (
 		initialOSSMVersion  = "servicemeshoperator3.v3.0.0"
 		initialIstioVersion = "v1.24.3"

test/e2e/operator_test.go

@@ -31,6 +31,7 @@ import (
 	operatorv1 "github.com/openshift/api/operator/v1"
 	iov1 "github.com/openshift/api/operatoringress/v1"
 	routev1 "github.com/openshift/api/route/v1"
+	olmv1 "github.com/operator-framework/api/pkg/operators/v1"
 
 	configclientset "github.com/openshift/client-go/config/clientset/versioned"
 	"github.com/openshift/cluster-ingress-operator/pkg/manifests"
@@ -173,6 +174,12 @@ func TestMain(m *testing.M) {
 	}
 	kclient = kubeClient
 
+	// GatewayAPI tests need to clean up the OSSM operator.
+	if olmv1.AddToScheme(operatorclient.GetScheme()); err != nil {
+		fmt.Printf("failed to install olmv1 scheme: %s\n", err)
+		os.Exit(1)
+	}
+
 	configClient, err = configclientset.NewForConfig(kubeConfig)
 	if err != nil {
 		fmt.Printf("failed to create config client: %s\n", err)

test/e2e/util_gatewayapi_test.go

@@ -20,6 +20,7 @@ import (
 	v1 "github.com/openshift/api/operatoringress/v1"
 	operatorcontroller "github.com/openshift/cluster-ingress-operator/pkg/operator/controller"
 	util "github.com/openshift/cluster-ingress-operator/pkg/util"
+	olmv1 "github.com/operator-framework/api/pkg/operators/v1"
 	operatorsv1alpha1 "github.com/operator-framework/api/pkg/operators/v1alpha1"
 
 	"github.com/google/go-cmp/cmp"
@@ -30,6 +31,7 @@ import (
 	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
 	kerrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/wait"
 
@@ -180,6 +182,105 @@ func deleteExistingVAP(t *testing.T, vapName string) error {
 	return nil
 }
 
+// cleanupGateway deletes the given gateway and waits for the corresponding Istio proxy deployment to disappear.
+func cleanupGateway(t *testing.T, namespace, name, gcname string) error {
+	t.Helper()
+
+	gw := &gatewayapiv1.Gateway{ObjectMeta: metav1.ObjectMeta{Namespace: namespace, Name: name}}
+	if err := kclient.Delete(context.Background(), gw); err != nil && !kerrors.IsNotFound(err) {
+		return fmt.Errorf(`failed to delete gateway "%s/%s": %w`, namespace, name, err)
+	}
+	t.Logf(`Deleted gateway "%s/%s"`, namespace, name)
+
+	depl := &appsv1.Deployment{}
+	istioName := types.NamespacedName{Namespace: operatorcontroller.DefaultOperandNamespace, Name: name + "-" + gcname}
+	if err := wait.PollUntilContextTimeout(context.Background(), 1*time.Second, 1*time.Minute, false, func(context context.Context) (bool, error) {
+		if err := kclient.Get(context, istioName, depl); err != nil {
+			if !kerrors.IsNotFound(err) {
+				t.Logf("Failed to get deployment %q, retrying...", istioName)
+				return false, nil
+			}
+		} else {
+			t.Logf("Deployment %q still exists, retrying...", istioName)
+			return false, nil
+		}
+		return true, nil
+	}); err != nil {
+		return fmt.Errorf("timed out waiting for deployment %v to disappear", istioName)
+	}
+	t.Logf("Deleted deployment %q", istioName)
+
+	return nil
+}
+
+// cleanupGatewayClass deletes the given gatewayclass and waits for the corresponding Istiod deployment to disappear.
+func cleanupGatewayClass(t *testing.T, name string) error {
+	t.Helper()
+
+	gc := &gatewayapiv1.GatewayClass{ObjectMeta: metav1.ObjectMeta{Name: name}}
+	if err := kclient.Delete(context.Background(), gc); err != nil && !kerrors.IsNotFound(err) {
+		return fmt.Errorf("failed to delete gatewayclass %q: %w", name, err)
+	}
+	t.Logf("Deleted gatewayclass %q", name)
+
+	depl := &appsv1.Deployment{}
+	istiodName := types.NamespacedName{Namespace: operatorcontroller.DefaultOperandNamespace, Name: "istiod-" + name}
+	if err := wait.PollUntilContextTimeout(context.Background(), 1*time.Second, 1*time.Minute, false, func(context context.Context) (bool, error) {
+		if err := kclient.Get(context, istiodName, depl); err != nil {
+			if !kerrors.IsNotFound(err) {
+				t.Logf("Failed to get deployment %q, retrying...", istiodName)
+				return false, nil
+			}
+		} else {
+			t.Logf("Deployment %q still exists, retrying...", istiodName)
+			return false, nil
+		}
+		return true, nil
+	}); err != nil {
+		return fmt.Errorf("timed out waiting for deployment %v to disappear", istiodName)
+	}
+	t.Logf("Deleted deployment %q", istiodName)
+
+	return nil
+}
+
+// cleanupOLMOperator deletes all components associated with the given OLM operator, including the operator resource itself.
+func cleanupOLMOperator(t *testing.T, namespace, name string) error {
+	operatorName := types.NamespacedName{Namespace: namespace, Name: name}
+	operator := &olmv1.Operator{}
+	if err := wait.PollUntilContextTimeout(context.Background(), 1*time.Second, 1*time.Minute, false, func(context context.Context) (bool, error) {
+		if err := kclient.Get(context, operatorName, operator); err != nil {
+			t.Logf("Failed to get operator %q, retrying...", operatorName)
+			return false, nil
+		}
+		return true, nil
+	}); err != nil {
+		return fmt.Errorf("timed out getting operator %v", operatorName)
+	}
+
+	if operator.Status.Components != nil {
+		for _, compRef := range operator.Status.Components.Refs {
+			if compRef.Kind != "CustomResourceDefinition" {
+				unstructuredObj := &unstructured.Unstructured{}
+				unstructuredObj.SetAPIVersion(compRef.APIVersion)
+				unstructuredObj.SetKind(compRef.Kind)
+				unstructuredObj.SetName(compRef.Name)
+				unstructuredObj.SetNamespace(namespace)
+				if err := kclient.Delete(context.Background(), unstructuredObj); err != nil && !kerrors.IsNotFound(err) {
+					return fmt.Errorf(`failed to delete operator component "%s/%s/%s/%s": %w`, compRef.APIVersion, compRef.Kind, namespace, compRef.Name, err)
+				}
+				t.Logf(`Deleted operator component "%s/%s/%s/%s"`, compRef.APIVersion, compRef.Kind, namespace, compRef.Name)
+			}
+		}
+	}
+	if err := kclient.Delete(context.Background(), operator); err != nil && !kerrors.IsNotFound(err) {
+		return fmt.Errorf("failed to delete operator %q: %w", operatorName, err)
+	}
+	t.Logf("Deleted operator %q", operatorName)
+
+	return nil
+}
+
 // createHttpRoute checks if the HTTPRoute can be created.
 // If it can't an error is returned.
 func createHttpRoute(namespace, routeName, parentNamespace, hostname, backendRefname string, gateway *gatewayapiv1.Gateway) (*gatewayapiv1.HTTPRoute, error) {