fake reconciler for catalog sync tests

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

Author: ankitathomas

cmd/manager/main.go

@@ -93,11 +93,11 @@ func main() {
 		os.Exit(1)
 	}
 
-	if err = (&controllers.OperatorReconciler{
+	if err = controllers.SetupWithManager(&controllers.OperatorReconciler{
 		Client:   mgr.GetClient(),
 		Scheme:   mgr.GetScheme(),
 		Resolver: resolution.NewOperatorResolver(mgr.GetClient(), entitysources.NewCatalogdEntitySource(mgr.GetClient())),
-	}).SetupWithManager(mgr); err != nil {
+	}, mgr); err != nil {
 		setupLog.Error(err, "unable to create controller", "controller", "Operator")
 		os.Exit(1)
 	}

internal/controllers/catalog_test.go

@@ -0,0 +1,109 @@
+package controllers_test
+
+import (
+	"context"
+	"strings"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	"github.com/operator-framework/operator-controller/internal/controllers"
+
+	catalogd "github.com/operator-framework/catalogd/pkg/apis/core/v1beta1"
+	operatorsv1alpha1 "github.com/operator-framework/operator-controller/api/v1alpha1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+)
+
+var _ = Describe("SetupWithManager", func() {
+	When("catalog events occur", func() {
+		var cancel context.CancelFunc
+		var ctx context.Context
+		var opNames = []string{"prometheus", "project-quay"}
+		var reqChan = make(chan string, 4*len(opNames))
+		BeforeEach(func() {
+			ctx = context.Background()
+			mgr, err := ctrl.NewManager(cfg, ctrl.Options{Scheme: sch})
+			Expect(err).To(BeNil())
+
+			var fakeReconciler reconcile.Func = func(_ context.Context, request ctrl.Request) (ctrl.Result, error) {
+				// ignore reconcile requests from other tests
+				if !strings.HasPrefix(request.Name, "operator-test") {
+					reqChan <- request.Name
+				}
+				return ctrl.Result{}, nil
+			}
+
+			err = controllers.SetupWithManager(fakeReconciler, mgr)
+			Expect(err).To(BeNil())
+
+			var mgrCtx context.Context
+			mgrCtx, cancel = context.WithCancel(ctx)
+
+			go func() {
+				err := mgr.Start(mgrCtx)
+				Expect(err).To(BeNil())
+			}()
+
+			for _, p := range opNames {
+				op := &operatorsv1alpha1.Operator{ObjectMeta: metav1.ObjectMeta{Name: p}, Spec: operatorsv1alpha1.OperatorSpec{PackageName: p}}
+				err := cl.Create(ctx, op)
+				Expect(err).To(BeNil())
+			}
+			By("verifying initial reconcile logs for operator creation")
+			var reqNames []string
+			for range opNames {
+				var req string
+				Eventually(reqChan).Should(Receive(&req))
+				reqNames = append(reqNames, req)
+			}
+			Expect(reqNames).To(ConsistOf(opNames))
+		})
+		It("reconciles all affected operators on cluster", func() {
+			By("creating a new catalog")
+			catalog := &catalogd.Catalog{ObjectMeta: metav1.ObjectMeta{Name: "t"}, Spec: catalogd.CatalogSpec{Source: catalogd.CatalogSource{Type: catalogd.SourceTypeImage, Image: &catalogd.ImageSource{}}}}
+			err := cl.Create(ctx, catalog)
+			Expect(err).To(BeNil())
+			By("verifying operator reconcile logs on catalog create")
+			var reqNames []string
+			for range opNames {
+				var req string
+				Eventually(reqChan).Should(Receive(&req))
+				reqNames = append(reqNames, req)
+			}
+			Expect(reqNames).To(ConsistOf(opNames))
+
+			By("updating a catalog")
+			catalog.Spec.Source.Image.Ref = "s"
+			err = cl.Update(ctx, catalog)
+			Expect(err).To(BeNil())
+			By("verifying operator reconcile logs on catalog update")
+			reqNames = []string{}
+			for range opNames {
+				var req string
+				Eventually(reqChan).Should(Receive(&req))
+				reqNames = append(reqNames, req)
+			}
+			Expect(reqNames).To(ConsistOf(opNames))
+
+			By("deleting a catalog")
+			err = cl.Delete(ctx, catalog)
+			Expect(err).To(BeNil())
+			By("verifying operator reconcile logs on catalog delete")
+			reqNames = []string{}
+			for range opNames {
+				var req string
+				Eventually(reqChan).Should(Receive(&req))
+				reqNames = append(reqNames, req)
+			}
+			Expect(reqNames).To(ConsistOf(opNames))
+		})
+		AfterEach(func() {
+			for _, p := range opNames {
+				op := &operatorsv1alpha1.Operator{ObjectMeta: metav1.ObjectMeta{Name: p}, Spec: operatorsv1alpha1.OperatorSpec{PackageName: p}}
+				Expect(cl.Delete(ctx, op)).To(Succeed())
+			}
+			cancel() // stop manager
+		})
+	})
+})

internal/controllers/operator_controller.go

@@ -289,7 +289,7 @@ func (r *OperatorReconciler) generateExpectedBundleDeployment(o operatorsv1alpha
 }
 
 // SetupWithManager sets up the controller with the Manager.
-func (r *OperatorReconciler) SetupWithManager(mgr ctrl.Manager) error {
+func SetupWithManager(r reconcile.Reconciler, mgr ctrl.Manager) error {
 	err := ctrl.NewControllerManagedBy(mgr).
 		For(&operatorsv1alpha1.Operator{}).
 		Watches(source.NewKindWithCache(&catalogd.Catalog{}, mgr.GetCache()),

internal/controllers/operator_controller_test.go

@@ -3,19 +3,11 @@ package controllers_test
 import (
 	"context"
 	"fmt"
-	"strings"
-	"time"
 
-	"github.com/go-logr/logr/funcr"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	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"
@@ -25,7 +17,11 @@ import (
 	ctrl "sigs.k8s.io/controller-runtime"
 	"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() {
@@ -1022,94 +1018,6 @@ var _ = Describe("Operator Controller Test", func() {
 			Expect(cond.Message).To(Equal("installation has not been attempted as spec is invalid"))
 		})
 	})
-	When("a catalog changes on cluster", func() {
-		var testLogs, opNames []string
-		var cancel context.CancelFunc
-		var logCount int
-		BeforeEach(func() {
-			l := funcr.New(func(prefix, args string) {
-				if prefix == "operator-controller" &&
-					strings.Contains(args, `"controller"="operator"`) &&
-					strings.Contains(args, `"msg"="ending"`) {
-					// filter for only relevant logs
-					testLogs = append(testLogs, fmt.Sprintf("%s", args))
-				}
-			}, funcr.Options{Verbosity: 1})
-			mgr, err := ctrl.NewManager(cfg, ctrl.Options{Scheme: sch, Logger: l})
-			Expect(err).To(BeNil())
-
-			err = reconciler.SetupWithManager(mgr)
-			Expect(err).To(BeNil())
-			var mgrCtx context.Context
-			mgrCtx, cancel = context.WithCancel(log.IntoContext(ctx, l))
-
-			go func() {
-				err := mgr.Start(mgrCtx)
-				Expect(err).To(BeNil())
-			}()
-
-			opNames = []string{"prometheus", "project-quay"}
-			for _, p := range opNames {
-				op := &operatorsv1alpha1.Operator{ObjectMeta: metav1.ObjectMeta{Name: p}, Spec: operatorsv1alpha1.OperatorSpec{PackageName: p}}
-				err := cl.Create(ctx, op)
-				Expect(err).To(BeNil())
-			}
-			Eventually(func(g Gomega) {
-				By("verifying initial reconcile logs for operator creation")
-				g.Expect(len(testLogs) >= len(opNames)).To(BeTrue())
-				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).Should(Succeed())
-		})
-
-		It("reconciles all affected operators on cluster", func() {
-			By("creating a new catalog")
-			catalog := &catalogd.Catalog{ObjectMeta: metav1.ObjectMeta{Name: "t"}, Spec: catalogd.CatalogSpec{Source: catalogd.CatalogSource{Type: catalogd.SourceTypeImage, Image: &catalogd.ImageSource{}}}}
-			err := cl.Create(ctx, catalog)
-			Expect(err).To(BeNil())
-			Eventually(func(g Gomega) {
-				By("verifying operator reconcile logs on catalog create")
-				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).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(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).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(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).Should(Succeed())
-		})
-		AfterEach(func() {
-			for _, p := range opNames {
-				op := &operatorsv1alpha1.Operator{ObjectMeta: metav1.ObjectMeta{Name: p}, Spec: operatorsv1alpha1.OperatorSpec{PackageName: p}}
-				Expect(cl.Delete(ctx, op)).To(BeNil())
-			}
-			cancel() // stop manager
-		})
-	})
 })
 
 func verifyInvariants(ctx context.Context, op *operatorsv1alpha1.Operator) {
@@ -1148,12 +1056,6 @@ var testEntitySource = input.NewCacheQuerier(map[deppy.Identifier]input.Entity{
 		"olm.package":     `{"packageName":"prometheus","version":"0.47.0"}`,
 		"olm.gvk":         `[]`,
 	}),
-	"operatorhub/project-quay/3.8.3": *input.NewEntity("operatorhub/project-quay/3.8.3", map[string]string{
-		"olm.bundle.path": `"quay.io/openshift-community-operators/project-quay@sha256:4f5698b5fec2e5f9a4df78b5ef9609b3a697c81cdb137b98e82e79104f0eb3b5"`,
-		"olm.channel":     `{"channelName":"stable","priority":0}`,
-		"olm.package":     `{"packageName":"project-quay","version":"3.8.3"}`,
-		"olm.gvk":         `[]`,
-	}),
 	"operatorhub/badimage/0.1.0": *input.NewEntity("operatorhub/badimage/0.1.0", map[string]string{
 		"olm.bundle.path": `{"name": "quay.io/operatorhubio/badimage:v0.1.0"}`,
 		"olm.package":     `{"packageName":"badimage","version":"0.1.0"}`,