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/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,10 +3,7 @@ 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"
@@ -25,7 +22,7 @@ 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"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 )
 
 var _ = Describe("Operator Controller Test", func() {
@@ -1023,25 +1020,24 @@ var _ = Describe("Operator Controller Test", func() {
 		})
 	})
 	When("a catalog changes on cluster", func() {
-		var testLogs, opNames []string
+		var reconcileReqs, 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})
+			mgr, err := ctrl.NewManager(cfg, ctrl.Options{Scheme: sch})
 			Expect(err).To(BeNil())
 
-			err = reconciler.SetupWithManager(mgr)
+			var fakeReconciler reconcile.Func = func(_ context.Context, request ctrl.Request) (ctrl.Result, error) {
+				reconcileReqs = append(reconcileReqs, request.Name)
+				fmt.Println("RECONCILE", request.Name)
+				return ctrl.Result{}, nil
+			}
+
+			err = controllers.SetupWithManager(fakeReconciler, mgr)
 			Expect(err).To(BeNil())
+
 			var mgrCtx context.Context
-			mgrCtx, cancel = context.WithCancel(log.IntoContext(ctx, l))
+			mgrCtx, cancel = context.WithCancel(ctx)
 
 			go func() {
 				err := mgr.Start(mgrCtx)
@@ -1056,51 +1052,42 @@ var _ = Describe("Operator Controller Test", func() {
 			}
 			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())
+				g.Expect(len(reconcileReqs) >= len(opNames)).To(BeTrue())
+				g.Expect(reconcileReqs).To(ContainElements(opNames))
+				logCount = len(reconcileReqs)
+			}).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())
+				g.Expect(reconcileReqs).To(HaveLen(logCount + len(opNames)))
+				g.Expect(reconcileReqs[len(reconcileReqs)-len(opNames):]).To(ConsistOf(opNames))
+				logCount = len(reconcileReqs)
+			}).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())
+				g.Expect(reconcileReqs).To(HaveLen(logCount + len(opNames)))
+				g.Expect(reconcileReqs[len(reconcileReqs)-len(opNames):]).To(ConsistOf(opNames))
+				logCount = len(reconcileReqs)
+			}).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())
+				g.Expect(reconcileReqs).To(HaveLen(logCount + len(opNames)))
+				g.Expect(reconcileReqs[len(reconcileReqs)-len(opNames):]).To(ConsistOf(opNames))
+			}).Should(Succeed())
 		})
 		AfterEach(func() {
 			for _, p := range opNames {