Test leaderelection code path with fake resource lock

Author: JoelSpeed

pkg/leaderelection/fake/doc.go

@@ -0,0 +1,22 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Package fake mocks a resource lock for testing purposes.
+Always returns leadership.
+*/
+
+package fake

pkg/leaderelection/fake/leader_election.go

@@ -0,0 +1,90 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package fake
+
+import (
+	"os"
+	"time"
+
+	"github.com/pborman/uuid"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/rest"
+	"k8s.io/client-go/tools/leaderelection/resourcelock"
+	"sigs.k8s.io/controller-runtime/pkg/leaderelection"
+	"sigs.k8s.io/controller-runtime/pkg/recorder"
+)
+
+// NewFakeResourceLock creates a new FakeResourceLock for use in testing
+// leader election.
+func NewFakeResourceLock(config *rest.Config, recorderProvider recorder.Provider, options leaderelection.Options) (resourcelock.Interface, error) {
+	// Leader id, needs to be unique
+	id, err := os.Hostname()
+	if err != nil {
+		return nil, err
+	}
+	id = id + "_" + string(uuid.NewUUID())
+
+	return &FakeResourceLock{
+		id: id,
+		record: resourcelock.LeaderElectionRecord{
+			HolderIdentity:       id,
+			LeaseDurationSeconds: 15,
+			AcquireTime:          metav1.NewTime(time.Now()),
+			RenewTime:            metav1.NewTime(time.Now().Add(15 * time.Second)),
+			LeaderTransitions:    1,
+		},
+	}, nil
+}
+
+// FakeResourceLock implements the ResourceLockInterface.
+// By default returns that the current identity holds the lock.
+type FakeResourceLock struct {
+	id     string
+	record resourcelock.LeaderElectionRecord
+}
+
+// Get implements the ResourceLockInterface.
+func (f *FakeResourceLock) Get() (*resourcelock.LeaderElectionRecord, error) {
+	return &f.record, nil
+}
+
+// Create implements the ResourceLockInterface.
+func (f *FakeResourceLock) Create(ler resourcelock.LeaderElectionRecord) error {
+	f.record = ler
+	return nil
+}
+
+// Update implements the ResourceLockInterface.
+func (f *FakeResourceLock) Update(ler resourcelock.LeaderElectionRecord) error {
+	f.record = ler
+	return nil
+}
+
+// RecordEvent implements the ResourceLockInterface.
+func (f *FakeResourceLock) RecordEvent(s string) {
+	return
+}
+
+// Idenity implements the ResourceLockInterface.
+func (f *FakeResourceLock) Identity() string {
+	return f.id
+}
+
+// Describe implements the ResourceLockInterface.
+func (f *FakeResourceLock) Describe() string {
+	return f.id
+}

pkg/manager/manager_test.go

@@ -28,6 +28,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/cache"
 	"sigs.k8s.io/controller-runtime/pkg/cache/informertest"
 	"sigs.k8s.io/controller-runtime/pkg/client"
+	fakeleaderelection "sigs.k8s.io/controller-runtime/pkg/leaderelection/fake"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 	"sigs.k8s.io/controller-runtime/pkg/recorder"
 	"sigs.k8s.io/controller-runtime/pkg/runtime/inject"
@@ -197,6 +198,99 @@ var _ = Describe("manger.Manager", func() {
 			<-c2
 			<-c3
 		})
+
+		Context("with leaderelection enabled", func() {
+			opts := Options{
+				LeaderElection:          true,
+				LeaderElectionID:        "controller-runtime",
+				LeaderElectionNamespace: "default",
+				newResourceLock:         fakeleaderelection.NewFakeResourceLock,
+			}
+
+			It("should Start each Component", func(done Done) {
+				m, err := New(cfg, opts)
+				Expect(err).NotTo(HaveOccurred())
+				c1 := make(chan struct{})
+				m.Add(RunnableFunc(func(s <-chan struct{}) error {
+					defer close(c1)
+					defer GinkgoRecover()
+					return nil
+				}))
+
+				c2 := make(chan struct{})
+				m.Add(RunnableFunc(func(s <-chan struct{}) error {
+					defer close(c2)
+					defer GinkgoRecover()
+					return nil
+				}))
+
+				go func() {
+					defer GinkgoRecover()
+					Expect(m.Start(stop)).NotTo(HaveOccurred())
+				}()
+				<-c1
+				<-c2
+
+				close(done)
+			})
+
+			It("should stop when stop is called", func(done Done) {
+				m, err := New(cfg, opts)
+				Expect(err).NotTo(HaveOccurred())
+				s := make(chan struct{})
+				close(s)
+				Expect(m.Start(s)).NotTo(HaveOccurred())
+
+				close(done)
+			})
+
+			It("should return an error if it can't start the cache", func(done Done) {
+				m, err := New(cfg, opts)
+				Expect(err).NotTo(HaveOccurred())
+				mgr, ok := m.(*controllerManager)
+				Expect(ok).To(BeTrue())
+				mgr.startCache = func(stop <-chan struct{}) error {
+					return fmt.Errorf("expected error")
+				}
+				Expect(m.Start(stop).Error()).To(ContainSubstring("expected error"))
+
+				close(done)
+			}, 5)
+
+			It("should return an error if any Components fail to Start", func(done Done) {
+				m, err := New(cfg, opts)
+				Expect(err).NotTo(HaveOccurred())
+				c1 := make(chan struct{})
+				m.Add(RunnableFunc(func(s <-chan struct{}) error {
+					defer GinkgoRecover()
+					defer close(c1)
+					return nil
+				}))
+
+				c2 := make(chan struct{})
+				m.Add(RunnableFunc(func(s <-chan struct{}) error {
+					defer GinkgoRecover()
+					defer close(c2)
+					return fmt.Errorf("expected error")
+				}))
+
+				c3 := make(chan struct{})
+				m.Add(RunnableFunc(func(s <-chan struct{}) error {
+					defer GinkgoRecover()
+					defer close(c3)
+					return nil
+				}))
+
+				go func() {
+					defer GinkgoRecover()
+					Expect(m.Start(stop)).NotTo(HaveOccurred())
+					close(done)
+				}()
+				<-c1
+				<-c2
+				<-c3
+			})
+		})
 	})
 
 	Describe("Add", func() {