remove e2e catalog reconcile test

Signed-off-by: Ankita Thomas <[email protected]>

Author: ankitathomas

go.mod

@@ -48,7 +48,6 @@ require (
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
-	github.com/operator-framework/api v0.17.3 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/prometheus/client_golang v1.14.0 // indirect
 	github.com/prometheus/client_model v0.3.0 // indirect

internal/controllers/operator_controller_test.go

@@ -12,6 +12,10 @@ import (
 	catalogd "github.com/operator-framework/catalogd/pkg/apis/core/v1beta1"
 	"github.com/operator-framework/deppy/pkg/deppy"
 	"github.com/operator-framework/deppy/pkg/deppy/input"
+	operatorsv1alpha1 "github.com/operator-framework/operator-controller/api/v1alpha1"
+	"github.com/operator-framework/operator-controller/internal/conditionsets"
+	"github.com/operator-framework/operator-controller/internal/controllers"
+	"github.com/operator-framework/operator-controller/internal/resolution"
 	rukpakv1alpha1 "github.com/operator-framework/rukpak/api/v1alpha1"
 	apimeta "k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -22,11 +26,6 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/client/fake"
 	"sigs.k8s.io/controller-runtime/pkg/log"
-
-	operatorsv1alpha1 "github.com/operator-framework/operator-controller/api/v1alpha1"
-	"github.com/operator-framework/operator-controller/internal/conditionsets"
-	"github.com/operator-framework/operator-controller/internal/controllers"
-	"github.com/operator-framework/operator-controller/internal/resolution"
 )
 
 var _ = Describe("Operator Controller Test", func() {
@@ -1062,7 +1061,7 @@ var _ = Describe("Operator Controller Test", func() {
 					g.Expect(testLogs[len(testLogs)-len(opNames):]).To(ContainElement(ContainSubstring(fmt.Sprintf("\"Operator\"={\"name\":\"%s\"}", p))))
 				}
 				logCount = len(testLogs)
-			}).WithTimeout(2 * time.Second).WithPolling(1 * time.Second).WithArguments().Should(Succeed())
+			}).WithTimeout(2 * time.Second).WithPolling(1 * time.Second).Should(Succeed())
 		})
 
 		It("reconciles all affected operators on cluster", func() {
@@ -1072,36 +1071,36 @@ var _ = Describe("Operator Controller Test", func() {
 			Expect(err).To(BeNil())
 			Eventually(func(g Gomega) {
 				By("verifying operator reconcile logs on catalog create")
-				g.Expect(len(testLogs)).To(Equal(logCount + len(opNames)))
+				g.Expect(testLogs).To(HaveLen(logCount + len(opNames)))
 				for _, p := range opNames {
 					g.Expect(testLogs[len(testLogs)-len(opNames):]).To(ContainElement(ContainSubstring(fmt.Sprintf("\"Operator\"={\"name\":\"%s\"}", p))))
 				}
 				logCount = len(testLogs)
-			}).WithTimeout(2 * time.Second).WithPolling(1 * time.Second).WithArguments().Should(Succeed())
+			}).WithTimeout(2 * time.Second).WithPolling(1 * time.Second).Should(Succeed())
 
 			By("updating a catalog")
 			catalog.Spec.Source.Image.Ref = "s"
 			err = cl.Update(ctx, catalog)
 			Expect(err).To(BeNil())
 			Eventually(func(g Gomega) {
 				By("verifying operator reconcile logs on catalog update")
-				g.Expect(len(testLogs)).To(Equal(logCount + len(opNames)))
+				g.Expect(testLogs).To(HaveLen(logCount + len(opNames)))
 				for _, p := range opNames {
 					g.Expect(testLogs[len(testLogs)-len(opNames):]).To(ContainElement(ContainSubstring(fmt.Sprintf("\"Operator\"={\"name\":\"%s\"}", p))))
 				}
 				logCount = len(testLogs)
-			}).WithTimeout(2 * time.Second).WithPolling(1 * time.Second).WithArguments().Should(Succeed())
+			}).WithTimeout(2 * time.Second).WithPolling(1 * time.Second).Should(Succeed())
 
 			By("deleting a catalog")
 			err = cl.Delete(ctx, catalog)
 			Expect(err).To(BeNil())
 			Eventually(func(g Gomega) {
 				By("verifying operator reconcile logs on catalog delete")
-				g.Expect(len(testLogs)).To(Equal(logCount + len(opNames)))
+				g.Expect(testLogs).To(HaveLen(logCount + len(opNames)))
 				for _, p := range opNames {
 					g.Expect(testLogs[len(testLogs)-len(opNames):]).To(ContainElement(ContainSubstring(fmt.Sprintf("\"Operator\"={\"name\":\"%s\"}", p))))
 				}
-			}).WithTimeout(2 * time.Second).WithPolling(1 * time.Second).WithArguments().Should(Succeed())
+			}).WithTimeout(2 * time.Second).WithPolling(1 * time.Second).Should(Succeed())
 		})
 		AfterEach(func() {
 			for _, p := range opNames {

test/e2e/install_test.go

@@ -10,7 +10,6 @@ import (
 	catalogd "github.com/operator-framework/catalogd/pkg/apis/core/v1beta1"
 	operatorv1alpha1 "github.com/operator-framework/operator-controller/api/v1alpha1"
 	rukpakv1alpha1 "github.com/operator-framework/rukpak/api/v1alpha1"
-	"k8s.io/apimachinery/pkg/api/errors"
 	apimeta "k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
@@ -58,8 +57,6 @@ var _ = Describe("Operator Install", func() {
 					},
 				},
 			}
-		})
-		It("resolves the specified package with correct bundle path", func() {
 			err := c.Create(ctx, operatorCatalog)
 			Expect(err).ToNot(HaveOccurred())
 			Eventually(func(g Gomega) {
@@ -72,9 +69,10 @@ var _ = Describe("Operator Install", func() {
 				g.Expect(cond.Reason).To(Equal(catalogd.ReasonUnpackSuccessful))
 				g.Expect(cond.Message).To(ContainSubstring("successfully unpacked the catalog image"))
 			}).WithTimeout(5 * time.Minute).WithPolling(defaultPoll).Should(Succeed())
-
+		})
+		It("resolves the specified package with correct bundle path", func() {
 			By("creating the Operator resource")
-			err = c.Create(ctx, operator)
+			err := c.Create(ctx, operator)
 			Expect(err).ToNot(HaveOccurred())
 
 			By("eventually reporting a successful resolution and bundle path")
@@ -115,86 +113,12 @@ var _ = Describe("Operator Install", func() {
 				g.Expect(cond.Reason).To(Equal(rukpakv1alpha1.ReasonInstallationSucceeded))
 			}).WithTimeout(defaultTimeout).WithPolling(defaultPoll).Should(Succeed())
 		})
-		It("resolves again when a new catalog is available", func() {
-			Eventually(func(g Gomega) {
-				// target package should not be present on cluster
-				err := c.Get(ctx, types.NamespacedName{Name: pkgName}, &catalogd.Package{})
-				Expect(errors.IsNotFound(err)).To(BeTrue())
-			}).WithTimeout(5 * time.Minute).WithPolling(defaultPoll).Should(Succeed())
-
-			By("creating the Operator resource")
-			err := c.Create(ctx, operator)
-			Expect(err).ToNot(HaveOccurred())
-
-			By("failing to find Operator during resolution")
-			Eventually(func(g Gomega) {
-				err = c.Get(ctx, types.NamespacedName{Name: operator.Name}, operator)
-				g.Expect(err).ToNot(HaveOccurred())
-				cond := apimeta.FindStatusCondition(operator.Status.Conditions, operatorv1alpha1.TypeResolved)
-				g.Expect(cond).ToNot(BeNil())
-				g.Expect(cond.Status).To(Equal(metav1.ConditionFalse))
-				g.Expect(cond.Reason).To(Equal(operatorv1alpha1.ReasonResolutionFailed))
-				g.Expect(cond.Message).To(Equal(fmt.Sprintf("package '%s' not found", pkgName)))
-			}).WithTimeout(defaultTimeout).WithPolling(defaultPoll).Should(Succeed())
-
-			By("creating an Operator catalog with the desired package")
-			err = c.Create(ctx, operatorCatalog)
-			Expect(err).ToNot(HaveOccurred())
-			Eventually(func(g Gomega) {
-				err = c.Get(ctx, types.NamespacedName{Name: operatorCatalog.Name}, operatorCatalog)
-				g.Expect(err).ToNot(HaveOccurred())
-				cond := apimeta.FindStatusCondition(operatorCatalog.Status.Conditions, catalogd.TypeUnpacked)
-				g.Expect(cond).ToNot(BeNil())
-				g.Expect(cond.Status).To(Equal(metav1.ConditionTrue))
-				g.Expect(cond.Reason).To(Equal(catalogd.ReasonUnpackSuccessful))
-			}).WithTimeout(5 * time.Minute).WithPolling(defaultPoll).Should(Succeed())
-
-			By("eventually resolving the package successfully")
-			Eventually(func(g Gomega) {
-				err = c.Get(ctx, types.NamespacedName{Name: operator.Name}, operator)
-				g.Expect(err).ToNot(HaveOccurred())
-				cond := apimeta.FindStatusCondition(operator.Status.Conditions, operatorv1alpha1.TypeResolved)
-				g.Expect(cond).ToNot(BeNil())
-				g.Expect(cond.Status).To(Equal(metav1.ConditionTrue))
-				g.Expect(cond.Reason).To(Equal(operatorv1alpha1.ReasonSuccess))
-			}).WithTimeout(defaultTimeout).WithPolling(defaultPoll).Should(Succeed())
-		})
 		AfterEach(func() {
 			err := c.Delete(ctx, operator)
 			Expect(err).ToNot(HaveOccurred())
-			Eventually(func(g Gomega) {
-				err = c.Get(ctx, types.NamespacedName{Name: operatorName}, &operatorv1alpha1.Operator{})
-				Expect(errors.IsNotFound(err)).To(BeTrue())
-			}).WithTimeout(defaultTimeout).WithPolling(defaultPoll).Should(Succeed())
 
 			err = c.Delete(ctx, operatorCatalog)
 			Expect(err).ToNot(HaveOccurred())
-			Eventually(func(g Gomega) {
-				err = c.Get(ctx, types.NamespacedName{Name: operatorCatalog.Name}, &catalogd.Catalog{})
-				Expect(errors.IsNotFound(err)).To(BeTrue())
-			}).WithTimeout(defaultTimeout).WithPolling(defaultPoll).Should(Succeed())
-
-			// speed up delete without waiting for gc
-			err = c.DeleteAllOf(ctx, &catalogd.BundleMetadata{})
-			Expect(err).ToNot(HaveOccurred())
-			err = c.DeleteAllOf(ctx, &catalogd.Package{})
-			Expect(err).ToNot(HaveOccurred())
-
-			Eventually(func(g Gomega) {
-				// ensure resource cleanup
-				packages := &catalogd.PackageList{}
-				err = c.List(ctx, packages)
-				Expect(err).To(BeNil())
-				Expect(packages.Items).To(BeEmpty())
-
-				bmd := &catalogd.BundleMetadataList{}
-				err = c.List(ctx, bmd)
-				Expect(err).To(BeNil())
-				Expect(bmd.Items).To(BeEmpty())
-
-				err = c.Get(ctx, types.NamespacedName{Name: operatorName}, &rukpakv1alpha1.BundleDeployment{})
-				Expect(errors.IsNotFound(err)).To(BeTrue())
-			}).WithTimeout(5 * time.Minute).WithPolling(defaultPoll).Should(Succeed())
 		})
 	})
 })