package controller_test

import (

"context"

"fmt"

. "github.com/onsi/ginkgo"

. "github.com/onsi/gomega"

"go.uber.org/goleak"

"sigs.k8s.io/controller-runtime/pkg/client"

"sigs.k8s.io/controller-runtime/pkg/controller"

"sigs.k8s.io/controller-runtime/pkg/manager"

"sigs.k8s.io/controller-runtime/pkg/reconcile"

"sigs.k8s.io/controller-runtime/pkg/runtime/inject"

)

var _ = Describe("controller.Controller", func() {

rec := reconcile.Func(func(context.Context, reconcile.Request) (reconcile.Result, error) {

return reconcile.Result{}, nil

})

Describe("New", func() {

It("should return an error if Name is not Specified", func(done Done) {

m, err := manager.New(cfg, manager.Options{})

Expect(err).NotTo(HaveOccurred())

c, err := controller.New("", m, controller.Options{Reconciler: rec})

Expect(c).To(BeNil())

Expect(err.Error()).To(ContainSubstring("must specify Name for Controller"))

close(done)

})

It("should return an error if Reconciler is not Specified", func(done Done) {

m, err := manager.New(cfg, manager.Options{})

Expect(err).NotTo(HaveOccurred())

c, err := controller.New("foo", m, controller.Options{})

Expect(c).To(BeNil())

Expect(err.Error()).To(ContainSubstring("must specify Reconciler"))

close(done)

})

It("NewController should return an error if injecting Reconciler fails", func(done Done) {

m, err := manager.New(cfg, manager.Options{})

Expect(err).NotTo(HaveOccurred())

c, err := controller.New("foo", m, controller.Options{Reconciler: &failRec{}})

Expect(c).To(BeNil())

Expect(err).To(HaveOccurred())

Expect(err.Error()).To(ContainSubstring("expected error"))

close(done)

})

It("should not return an error if two controllers are registered with different names", func(done Done) {

m, err := manager.New(cfg, manager.Options{})

Expect(err).NotTo(HaveOccurred())

c1, err := controller.New("c1", m, controller.Options{Reconciler: rec})

Expect(err).NotTo(HaveOccurred())

Expect(c1).ToNot(BeNil())

c2, err := controller.New("c2", m, controller.Options{Reconciler: rec})

Expect(err).NotTo(HaveOccurred())

Expect(c2).ToNot(BeNil())

close(done)

})

It("should not leak goroutines when stopped", func() {

currentGRs := goleak.IgnoreCurrent()

m, err := manager.New(cfg, manager.Options{})

Expect(err).NotTo(HaveOccurred())

_, err = controller.New("new-controller", m, controller.Options{Reconciler: rec})

Expect(err).NotTo(HaveOccurred())

ctx, cancel := context.WithCancel(context.Background())

cancel()

Expect(m.Start(ctx)).To(Succeed())

// force-close keep-alive connections. These'll time anyway (after

// like 30s or so) but force it to speed up the tests.

clientTransport.CloseIdleConnections()

Eventually(func() error { return goleak.Find(currentGRs) }).Should(Succeed())

})

It("should not create goroutines if never started", func() {

currentGRs := goleak.IgnoreCurrent()

m, err := manager.New(cfg, manager.Options{})

Expect(err).NotTo(HaveOccurred())

_, err = controller.New("new-controller", m, controller.Options{Reconciler: rec})

Expect(err).NotTo(HaveOccurred())

// force-close keep-alive connections. These'll time anyway (after

// like 30s or so) but force it to speed up the tests.

clientTransport.CloseIdleConnections()

Eventually(func() error { return goleak.Find(currentGRs) }).Should(Succeed())

})

})

})

var _ reconcile.Reconciler = &failRec{}

var _ inject.Client = &failRec{}

type failRec struct{}

func (*failRec) Reconcile(context.Context, reconcile.Request) (reconcile.Result, error) {

return reconcile.Result{}, nil

}

func (*failRec) InjectClient(client.Client) error {

return fmt.Errorf("expected error")

}