Test that For and Owns can only be used with reconcile.Request

pkg/builder/controller.go

@@ -313,7 +313,7 @@ func (blder *TypedBuilder[request]) doWatch() error {
 		}
 
 		if reflect.TypeFor[request]() != reflect.TypeOf(reconcile.Request{}) {
-			return fmt.Errorf("For() can only be used with reconcile.Request, got %T", reflect.TypeFor[request]())
+			return fmt.Errorf("For() can only be used with reconcile.Request, got %T", *new(request))
 		}
 
 		var hdler handler.TypedEventHandler[client.Object, request]
@@ -340,10 +340,6 @@ func (blder *TypedBuilder[request]) doWatch() error {
 			opts = append(opts, handler.OnlyControllerOwner())
 		}
 
-		if reflect.TypeFor[request]() != reflect.TypeOf(reconcile.Request{}) {
-			return errors.New("Owns() is not supported for TypedBuilder")
-		}
-
 		var hdler handler.TypedEventHandler[client.Object, request]
 		reflect.ValueOf(&hdler).Elem().Set(reflect.ValueOf(handler.EnqueueRequestForOwner(
 			blder.mgr.GetScheme(), blder.mgr.GetRESTMapper(),

pkg/builder/controller_test.go

@@ -49,12 +49,6 @@ import (
 
 var _ untypedWatchesInput = (*WatchesInput[struct{}])(nil)
 
-type typedNoop struct{}
-
-func (typedNoop) Reconcile(context.Context, reconcile.Request) (reconcile.Result, error) {
-	return reconcile.Result{}, nil
-}
-
 type testLogger struct {
 	logr.Logger
 }
@@ -77,10 +71,15 @@ func (l *testLogger) WithName(name string) logr.LogSink {
 	return l
 }
 
+type empty struct{}
+
 var _ = Describe("application", func() {
 	noop := reconcile.Func(func(context.Context, reconcile.Request) (reconcile.Result, error) {
 		return reconcile.Result{}, nil
 	})
+	typedNoop := reconcile.TypedFunc[empty](func(context.Context, empty) (reconcile.Result, error) {
+		return reconcile.Result{}, nil
+	})
 
 	Describe("New", func() {
 		It("should return success if given valid objects", func() {
@@ -179,6 +178,34 @@ var _ = Describe("application", func() {
 			// manifest when we try to default the controller name, which is good to double check.
 		})
 
+		It("should return error if in For is used with a custom request type", func() {
+			By("creating a controller manager")
+			m, err := manager.New(cfg, manager.Options{})
+			Expect(err).NotTo(HaveOccurred())
+
+			instance, err := TypedControllerManagedBy[empty](m).
+				For(&appsv1.ReplicaSet{}).
+				Build(typedNoop)
+			Expect(err).To(MatchError(ContainSubstring("For() can only be used with reconcile.Request, got builder.empty")))
+			Expect(instance).To(BeNil())
+		})
+
+		It("should return error if in Owns is used with a custom request type", func() {
+			By("creating a controller manager")
+			m, err := manager.New(cfg, manager.Options{})
+			Expect(err).NotTo(HaveOccurred())
+
+			instance, err := TypedControllerManagedBy[empty](m).
+				Named("my_controller").
+				Owns(&appsv1.ReplicaSet{}).
+				Build(typedNoop)
+				// If we ever allow Owns() without For() we need to update the code to error
+				// out on Owns() if the request type is different from reconcile.Request just
+				// like we do in For().
+			Expect(err).To(MatchError("Owns() can only be used together with For()"))
+			Expect(instance).To(BeNil())
+		})
+
 		It("should return an error if it cannot create the controller", func() {
 
 			By("creating a controller manager")
@@ -303,22 +330,14 @@ var _ = Describe("application", func() {
 		})
 
 		It("should not allow multiple reconcilers during creation of controller", func() {
-			newController := func(name string, mgr manager.Manager, options controller.Options) (controller.Controller, error) {
-				if options.Reconciler != (typedNoop{}) {
-					return nil, fmt.Errorf("Custom reconciler expected %T but found %T", typedNoop{}, options.Reconciler)
-				}
-				return controller.New(name, mgr, options)
-			}
-
 			By("creating a controller manager")
 			m, err := manager.New(cfg, manager.Options{})
 			Expect(err).NotTo(HaveOccurred())
 
 			builder := ControllerManagedBy(m).
 				For(&appsv1.ReplicaSet{}).
 				Owns(&appsv1.ReplicaSet{}).
-				WithOptions(controller.Options{Reconciler: typedNoop{}})
-			builder.newController = newController
+				WithOptions(controller.Options{Reconciler: noop})
 			instance, err := builder.Build(noop)
 			Expect(err).To(HaveOccurred())
 			Expect(instance).To(BeNil())