🌱 Catalog unit test

cmd/manager/main.go

@@ -94,14 +94,14 @@ func main() {
 		os.Exit(1)
 	}
 
-	if err = (&controllers.OperatorReconciler{
+	if err = controllers.SetupWithManager(&controllers.OperatorReconciler{
 		Client: mgr.GetClient(),
 		Scheme: mgr.GetScheme(),
 		Resolver: solver.NewDeppySolver(
 			entitysources.NewCatalogdEntitySource(mgr.GetClient()),
 			olm.NewOLMVariableSource(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,106 @@
+package controllers_test
+
+import (
+	"context"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	catalogd "github.com/operator-framework/catalogd/api/core/v1alpha1"
+	operatorsv1alpha1 "github.com/operator-framework/operator-controller/api/v1alpha1"
+	"github.com/operator-framework/operator-controller/internal/controllers"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+)
+
+func collectRequests(reqChan <-chan string) func() []string {
+	var reqNames []string
+	return func() []string {
+		select {
+		case req := <-reqChan:
+			reqNames = append(reqNames, req)
+		default:
+		}
+		return reqNames
+	}
+}
+
+func operatorForPackage(name, pkg string) *operatorsv1alpha1.Operator {
+	return &operatorsv1alpha1.Operator{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: name,
+		},
+		Spec: operatorsv1alpha1.OperatorSpec{
+			PackageName: pkg,
+		},
+	}
+}
+
+var _ = Describe("SetupWithManager", func() {
+	When("catalog events occur", func() {
+		var cancel context.CancelFunc
+		var ctx context.Context
+		var opNames []string
+		var reqChan chan string
+		BeforeEach(func() {
+			ctx = context.Background()
+			mgr, err := ctrl.NewManager(cfg, ctrl.Options{Scheme: sch})
+			Expect(err).To(BeNil())
+
+			opNames = []string{"prometheus", "project-quay"}
+			reqChan = make(chan string)
+			var fakeReconciler reconcile.Func = func(_ context.Context, request ctrl.Request) (ctrl.Result, error) {
+				reqChan <- request.Name
+				return ctrl.Result{}, nil
+			}
+			Expect(controllers.SetupWithManager(fakeReconciler, mgr)).To(Succeed())
+
+			var mgrCtx context.Context
+			mgrCtx, cancel = context.WithCancel(ctx)
+			go func() {
+				Expect(mgr.Start(mgrCtx)).To(Succeed())
+			}()
+
+			for _, p := range opNames {
+				Expect(cl.Create(ctx, operatorForPackage(p, p))).To(Succeed())
+			}
+			By("verifying initial reconcile logs for operator creation")
+			Eventually(collectRequests(reqChan)).Should(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{},
+					},
+				},
+			}
+			Expect(cl.Create(ctx, catalog)).To(Succeed())
+			By("verifying operator reconcile logs on catalog create")
+			Eventually(collectRequests(reqChan)).Should(ConsistOf(opNames))
+
+			By("updating a catalog")
+			catalog.Spec.Source.Image.Ref = "s"
+			Expect(cl.Update(ctx, catalog)).To(Succeed())
+			By("verifying operator reconcile logs on catalog update")
+			Eventually(collectRequests(reqChan)).Should(ConsistOf(opNames))
+
+			By("deleting a catalog")
+			Expect(cl.Delete(ctx, catalog)).To(Succeed())
+			By("verifying operator reconcile logs on catalog delete")
+			Eventually(collectRequests(reqChan)).Should(ConsistOf(opNames))
+		})
+		AfterEach(func() {
+			cancel() // stop manager
+			close(reqChan)
+			for _, p := range opNames {
+				Expect(cl.Delete(ctx, operatorForPackage(p, p))).To(Succeed())
+			}
+		})
+	})
+})

internal/controllers/operator_controller.go

@@ -298,7 +298,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/suite_test.go

@@ -23,6 +23,7 @@ import (
 
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
+	catalogd "github.com/operator-framework/catalogd/api/core/v1alpha1"
 	rukpakv1alpha1 "github.com/operator-framework/rukpak/api/v1alpha1"
 	"k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -72,6 +73,8 @@ var _ = BeforeSuite(func() {
 	Expect(err).NotTo(HaveOccurred())
 	err = rukpakv1alpha1.AddToScheme(sch)
 	Expect(err).NotTo(HaveOccurred())
+	err = catalogd.AddToScheme(sch)
+	Expect(err).NotTo(HaveOccurred())
 
 	cl, err = client.New(cfg, client.Options{Scheme: sch})
 	Expect(err).NotTo(HaveOccurred())

test/e2e/install_test.go

@@ -6,7 +6,6 @@ import (
 
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	catalogd "github.com/operator-framework/catalogd/api/core/v1alpha1"
 	operatorv1alpha1 "github.com/operator-framework/operator-controller/api/v1alpha1"
 	rukpakv1alpha1 "github.com/operator-framework/rukpak/api/v1alpha1"
 	"k8s.io/apimachinery/pkg/api/errors"
@@ -45,7 +44,6 @@ var _ = Describe("Operator Install", func() {
 				By("eventually reporting a successful resolution and bundle path")
 				Eventually(func(g Gomega) {
 					g.Expect(c.Get(ctx, types.NamespacedName{Name: operator.Name}, operator)).To(Succeed())
-					g.Expect(len(operator.Status.Conditions)).To(Equal(2))
 					cond := apimeta.FindStatusCondition(operator.Status.Conditions, operatorv1alpha1.TypeResolved)
 					g.Expect(cond).ToNot(BeNil())
 					g.Expect(cond.Status).To(Equal(metav1.ConditionTrue))
@@ -66,9 +64,16 @@ var _ = Describe("Operator Install", func() {
 
 					bd := rukpakv1alpha1.BundleDeployment{}
 					g.Expect(c.Get(ctx, types.NamespacedName{Name: operatorName}, &bd)).To(Succeed())
-					g.Expect(len(bd.Status.Conditions)).To(Equal(2))
-					g.Expect(bd.Status.Conditions[0].Reason).To(Equal("UnpackSuccessful"))
-					g.Expect(bd.Status.Conditions[1].Reason).To(Equal("InstallationSucceeded"))
+
+					cond = apimeta.FindStatusCondition(bd.Status.Conditions, rukpakv1alpha1.TypeHasValidBundle)
+					g.Expect(cond).ToNot(BeNil())
+					g.Expect(cond.Status).To(Equal(metav1.ConditionTrue))
+					g.Expect(cond.Reason).To(Equal(rukpakv1alpha1.ReasonUnpackSuccessful))
+
+					cond = apimeta.FindStatusCondition(bd.Status.Conditions, rukpakv1alpha1.TypeInstalled)
+					g.Expect(cond).ToNot(BeNil())
+					g.Expect(cond.Status).To(Equal(metav1.ConditionTrue))
+					g.Expect(cond.Reason).To(Equal(rukpakv1alpha1.ReasonInstallationSucceeded))
 				}).Should(Succeed())
 			})
 		})
@@ -86,7 +91,6 @@ var _ = Describe("Operator Install", func() {
 				By("eventually reporting a successful resolution and bundle path")
 				Eventually(func(g Gomega) {
 					g.Expect(c.Get(ctx, types.NamespacedName{Name: operator.Name}, operator)).To(Succeed())
-					g.Expect(len(operator.Status.Conditions)).To(Equal(2))
 					cond := apimeta.FindStatusCondition(operator.Status.Conditions, operatorv1alpha1.TypeResolved)
 					g.Expect(cond).ToNot(BeNil())
 					g.Expect(cond.Status).To(Equal(metav1.ConditionTrue))
@@ -107,63 +111,20 @@ var _ = Describe("Operator Install", func() {
 
 					bd := rukpakv1alpha1.BundleDeployment{}
 					g.Expect(c.Get(ctx, types.NamespacedName{Name: operatorName}, &bd)).To(Succeed())
-					g.Expect(len(bd.Status.Conditions)).To(Equal(2))
-					g.Expect(bd.Status.Conditions[0].Reason).To(Equal("UnpackSuccessful"))
-					g.Expect(bd.Status.Conditions[1].Reason).To(Equal("InstallationSucceeded"))
-				}).Should(Succeed())
-			})
-		})
-
-		It("resolves again when a new catalog is available", func() {
-			pkgName := "prometheus"
-			operator.Spec = operatorv1alpha1.OperatorSpec{
-				PackageName: pkgName,
-			}
-
-			// Delete the catalog first
-			Expect(c.Delete(ctx, operatorCatalog)).To(Succeed())
-
-			Eventually(func(g Gomega) {
-				// target package should not be present on cluster
-				err := c.Get(ctx, types.NamespacedName{Name: pkgName}, &catalogd.Package{})
-				g.Expect(errors.IsNotFound(err)).To(BeTrue())
-			}).Should(Succeed())
-
-			By("creating the Operator resource")
-			Expect(c.Create(ctx, operator)).To(Succeed())
 
-			By("failing to find Operator during resolution")
-			Eventually(func(g Gomega) {
-				g.Expect(c.Get(ctx, types.NamespacedName{Name: operator.Name}, operator)).To(Succeed())
-				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)))
-			}).Should(Succeed())
+					cond = apimeta.FindStatusCondition(bd.Status.Conditions, rukpakv1alpha1.TypeHasValidBundle)
+					g.Expect(cond).ToNot(BeNil())
+					g.Expect(cond.Status).To(Equal(metav1.ConditionTrue))
+					g.Expect(cond.Reason).To(Equal(rukpakv1alpha1.ReasonUnpackSuccessful))
 
-			By("creating an Operator catalog with the desired package")
-			var err error
-			operatorCatalog, err = createTestCatalog(ctx, testCatalogName, testCatalogRef)
-			Expect(err).ToNot(HaveOccurred())
-			Eventually(func(g Gomega) {
-				g.Expect(c.Get(ctx, types.NamespacedName{Name: operatorCatalog.Name}, operatorCatalog)).To(Succeed())
-				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))
-			}).Should(Succeed())
+					cond = apimeta.FindStatusCondition(bd.Status.Conditions, rukpakv1alpha1.TypeInstalled)
+					g.Expect(cond).ToNot(BeNil())
+					g.Expect(cond.Status).To(Equal(metav1.ConditionTrue))
+					g.Expect(cond.Reason).To(Equal(rukpakv1alpha1.ReasonInstallationSucceeded))
 
-			By("eventually resolving the package successfully")
-			Eventually(func(g Gomega) {
-				g.Expect(c.Get(ctx, types.NamespacedName{Name: operator.Name}, operator)).To(Succeed())
-				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))
-			}).Should(Succeed())
+				}).Should(Succeed())
+			})
 		})
-
 		AfterEach(func() {
 			Expect(c.Delete(ctx, operator)).To(Succeed())
 			Eventually(func(g Gomega) {