|
|
@@ -0,0 +1,1288 @@
|
|
|
+// Code generated by counterfeiter. DO NOT EDIT.
|
|
|
+package fakes
|
|
|
+
|
|
|
+import (
|
|
|
+ "context"
|
|
|
+ "net/http"
|
|
|
+ "sync"
|
|
|
+
|
|
|
+ "github.com/go-logr/logr"
|
|
|
+ "k8s.io/apimachinery/pkg/api/meta"
|
|
|
+ "k8s.io/apimachinery/pkg/runtime"
|
|
|
+ "k8s.io/client-go/rest"
|
|
|
+ "k8s.io/client-go/tools/record"
|
|
|
+ "sigs.k8s.io/controller-runtime/pkg/cache"
|
|
|
+ "sigs.k8s.io/controller-runtime/pkg/client"
|
|
|
+ "sigs.k8s.io/controller-runtime/pkg/config/v1alpha1"
|
|
|
+ "sigs.k8s.io/controller-runtime/pkg/healthz"
|
|
|
+ "sigs.k8s.io/controller-runtime/pkg/manager"
|
|
|
+ "sigs.k8s.io/controller-runtime/pkg/webhook"
|
|
|
+)
|
|
|
+
|
|
|
+type Manager struct {
|
|
|
+ AddStub func(manager.Runnable) error
|
|
|
+ addMutex sync.RWMutex
|
|
|
+ addArgsForCall []struct {
|
|
|
+ arg1 manager.Runnable
|
|
|
+ }
|
|
|
+ addReturns struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ addReturnsOnCall map[int]struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ AddHealthzCheckStub func(string, healthz.Checker) error
|
|
|
+ addHealthzCheckMutex sync.RWMutex
|
|
|
+ addHealthzCheckArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 healthz.Checker
|
|
|
+ }
|
|
|
+ addHealthzCheckReturns struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ addHealthzCheckReturnsOnCall map[int]struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ AddMetricsExtraHandlerStub func(string, http.Handler) error
|
|
|
+ addMetricsExtraHandlerMutex sync.RWMutex
|
|
|
+ addMetricsExtraHandlerArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 http.Handler
|
|
|
+ }
|
|
|
+ addMetricsExtraHandlerReturns struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ addMetricsExtraHandlerReturnsOnCall map[int]struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ AddReadyzCheckStub func(string, healthz.Checker) error
|
|
|
+ addReadyzCheckMutex sync.RWMutex
|
|
|
+ addReadyzCheckArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 healthz.Checker
|
|
|
+ }
|
|
|
+ addReadyzCheckReturns struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ addReadyzCheckReturnsOnCall map[int]struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ ElectedStub func() <-chan struct{}
|
|
|
+ electedMutex sync.RWMutex
|
|
|
+ electedArgsForCall []struct {
|
|
|
+ }
|
|
|
+ electedReturns struct {
|
|
|
+ result1 <-chan struct{}
|
|
|
+ }
|
|
|
+ electedReturnsOnCall map[int]struct {
|
|
|
+ result1 <-chan struct{}
|
|
|
+ }
|
|
|
+ GetAPIReaderStub func() client.Reader
|
|
|
+ getAPIReaderMutex sync.RWMutex
|
|
|
+ getAPIReaderArgsForCall []struct {
|
|
|
+ }
|
|
|
+ getAPIReaderReturns struct {
|
|
|
+ result1 client.Reader
|
|
|
+ }
|
|
|
+ getAPIReaderReturnsOnCall map[int]struct {
|
|
|
+ result1 client.Reader
|
|
|
+ }
|
|
|
+ GetCacheStub func() cache.Cache
|
|
|
+ getCacheMutex sync.RWMutex
|
|
|
+ getCacheArgsForCall []struct {
|
|
|
+ }
|
|
|
+ getCacheReturns struct {
|
|
|
+ result1 cache.Cache
|
|
|
+ }
|
|
|
+ getCacheReturnsOnCall map[int]struct {
|
|
|
+ result1 cache.Cache
|
|
|
+ }
|
|
|
+ GetClientStub func() client.Client
|
|
|
+ getClientMutex sync.RWMutex
|
|
|
+ getClientArgsForCall []struct {
|
|
|
+ }
|
|
|
+ getClientReturns struct {
|
|
|
+ result1 client.Client
|
|
|
+ }
|
|
|
+ getClientReturnsOnCall map[int]struct {
|
|
|
+ result1 client.Client
|
|
|
+ }
|
|
|
+ GetConfigStub func() *rest.Config
|
|
|
+ getConfigMutex sync.RWMutex
|
|
|
+ getConfigArgsForCall []struct {
|
|
|
+ }
|
|
|
+ getConfigReturns struct {
|
|
|
+ result1 *rest.Config
|
|
|
+ }
|
|
|
+ getConfigReturnsOnCall map[int]struct {
|
|
|
+ result1 *rest.Config
|
|
|
+ }
|
|
|
+ GetControllerOptionsStub func() v1alpha1.ControllerConfigurationSpec
|
|
|
+ getControllerOptionsMutex sync.RWMutex
|
|
|
+ getControllerOptionsArgsForCall []struct {
|
|
|
+ }
|
|
|
+ getControllerOptionsReturns struct {
|
|
|
+ result1 v1alpha1.ControllerConfigurationSpec
|
|
|
+ }
|
|
|
+ getControllerOptionsReturnsOnCall map[int]struct {
|
|
|
+ result1 v1alpha1.ControllerConfigurationSpec
|
|
|
+ }
|
|
|
+ GetEventRecorderForStub func(string) record.EventRecorder
|
|
|
+ getEventRecorderForMutex sync.RWMutex
|
|
|
+ getEventRecorderForArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ }
|
|
|
+ getEventRecorderForReturns struct {
|
|
|
+ result1 record.EventRecorder
|
|
|
+ }
|
|
|
+ getEventRecorderForReturnsOnCall map[int]struct {
|
|
|
+ result1 record.EventRecorder
|
|
|
+ }
|
|
|
+ GetFieldIndexerStub func() client.FieldIndexer
|
|
|
+ getFieldIndexerMutex sync.RWMutex
|
|
|
+ getFieldIndexerArgsForCall []struct {
|
|
|
+ }
|
|
|
+ getFieldIndexerReturns struct {
|
|
|
+ result1 client.FieldIndexer
|
|
|
+ }
|
|
|
+ getFieldIndexerReturnsOnCall map[int]struct {
|
|
|
+ result1 client.FieldIndexer
|
|
|
+ }
|
|
|
+ GetLoggerStub func() logr.Logger
|
|
|
+ getLoggerMutex sync.RWMutex
|
|
|
+ getLoggerArgsForCall []struct {
|
|
|
+ }
|
|
|
+ getLoggerReturns struct {
|
|
|
+ result1 logr.Logger
|
|
|
+ }
|
|
|
+ getLoggerReturnsOnCall map[int]struct {
|
|
|
+ result1 logr.Logger
|
|
|
+ }
|
|
|
+ GetRESTMapperStub func() meta.RESTMapper
|
|
|
+ getRESTMapperMutex sync.RWMutex
|
|
|
+ getRESTMapperArgsForCall []struct {
|
|
|
+ }
|
|
|
+ getRESTMapperReturns struct {
|
|
|
+ result1 meta.RESTMapper
|
|
|
+ }
|
|
|
+ getRESTMapperReturnsOnCall map[int]struct {
|
|
|
+ result1 meta.RESTMapper
|
|
|
+ }
|
|
|
+ GetSchemeStub func() *runtime.Scheme
|
|
|
+ getSchemeMutex sync.RWMutex
|
|
|
+ getSchemeArgsForCall []struct {
|
|
|
+ }
|
|
|
+ getSchemeReturns struct {
|
|
|
+ result1 *runtime.Scheme
|
|
|
+ }
|
|
|
+ getSchemeReturnsOnCall map[int]struct {
|
|
|
+ result1 *runtime.Scheme
|
|
|
+ }
|
|
|
+ GetWebhookServerStub func() *webhook.Server
|
|
|
+ getWebhookServerMutex sync.RWMutex
|
|
|
+ getWebhookServerArgsForCall []struct {
|
|
|
+ }
|
|
|
+ getWebhookServerReturns struct {
|
|
|
+ result1 *webhook.Server
|
|
|
+ }
|
|
|
+ getWebhookServerReturnsOnCall map[int]struct {
|
|
|
+ result1 *webhook.Server
|
|
|
+ }
|
|
|
+ SetFieldsStub func(interface{}) error
|
|
|
+ setFieldsMutex sync.RWMutex
|
|
|
+ setFieldsArgsForCall []struct {
|
|
|
+ arg1 interface{}
|
|
|
+ }
|
|
|
+ setFieldsReturns struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ setFieldsReturnsOnCall map[int]struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ StartStub func(context.Context) error
|
|
|
+ startMutex sync.RWMutex
|
|
|
+ startArgsForCall []struct {
|
|
|
+ arg1 context.Context
|
|
|
+ }
|
|
|
+ startReturns struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ startReturnsOnCall map[int]struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ invocations map[string][][]interface{}
|
|
|
+ invocationsMutex sync.RWMutex
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) Add(arg1 manager.Runnable) error {
|
|
|
+ fake.addMutex.Lock()
|
|
|
+ ret, specificReturn := fake.addReturnsOnCall[len(fake.addArgsForCall)]
|
|
|
+ fake.addArgsForCall = append(fake.addArgsForCall, struct {
|
|
|
+ arg1 manager.Runnable
|
|
|
+ }{arg1})
|
|
|
+ stub := fake.AddStub
|
|
|
+ fakeReturns := fake.addReturns
|
|
|
+ fake.recordInvocation("Add", []interface{}{arg1})
|
|
|
+ fake.addMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) AddCallCount() int {
|
|
|
+ fake.addMutex.RLock()
|
|
|
+ defer fake.addMutex.RUnlock()
|
|
|
+ return len(fake.addArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) AddCalls(stub func(manager.Runnable) error) {
|
|
|
+ fake.addMutex.Lock()
|
|
|
+ defer fake.addMutex.Unlock()
|
|
|
+ fake.AddStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) AddArgsForCall(i int) manager.Runnable {
|
|
|
+ fake.addMutex.RLock()
|
|
|
+ defer fake.addMutex.RUnlock()
|
|
|
+ argsForCall := fake.addArgsForCall[i]
|
|
|
+ return argsForCall.arg1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) AddReturns(result1 error) {
|
|
|
+ fake.addMutex.Lock()
|
|
|
+ defer fake.addMutex.Unlock()
|
|
|
+ fake.AddStub = nil
|
|
|
+ fake.addReturns = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) AddReturnsOnCall(i int, result1 error) {
|
|
|
+ fake.addMutex.Lock()
|
|
|
+ defer fake.addMutex.Unlock()
|
|
|
+ fake.AddStub = nil
|
|
|
+ if fake.addReturnsOnCall == nil {
|
|
|
+ fake.addReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.addReturnsOnCall[i] = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) AddHealthzCheck(arg1 string, arg2 healthz.Checker) error {
|
|
|
+ fake.addHealthzCheckMutex.Lock()
|
|
|
+ ret, specificReturn := fake.addHealthzCheckReturnsOnCall[len(fake.addHealthzCheckArgsForCall)]
|
|
|
+ fake.addHealthzCheckArgsForCall = append(fake.addHealthzCheckArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 healthz.Checker
|
|
|
+ }{arg1, arg2})
|
|
|
+ stub := fake.AddHealthzCheckStub
|
|
|
+ fakeReturns := fake.addHealthzCheckReturns
|
|
|
+ fake.recordInvocation("AddHealthzCheck", []interface{}{arg1, arg2})
|
|
|
+ fake.addHealthzCheckMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1, arg2)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) AddHealthzCheckCallCount() int {
|
|
|
+ fake.addHealthzCheckMutex.RLock()
|
|
|
+ defer fake.addHealthzCheckMutex.RUnlock()
|
|
|
+ return len(fake.addHealthzCheckArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) AddHealthzCheckCalls(stub func(string, healthz.Checker) error) {
|
|
|
+ fake.addHealthzCheckMutex.Lock()
|
|
|
+ defer fake.addHealthzCheckMutex.Unlock()
|
|
|
+ fake.AddHealthzCheckStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) AddHealthzCheckArgsForCall(i int) (string, healthz.Checker) {
|
|
|
+ fake.addHealthzCheckMutex.RLock()
|
|
|
+ defer fake.addHealthzCheckMutex.RUnlock()
|
|
|
+ argsForCall := fake.addHealthzCheckArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) AddHealthzCheckReturns(result1 error) {
|
|
|
+ fake.addHealthzCheckMutex.Lock()
|
|
|
+ defer fake.addHealthzCheckMutex.Unlock()
|
|
|
+ fake.AddHealthzCheckStub = nil
|
|
|
+ fake.addHealthzCheckReturns = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) AddHealthzCheckReturnsOnCall(i int, result1 error) {
|
|
|
+ fake.addHealthzCheckMutex.Lock()
|
|
|
+ defer fake.addHealthzCheckMutex.Unlock()
|
|
|
+ fake.AddHealthzCheckStub = nil
|
|
|
+ if fake.addHealthzCheckReturnsOnCall == nil {
|
|
|
+ fake.addHealthzCheckReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.addHealthzCheckReturnsOnCall[i] = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) AddMetricsExtraHandler(arg1 string, arg2 http.Handler) error {
|
|
|
+ fake.addMetricsExtraHandlerMutex.Lock()
|
|
|
+ ret, specificReturn := fake.addMetricsExtraHandlerReturnsOnCall[len(fake.addMetricsExtraHandlerArgsForCall)]
|
|
|
+ fake.addMetricsExtraHandlerArgsForCall = append(fake.addMetricsExtraHandlerArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 http.Handler
|
|
|
+ }{arg1, arg2})
|
|
|
+ stub := fake.AddMetricsExtraHandlerStub
|
|
|
+ fakeReturns := fake.addMetricsExtraHandlerReturns
|
|
|
+ fake.recordInvocation("AddMetricsExtraHandler", []interface{}{arg1, arg2})
|
|
|
+ fake.addMetricsExtraHandlerMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1, arg2)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) AddMetricsExtraHandlerCallCount() int {
|
|
|
+ fake.addMetricsExtraHandlerMutex.RLock()
|
|
|
+ defer fake.addMetricsExtraHandlerMutex.RUnlock()
|
|
|
+ return len(fake.addMetricsExtraHandlerArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) AddMetricsExtraHandlerCalls(stub func(string, http.Handler) error) {
|
|
|
+ fake.addMetricsExtraHandlerMutex.Lock()
|
|
|
+ defer fake.addMetricsExtraHandlerMutex.Unlock()
|
|
|
+ fake.AddMetricsExtraHandlerStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) AddMetricsExtraHandlerArgsForCall(i int) (string, http.Handler) {
|
|
|
+ fake.addMetricsExtraHandlerMutex.RLock()
|
|
|
+ defer fake.addMetricsExtraHandlerMutex.RUnlock()
|
|
|
+ argsForCall := fake.addMetricsExtraHandlerArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) AddMetricsExtraHandlerReturns(result1 error) {
|
|
|
+ fake.addMetricsExtraHandlerMutex.Lock()
|
|
|
+ defer fake.addMetricsExtraHandlerMutex.Unlock()
|
|
|
+ fake.AddMetricsExtraHandlerStub = nil
|
|
|
+ fake.addMetricsExtraHandlerReturns = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) AddMetricsExtraHandlerReturnsOnCall(i int, result1 error) {
|
|
|
+ fake.addMetricsExtraHandlerMutex.Lock()
|
|
|
+ defer fake.addMetricsExtraHandlerMutex.Unlock()
|
|
|
+ fake.AddMetricsExtraHandlerStub = nil
|
|
|
+ if fake.addMetricsExtraHandlerReturnsOnCall == nil {
|
|
|
+ fake.addMetricsExtraHandlerReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.addMetricsExtraHandlerReturnsOnCall[i] = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) AddReadyzCheck(arg1 string, arg2 healthz.Checker) error {
|
|
|
+ fake.addReadyzCheckMutex.Lock()
|
|
|
+ ret, specificReturn := fake.addReadyzCheckReturnsOnCall[len(fake.addReadyzCheckArgsForCall)]
|
|
|
+ fake.addReadyzCheckArgsForCall = append(fake.addReadyzCheckArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 healthz.Checker
|
|
|
+ }{arg1, arg2})
|
|
|
+ stub := fake.AddReadyzCheckStub
|
|
|
+ fakeReturns := fake.addReadyzCheckReturns
|
|
|
+ fake.recordInvocation("AddReadyzCheck", []interface{}{arg1, arg2})
|
|
|
+ fake.addReadyzCheckMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1, arg2)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) AddReadyzCheckCallCount() int {
|
|
|
+ fake.addReadyzCheckMutex.RLock()
|
|
|
+ defer fake.addReadyzCheckMutex.RUnlock()
|
|
|
+ return len(fake.addReadyzCheckArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) AddReadyzCheckCalls(stub func(string, healthz.Checker) error) {
|
|
|
+ fake.addReadyzCheckMutex.Lock()
|
|
|
+ defer fake.addReadyzCheckMutex.Unlock()
|
|
|
+ fake.AddReadyzCheckStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) AddReadyzCheckArgsForCall(i int) (string, healthz.Checker) {
|
|
|
+ fake.addReadyzCheckMutex.RLock()
|
|
|
+ defer fake.addReadyzCheckMutex.RUnlock()
|
|
|
+ argsForCall := fake.addReadyzCheckArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) AddReadyzCheckReturns(result1 error) {
|
|
|
+ fake.addReadyzCheckMutex.Lock()
|
|
|
+ defer fake.addReadyzCheckMutex.Unlock()
|
|
|
+ fake.AddReadyzCheckStub = nil
|
|
|
+ fake.addReadyzCheckReturns = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) AddReadyzCheckReturnsOnCall(i int, result1 error) {
|
|
|
+ fake.addReadyzCheckMutex.Lock()
|
|
|
+ defer fake.addReadyzCheckMutex.Unlock()
|
|
|
+ fake.AddReadyzCheckStub = nil
|
|
|
+ if fake.addReadyzCheckReturnsOnCall == nil {
|
|
|
+ fake.addReadyzCheckReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.addReadyzCheckReturnsOnCall[i] = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) Elected() <-chan struct{} {
|
|
|
+ fake.electedMutex.Lock()
|
|
|
+ ret, specificReturn := fake.electedReturnsOnCall[len(fake.electedArgsForCall)]
|
|
|
+ fake.electedArgsForCall = append(fake.electedArgsForCall, struct {
|
|
|
+ }{})
|
|
|
+ stub := fake.ElectedStub
|
|
|
+ fakeReturns := fake.electedReturns
|
|
|
+ fake.recordInvocation("Elected", []interface{}{})
|
|
|
+ fake.electedMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub()
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) ElectedCallCount() int {
|
|
|
+ fake.electedMutex.RLock()
|
|
|
+ defer fake.electedMutex.RUnlock()
|
|
|
+ return len(fake.electedArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) ElectedCalls(stub func() <-chan struct{}) {
|
|
|
+ fake.electedMutex.Lock()
|
|
|
+ defer fake.electedMutex.Unlock()
|
|
|
+ fake.ElectedStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) ElectedReturns(result1 <-chan struct{}) {
|
|
|
+ fake.electedMutex.Lock()
|
|
|
+ defer fake.electedMutex.Unlock()
|
|
|
+ fake.ElectedStub = nil
|
|
|
+ fake.electedReturns = struct {
|
|
|
+ result1 <-chan struct{}
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) ElectedReturnsOnCall(i int, result1 <-chan struct{}) {
|
|
|
+ fake.electedMutex.Lock()
|
|
|
+ defer fake.electedMutex.Unlock()
|
|
|
+ fake.ElectedStub = nil
|
|
|
+ if fake.electedReturnsOnCall == nil {
|
|
|
+ fake.electedReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 <-chan struct{}
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.electedReturnsOnCall[i] = struct {
|
|
|
+ result1 <-chan struct{}
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetAPIReader() client.Reader {
|
|
|
+ fake.getAPIReaderMutex.Lock()
|
|
|
+ ret, specificReturn := fake.getAPIReaderReturnsOnCall[len(fake.getAPIReaderArgsForCall)]
|
|
|
+ fake.getAPIReaderArgsForCall = append(fake.getAPIReaderArgsForCall, struct {
|
|
|
+ }{})
|
|
|
+ stub := fake.GetAPIReaderStub
|
|
|
+ fakeReturns := fake.getAPIReaderReturns
|
|
|
+ fake.recordInvocation("GetAPIReader", []interface{}{})
|
|
|
+ fake.getAPIReaderMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub()
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetAPIReaderCallCount() int {
|
|
|
+ fake.getAPIReaderMutex.RLock()
|
|
|
+ defer fake.getAPIReaderMutex.RUnlock()
|
|
|
+ return len(fake.getAPIReaderArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetAPIReaderCalls(stub func() client.Reader) {
|
|
|
+ fake.getAPIReaderMutex.Lock()
|
|
|
+ defer fake.getAPIReaderMutex.Unlock()
|
|
|
+ fake.GetAPIReaderStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetAPIReaderReturns(result1 client.Reader) {
|
|
|
+ fake.getAPIReaderMutex.Lock()
|
|
|
+ defer fake.getAPIReaderMutex.Unlock()
|
|
|
+ fake.GetAPIReaderStub = nil
|
|
|
+ fake.getAPIReaderReturns = struct {
|
|
|
+ result1 client.Reader
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetAPIReaderReturnsOnCall(i int, result1 client.Reader) {
|
|
|
+ fake.getAPIReaderMutex.Lock()
|
|
|
+ defer fake.getAPIReaderMutex.Unlock()
|
|
|
+ fake.GetAPIReaderStub = nil
|
|
|
+ if fake.getAPIReaderReturnsOnCall == nil {
|
|
|
+ fake.getAPIReaderReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 client.Reader
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.getAPIReaderReturnsOnCall[i] = struct {
|
|
|
+ result1 client.Reader
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetCache() cache.Cache {
|
|
|
+ fake.getCacheMutex.Lock()
|
|
|
+ ret, specificReturn := fake.getCacheReturnsOnCall[len(fake.getCacheArgsForCall)]
|
|
|
+ fake.getCacheArgsForCall = append(fake.getCacheArgsForCall, struct {
|
|
|
+ }{})
|
|
|
+ stub := fake.GetCacheStub
|
|
|
+ fakeReturns := fake.getCacheReturns
|
|
|
+ fake.recordInvocation("GetCache", []interface{}{})
|
|
|
+ fake.getCacheMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub()
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetCacheCallCount() int {
|
|
|
+ fake.getCacheMutex.RLock()
|
|
|
+ defer fake.getCacheMutex.RUnlock()
|
|
|
+ return len(fake.getCacheArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetCacheCalls(stub func() cache.Cache) {
|
|
|
+ fake.getCacheMutex.Lock()
|
|
|
+ defer fake.getCacheMutex.Unlock()
|
|
|
+ fake.GetCacheStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetCacheReturns(result1 cache.Cache) {
|
|
|
+ fake.getCacheMutex.Lock()
|
|
|
+ defer fake.getCacheMutex.Unlock()
|
|
|
+ fake.GetCacheStub = nil
|
|
|
+ fake.getCacheReturns = struct {
|
|
|
+ result1 cache.Cache
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetCacheReturnsOnCall(i int, result1 cache.Cache) {
|
|
|
+ fake.getCacheMutex.Lock()
|
|
|
+ defer fake.getCacheMutex.Unlock()
|
|
|
+ fake.GetCacheStub = nil
|
|
|
+ if fake.getCacheReturnsOnCall == nil {
|
|
|
+ fake.getCacheReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 cache.Cache
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.getCacheReturnsOnCall[i] = struct {
|
|
|
+ result1 cache.Cache
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetClient() client.Client {
|
|
|
+ fake.getClientMutex.Lock()
|
|
|
+ ret, specificReturn := fake.getClientReturnsOnCall[len(fake.getClientArgsForCall)]
|
|
|
+ fake.getClientArgsForCall = append(fake.getClientArgsForCall, struct {
|
|
|
+ }{})
|
|
|
+ stub := fake.GetClientStub
|
|
|
+ fakeReturns := fake.getClientReturns
|
|
|
+ fake.recordInvocation("GetClient", []interface{}{})
|
|
|
+ fake.getClientMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub()
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetClientCallCount() int {
|
|
|
+ fake.getClientMutex.RLock()
|
|
|
+ defer fake.getClientMutex.RUnlock()
|
|
|
+ return len(fake.getClientArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetClientCalls(stub func() client.Client) {
|
|
|
+ fake.getClientMutex.Lock()
|
|
|
+ defer fake.getClientMutex.Unlock()
|
|
|
+ fake.GetClientStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetClientReturns(result1 client.Client) {
|
|
|
+ fake.getClientMutex.Lock()
|
|
|
+ defer fake.getClientMutex.Unlock()
|
|
|
+ fake.GetClientStub = nil
|
|
|
+ fake.getClientReturns = struct {
|
|
|
+ result1 client.Client
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetClientReturnsOnCall(i int, result1 client.Client) {
|
|
|
+ fake.getClientMutex.Lock()
|
|
|
+ defer fake.getClientMutex.Unlock()
|
|
|
+ fake.GetClientStub = nil
|
|
|
+ if fake.getClientReturnsOnCall == nil {
|
|
|
+ fake.getClientReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 client.Client
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.getClientReturnsOnCall[i] = struct {
|
|
|
+ result1 client.Client
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetConfig() *rest.Config {
|
|
|
+ fake.getConfigMutex.Lock()
|
|
|
+ ret, specificReturn := fake.getConfigReturnsOnCall[len(fake.getConfigArgsForCall)]
|
|
|
+ fake.getConfigArgsForCall = append(fake.getConfigArgsForCall, struct {
|
|
|
+ }{})
|
|
|
+ stub := fake.GetConfigStub
|
|
|
+ fakeReturns := fake.getConfigReturns
|
|
|
+ fake.recordInvocation("GetConfig", []interface{}{})
|
|
|
+ fake.getConfigMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub()
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetConfigCallCount() int {
|
|
|
+ fake.getConfigMutex.RLock()
|
|
|
+ defer fake.getConfigMutex.RUnlock()
|
|
|
+ return len(fake.getConfigArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetConfigCalls(stub func() *rest.Config) {
|
|
|
+ fake.getConfigMutex.Lock()
|
|
|
+ defer fake.getConfigMutex.Unlock()
|
|
|
+ fake.GetConfigStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetConfigReturns(result1 *rest.Config) {
|
|
|
+ fake.getConfigMutex.Lock()
|
|
|
+ defer fake.getConfigMutex.Unlock()
|
|
|
+ fake.GetConfigStub = nil
|
|
|
+ fake.getConfigReturns = struct {
|
|
|
+ result1 *rest.Config
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetConfigReturnsOnCall(i int, result1 *rest.Config) {
|
|
|
+ fake.getConfigMutex.Lock()
|
|
|
+ defer fake.getConfigMutex.Unlock()
|
|
|
+ fake.GetConfigStub = nil
|
|
|
+ if fake.getConfigReturnsOnCall == nil {
|
|
|
+ fake.getConfigReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 *rest.Config
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.getConfigReturnsOnCall[i] = struct {
|
|
|
+ result1 *rest.Config
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetControllerOptions() v1alpha1.ControllerConfigurationSpec {
|
|
|
+ fake.getControllerOptionsMutex.Lock()
|
|
|
+ ret, specificReturn := fake.getControllerOptionsReturnsOnCall[len(fake.getControllerOptionsArgsForCall)]
|
|
|
+ fake.getControllerOptionsArgsForCall = append(fake.getControllerOptionsArgsForCall, struct {
|
|
|
+ }{})
|
|
|
+ stub := fake.GetControllerOptionsStub
|
|
|
+ fakeReturns := fake.getControllerOptionsReturns
|
|
|
+ fake.recordInvocation("GetControllerOptions", []interface{}{})
|
|
|
+ fake.getControllerOptionsMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub()
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetControllerOptionsCallCount() int {
|
|
|
+ fake.getControllerOptionsMutex.RLock()
|
|
|
+ defer fake.getControllerOptionsMutex.RUnlock()
|
|
|
+ return len(fake.getControllerOptionsArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetControllerOptionsCalls(stub func() v1alpha1.ControllerConfigurationSpec) {
|
|
|
+ fake.getControllerOptionsMutex.Lock()
|
|
|
+ defer fake.getControllerOptionsMutex.Unlock()
|
|
|
+ fake.GetControllerOptionsStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetControllerOptionsReturns(result1 v1alpha1.ControllerConfigurationSpec) {
|
|
|
+ fake.getControllerOptionsMutex.Lock()
|
|
|
+ defer fake.getControllerOptionsMutex.Unlock()
|
|
|
+ fake.GetControllerOptionsStub = nil
|
|
|
+ fake.getControllerOptionsReturns = struct {
|
|
|
+ result1 v1alpha1.ControllerConfigurationSpec
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetControllerOptionsReturnsOnCall(i int, result1 v1alpha1.ControllerConfigurationSpec) {
|
|
|
+ fake.getControllerOptionsMutex.Lock()
|
|
|
+ defer fake.getControllerOptionsMutex.Unlock()
|
|
|
+ fake.GetControllerOptionsStub = nil
|
|
|
+ if fake.getControllerOptionsReturnsOnCall == nil {
|
|
|
+ fake.getControllerOptionsReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 v1alpha1.ControllerConfigurationSpec
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.getControllerOptionsReturnsOnCall[i] = struct {
|
|
|
+ result1 v1alpha1.ControllerConfigurationSpec
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetEventRecorderFor(arg1 string) record.EventRecorder {
|
|
|
+ fake.getEventRecorderForMutex.Lock()
|
|
|
+ ret, specificReturn := fake.getEventRecorderForReturnsOnCall[len(fake.getEventRecorderForArgsForCall)]
|
|
|
+ fake.getEventRecorderForArgsForCall = append(fake.getEventRecorderForArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ }{arg1})
|
|
|
+ stub := fake.GetEventRecorderForStub
|
|
|
+ fakeReturns := fake.getEventRecorderForReturns
|
|
|
+ fake.recordInvocation("GetEventRecorderFor", []interface{}{arg1})
|
|
|
+ fake.getEventRecorderForMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetEventRecorderForCallCount() int {
|
|
|
+ fake.getEventRecorderForMutex.RLock()
|
|
|
+ defer fake.getEventRecorderForMutex.RUnlock()
|
|
|
+ return len(fake.getEventRecorderForArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetEventRecorderForCalls(stub func(string) record.EventRecorder) {
|
|
|
+ fake.getEventRecorderForMutex.Lock()
|
|
|
+ defer fake.getEventRecorderForMutex.Unlock()
|
|
|
+ fake.GetEventRecorderForStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetEventRecorderForArgsForCall(i int) string {
|
|
|
+ fake.getEventRecorderForMutex.RLock()
|
|
|
+ defer fake.getEventRecorderForMutex.RUnlock()
|
|
|
+ argsForCall := fake.getEventRecorderForArgsForCall[i]
|
|
|
+ return argsForCall.arg1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetEventRecorderForReturns(result1 record.EventRecorder) {
|
|
|
+ fake.getEventRecorderForMutex.Lock()
|
|
|
+ defer fake.getEventRecorderForMutex.Unlock()
|
|
|
+ fake.GetEventRecorderForStub = nil
|
|
|
+ fake.getEventRecorderForReturns = struct {
|
|
|
+ result1 record.EventRecorder
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetEventRecorderForReturnsOnCall(i int, result1 record.EventRecorder) {
|
|
|
+ fake.getEventRecorderForMutex.Lock()
|
|
|
+ defer fake.getEventRecorderForMutex.Unlock()
|
|
|
+ fake.GetEventRecorderForStub = nil
|
|
|
+ if fake.getEventRecorderForReturnsOnCall == nil {
|
|
|
+ fake.getEventRecorderForReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 record.EventRecorder
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.getEventRecorderForReturnsOnCall[i] = struct {
|
|
|
+ result1 record.EventRecorder
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetFieldIndexer() client.FieldIndexer {
|
|
|
+ fake.getFieldIndexerMutex.Lock()
|
|
|
+ ret, specificReturn := fake.getFieldIndexerReturnsOnCall[len(fake.getFieldIndexerArgsForCall)]
|
|
|
+ fake.getFieldIndexerArgsForCall = append(fake.getFieldIndexerArgsForCall, struct {
|
|
|
+ }{})
|
|
|
+ stub := fake.GetFieldIndexerStub
|
|
|
+ fakeReturns := fake.getFieldIndexerReturns
|
|
|
+ fake.recordInvocation("GetFieldIndexer", []interface{}{})
|
|
|
+ fake.getFieldIndexerMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub()
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetFieldIndexerCallCount() int {
|
|
|
+ fake.getFieldIndexerMutex.RLock()
|
|
|
+ defer fake.getFieldIndexerMutex.RUnlock()
|
|
|
+ return len(fake.getFieldIndexerArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetFieldIndexerCalls(stub func() client.FieldIndexer) {
|
|
|
+ fake.getFieldIndexerMutex.Lock()
|
|
|
+ defer fake.getFieldIndexerMutex.Unlock()
|
|
|
+ fake.GetFieldIndexerStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetFieldIndexerReturns(result1 client.FieldIndexer) {
|
|
|
+ fake.getFieldIndexerMutex.Lock()
|
|
|
+ defer fake.getFieldIndexerMutex.Unlock()
|
|
|
+ fake.GetFieldIndexerStub = nil
|
|
|
+ fake.getFieldIndexerReturns = struct {
|
|
|
+ result1 client.FieldIndexer
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetFieldIndexerReturnsOnCall(i int, result1 client.FieldIndexer) {
|
|
|
+ fake.getFieldIndexerMutex.Lock()
|
|
|
+ defer fake.getFieldIndexerMutex.Unlock()
|
|
|
+ fake.GetFieldIndexerStub = nil
|
|
|
+ if fake.getFieldIndexerReturnsOnCall == nil {
|
|
|
+ fake.getFieldIndexerReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 client.FieldIndexer
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.getFieldIndexerReturnsOnCall[i] = struct {
|
|
|
+ result1 client.FieldIndexer
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetLogger() logr.Logger {
|
|
|
+ fake.getLoggerMutex.Lock()
|
|
|
+ ret, specificReturn := fake.getLoggerReturnsOnCall[len(fake.getLoggerArgsForCall)]
|
|
|
+ fake.getLoggerArgsForCall = append(fake.getLoggerArgsForCall, struct {
|
|
|
+ }{})
|
|
|
+ stub := fake.GetLoggerStub
|
|
|
+ fakeReturns := fake.getLoggerReturns
|
|
|
+ fake.recordInvocation("GetLogger", []interface{}{})
|
|
|
+ fake.getLoggerMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub()
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetLoggerCallCount() int {
|
|
|
+ fake.getLoggerMutex.RLock()
|
|
|
+ defer fake.getLoggerMutex.RUnlock()
|
|
|
+ return len(fake.getLoggerArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetLoggerCalls(stub func() logr.Logger) {
|
|
|
+ fake.getLoggerMutex.Lock()
|
|
|
+ defer fake.getLoggerMutex.Unlock()
|
|
|
+ fake.GetLoggerStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetLoggerReturns(result1 logr.Logger) {
|
|
|
+ fake.getLoggerMutex.Lock()
|
|
|
+ defer fake.getLoggerMutex.Unlock()
|
|
|
+ fake.GetLoggerStub = nil
|
|
|
+ fake.getLoggerReturns = struct {
|
|
|
+ result1 logr.Logger
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetLoggerReturnsOnCall(i int, result1 logr.Logger) {
|
|
|
+ fake.getLoggerMutex.Lock()
|
|
|
+ defer fake.getLoggerMutex.Unlock()
|
|
|
+ fake.GetLoggerStub = nil
|
|
|
+ if fake.getLoggerReturnsOnCall == nil {
|
|
|
+ fake.getLoggerReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 logr.Logger
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.getLoggerReturnsOnCall[i] = struct {
|
|
|
+ result1 logr.Logger
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetRESTMapper() meta.RESTMapper {
|
|
|
+ fake.getRESTMapperMutex.Lock()
|
|
|
+ ret, specificReturn := fake.getRESTMapperReturnsOnCall[len(fake.getRESTMapperArgsForCall)]
|
|
|
+ fake.getRESTMapperArgsForCall = append(fake.getRESTMapperArgsForCall, struct {
|
|
|
+ }{})
|
|
|
+ stub := fake.GetRESTMapperStub
|
|
|
+ fakeReturns := fake.getRESTMapperReturns
|
|
|
+ fake.recordInvocation("GetRESTMapper", []interface{}{})
|
|
|
+ fake.getRESTMapperMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub()
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetRESTMapperCallCount() int {
|
|
|
+ fake.getRESTMapperMutex.RLock()
|
|
|
+ defer fake.getRESTMapperMutex.RUnlock()
|
|
|
+ return len(fake.getRESTMapperArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetRESTMapperCalls(stub func() meta.RESTMapper) {
|
|
|
+ fake.getRESTMapperMutex.Lock()
|
|
|
+ defer fake.getRESTMapperMutex.Unlock()
|
|
|
+ fake.GetRESTMapperStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetRESTMapperReturns(result1 meta.RESTMapper) {
|
|
|
+ fake.getRESTMapperMutex.Lock()
|
|
|
+ defer fake.getRESTMapperMutex.Unlock()
|
|
|
+ fake.GetRESTMapperStub = nil
|
|
|
+ fake.getRESTMapperReturns = struct {
|
|
|
+ result1 meta.RESTMapper
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetRESTMapperReturnsOnCall(i int, result1 meta.RESTMapper) {
|
|
|
+ fake.getRESTMapperMutex.Lock()
|
|
|
+ defer fake.getRESTMapperMutex.Unlock()
|
|
|
+ fake.GetRESTMapperStub = nil
|
|
|
+ if fake.getRESTMapperReturnsOnCall == nil {
|
|
|
+ fake.getRESTMapperReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 meta.RESTMapper
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.getRESTMapperReturnsOnCall[i] = struct {
|
|
|
+ result1 meta.RESTMapper
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetScheme() *runtime.Scheme {
|
|
|
+ fake.getSchemeMutex.Lock()
|
|
|
+ ret, specificReturn := fake.getSchemeReturnsOnCall[len(fake.getSchemeArgsForCall)]
|
|
|
+ fake.getSchemeArgsForCall = append(fake.getSchemeArgsForCall, struct {
|
|
|
+ }{})
|
|
|
+ stub := fake.GetSchemeStub
|
|
|
+ fakeReturns := fake.getSchemeReturns
|
|
|
+ fake.recordInvocation("GetScheme", []interface{}{})
|
|
|
+ fake.getSchemeMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub()
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetSchemeCallCount() int {
|
|
|
+ fake.getSchemeMutex.RLock()
|
|
|
+ defer fake.getSchemeMutex.RUnlock()
|
|
|
+ return len(fake.getSchemeArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetSchemeCalls(stub func() *runtime.Scheme) {
|
|
|
+ fake.getSchemeMutex.Lock()
|
|
|
+ defer fake.getSchemeMutex.Unlock()
|
|
|
+ fake.GetSchemeStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetSchemeReturns(result1 *runtime.Scheme) {
|
|
|
+ fake.getSchemeMutex.Lock()
|
|
|
+ defer fake.getSchemeMutex.Unlock()
|
|
|
+ fake.GetSchemeStub = nil
|
|
|
+ fake.getSchemeReturns = struct {
|
|
|
+ result1 *runtime.Scheme
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetSchemeReturnsOnCall(i int, result1 *runtime.Scheme) {
|
|
|
+ fake.getSchemeMutex.Lock()
|
|
|
+ defer fake.getSchemeMutex.Unlock()
|
|
|
+ fake.GetSchemeStub = nil
|
|
|
+ if fake.getSchemeReturnsOnCall == nil {
|
|
|
+ fake.getSchemeReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 *runtime.Scheme
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.getSchemeReturnsOnCall[i] = struct {
|
|
|
+ result1 *runtime.Scheme
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetWebhookServer() *webhook.Server {
|
|
|
+ fake.getWebhookServerMutex.Lock()
|
|
|
+ ret, specificReturn := fake.getWebhookServerReturnsOnCall[len(fake.getWebhookServerArgsForCall)]
|
|
|
+ fake.getWebhookServerArgsForCall = append(fake.getWebhookServerArgsForCall, struct {
|
|
|
+ }{})
|
|
|
+ stub := fake.GetWebhookServerStub
|
|
|
+ fakeReturns := fake.getWebhookServerReturns
|
|
|
+ fake.recordInvocation("GetWebhookServer", []interface{}{})
|
|
|
+ fake.getWebhookServerMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub()
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetWebhookServerCallCount() int {
|
|
|
+ fake.getWebhookServerMutex.RLock()
|
|
|
+ defer fake.getWebhookServerMutex.RUnlock()
|
|
|
+ return len(fake.getWebhookServerArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetWebhookServerCalls(stub func() *webhook.Server) {
|
|
|
+ fake.getWebhookServerMutex.Lock()
|
|
|
+ defer fake.getWebhookServerMutex.Unlock()
|
|
|
+ fake.GetWebhookServerStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetWebhookServerReturns(result1 *webhook.Server) {
|
|
|
+ fake.getWebhookServerMutex.Lock()
|
|
|
+ defer fake.getWebhookServerMutex.Unlock()
|
|
|
+ fake.GetWebhookServerStub = nil
|
|
|
+ fake.getWebhookServerReturns = struct {
|
|
|
+ result1 *webhook.Server
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) GetWebhookServerReturnsOnCall(i int, result1 *webhook.Server) {
|
|
|
+ fake.getWebhookServerMutex.Lock()
|
|
|
+ defer fake.getWebhookServerMutex.Unlock()
|
|
|
+ fake.GetWebhookServerStub = nil
|
|
|
+ if fake.getWebhookServerReturnsOnCall == nil {
|
|
|
+ fake.getWebhookServerReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 *webhook.Server
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.getWebhookServerReturnsOnCall[i] = struct {
|
|
|
+ result1 *webhook.Server
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) SetFields(arg1 interface{}) error {
|
|
|
+ fake.setFieldsMutex.Lock()
|
|
|
+ ret, specificReturn := fake.setFieldsReturnsOnCall[len(fake.setFieldsArgsForCall)]
|
|
|
+ fake.setFieldsArgsForCall = append(fake.setFieldsArgsForCall, struct {
|
|
|
+ arg1 interface{}
|
|
|
+ }{arg1})
|
|
|
+ stub := fake.SetFieldsStub
|
|
|
+ fakeReturns := fake.setFieldsReturns
|
|
|
+ fake.recordInvocation("SetFields", []interface{}{arg1})
|
|
|
+ fake.setFieldsMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) SetFieldsCallCount() int {
|
|
|
+ fake.setFieldsMutex.RLock()
|
|
|
+ defer fake.setFieldsMutex.RUnlock()
|
|
|
+ return len(fake.setFieldsArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) SetFieldsCalls(stub func(interface{}) error) {
|
|
|
+ fake.setFieldsMutex.Lock()
|
|
|
+ defer fake.setFieldsMutex.Unlock()
|
|
|
+ fake.SetFieldsStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) SetFieldsArgsForCall(i int) interface{} {
|
|
|
+ fake.setFieldsMutex.RLock()
|
|
|
+ defer fake.setFieldsMutex.RUnlock()
|
|
|
+ argsForCall := fake.setFieldsArgsForCall[i]
|
|
|
+ return argsForCall.arg1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) SetFieldsReturns(result1 error) {
|
|
|
+ fake.setFieldsMutex.Lock()
|
|
|
+ defer fake.setFieldsMutex.Unlock()
|
|
|
+ fake.SetFieldsStub = nil
|
|
|
+ fake.setFieldsReturns = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) SetFieldsReturnsOnCall(i int, result1 error) {
|
|
|
+ fake.setFieldsMutex.Lock()
|
|
|
+ defer fake.setFieldsMutex.Unlock()
|
|
|
+ fake.SetFieldsStub = nil
|
|
|
+ if fake.setFieldsReturnsOnCall == nil {
|
|
|
+ fake.setFieldsReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.setFieldsReturnsOnCall[i] = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) Start(arg1 context.Context) error {
|
|
|
+ fake.startMutex.Lock()
|
|
|
+ ret, specificReturn := fake.startReturnsOnCall[len(fake.startArgsForCall)]
|
|
|
+ fake.startArgsForCall = append(fake.startArgsForCall, struct {
|
|
|
+ arg1 context.Context
|
|
|
+ }{arg1})
|
|
|
+ stub := fake.StartStub
|
|
|
+ fakeReturns := fake.startReturns
|
|
|
+ fake.recordInvocation("Start", []interface{}{arg1})
|
|
|
+ fake.startMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) StartCallCount() int {
|
|
|
+ fake.startMutex.RLock()
|
|
|
+ defer fake.startMutex.RUnlock()
|
|
|
+ return len(fake.startArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) StartCalls(stub func(context.Context) error) {
|
|
|
+ fake.startMutex.Lock()
|
|
|
+ defer fake.startMutex.Unlock()
|
|
|
+ fake.StartStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) StartArgsForCall(i int) context.Context {
|
|
|
+ fake.startMutex.RLock()
|
|
|
+ defer fake.startMutex.RUnlock()
|
|
|
+ argsForCall := fake.startArgsForCall[i]
|
|
|
+ return argsForCall.arg1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) StartReturns(result1 error) {
|
|
|
+ fake.startMutex.Lock()
|
|
|
+ defer fake.startMutex.Unlock()
|
|
|
+ fake.StartStub = nil
|
|
|
+ fake.startReturns = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) StartReturnsOnCall(i int, result1 error) {
|
|
|
+ fake.startMutex.Lock()
|
|
|
+ defer fake.startMutex.Unlock()
|
|
|
+ fake.StartStub = nil
|
|
|
+ if fake.startReturnsOnCall == nil {
|
|
|
+ fake.startReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.startReturnsOnCall[i] = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) Invocations() map[string][][]interface{} {
|
|
|
+ fake.invocationsMutex.RLock()
|
|
|
+ defer fake.invocationsMutex.RUnlock()
|
|
|
+ fake.addMutex.RLock()
|
|
|
+ defer fake.addMutex.RUnlock()
|
|
|
+ fake.addHealthzCheckMutex.RLock()
|
|
|
+ defer fake.addHealthzCheckMutex.RUnlock()
|
|
|
+ fake.addMetricsExtraHandlerMutex.RLock()
|
|
|
+ defer fake.addMetricsExtraHandlerMutex.RUnlock()
|
|
|
+ fake.addReadyzCheckMutex.RLock()
|
|
|
+ defer fake.addReadyzCheckMutex.RUnlock()
|
|
|
+ fake.electedMutex.RLock()
|
|
|
+ defer fake.electedMutex.RUnlock()
|
|
|
+ fake.getAPIReaderMutex.RLock()
|
|
|
+ defer fake.getAPIReaderMutex.RUnlock()
|
|
|
+ fake.getCacheMutex.RLock()
|
|
|
+ defer fake.getCacheMutex.RUnlock()
|
|
|
+ fake.getClientMutex.RLock()
|
|
|
+ defer fake.getClientMutex.RUnlock()
|
|
|
+ fake.getConfigMutex.RLock()
|
|
|
+ defer fake.getConfigMutex.RUnlock()
|
|
|
+ fake.getControllerOptionsMutex.RLock()
|
|
|
+ defer fake.getControllerOptionsMutex.RUnlock()
|
|
|
+ fake.getEventRecorderForMutex.RLock()
|
|
|
+ defer fake.getEventRecorderForMutex.RUnlock()
|
|
|
+ fake.getFieldIndexerMutex.RLock()
|
|
|
+ defer fake.getFieldIndexerMutex.RUnlock()
|
|
|
+ fake.getLoggerMutex.RLock()
|
|
|
+ defer fake.getLoggerMutex.RUnlock()
|
|
|
+ fake.getRESTMapperMutex.RLock()
|
|
|
+ defer fake.getRESTMapperMutex.RUnlock()
|
|
|
+ fake.getSchemeMutex.RLock()
|
|
|
+ defer fake.getSchemeMutex.RUnlock()
|
|
|
+ fake.getWebhookServerMutex.RLock()
|
|
|
+ defer fake.getWebhookServerMutex.RUnlock()
|
|
|
+ fake.setFieldsMutex.RLock()
|
|
|
+ defer fake.setFieldsMutex.RUnlock()
|
|
|
+ fake.startMutex.RLock()
|
|
|
+ defer fake.startMutex.RUnlock()
|
|
|
+ copiedInvocations := map[string][][]interface{}{}
|
|
|
+ for key, value := range fake.invocations {
|
|
|
+ copiedInvocations[key] = value
|
|
|
+ }
|
|
|
+ return copiedInvocations
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Manager) recordInvocation(key string, args []interface{}) {
|
|
|
+ fake.invocationsMutex.Lock()
|
|
|
+ defer fake.invocationsMutex.Unlock()
|
|
|
+ if fake.invocations == nil {
|
|
|
+ fake.invocations = map[string][][]interface{}{}
|
|
|
+ }
|
|
|
+ if fake.invocations[key] == nil {
|
|
|
+ fake.invocations[key] = [][]interface{}{}
|
|
|
+ }
|
|
|
+ fake.invocations[key] = append(fake.invocations[key], args)
|
|
|
+}
|
|
|
+
|
|
|
+var _ manager.Manager = new(Manager)
|
William Young