mock_k8sManager_test.go

// Code generated by mockery v2.20.0. DO NOT EDIT.

package main

import (
	cache "sigs.k8s.io/controller-runtime/pkg/cache"
	client "sigs.k8s.io/controller-runtime/pkg/client"

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

	context "context"

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

	http "net/http"

	logr "github.com/go-logr/logr"

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

	meta "k8s.io/apimachinery/pkg/api/meta"

	mock "github.com/stretchr/testify/mock"

	record "k8s.io/client-go/tools/record"

	rest "k8s.io/client-go/rest"

	runtime "k8s.io/apimachinery/pkg/runtime"

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

// mockK8sManager is an autogenerated mock type for the k8sManager type
type mockK8sManager struct {
	mock.Mock
}

type mockK8sManager_Expecter struct {
	mock *mock.Mock
}

func (_m *mockK8sManager) EXPECT() *mockK8sManager_Expecter {
	return &mockK8sManager_Expecter{mock: &_m.Mock}
}

// Add provides a mock function with given fields: _a0
func (_m *mockK8sManager) Add(_a0 manager.Runnable) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(manager.Runnable) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// mockK8sManager_Add_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Add'
type mockK8sManager_Add_Call struct {
	*mock.Call
}

// Add is a helper method to define mock.On call
//   - _a0 manager.Runnable
func (_e *mockK8sManager_Expecter) Add(_a0 interface{}) *mockK8sManager_Add_Call {
	return &mockK8sManager_Add_Call{Call: _e.mock.On("Add", _a0)}
}

func (_c *mockK8sManager_Add_Call) Run(run func(_a0 manager.Runnable)) *mockK8sManager_Add_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(manager.Runnable))
	})
	return _c
}

func (_c *mockK8sManager_Add_Call) Return(_a0 error) *mockK8sManager_Add_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockK8sManager_Add_Call) RunAndReturn(run func(manager.Runnable) error) *mockK8sManager_Add_Call {
	_c.Call.Return(run)
	return _c
}

// AddHealthzCheck provides a mock function with given fields: name, check
func (_m *mockK8sManager) AddHealthzCheck(name string, check healthz.Checker) error {
	ret := _m.Called(name, check)

	var r0 error
	if rf, ok := ret.Get(0).(func(string, healthz.Checker) error); ok {
		r0 = rf(name, check)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// mockK8sManager_AddHealthzCheck_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddHealthzCheck'
type mockK8sManager_AddHealthzCheck_Call struct {
	*mock.Call
}

// AddHealthzCheck is a helper method to define mock.On call
//   - name string
//   - check healthz.Checker
func (_e *mockK8sManager_Expecter) AddHealthzCheck(name interface{}, check interface{}) *mockK8sManager_AddHealthzCheck_Call {
	return &mockK8sManager_AddHealthzCheck_Call{Call: _e.mock.On("AddHealthzCheck", name, check)}
}

func (_c *mockK8sManager_AddHealthzCheck_Call) Run(run func(name string, check healthz.Checker)) *mockK8sManager_AddHealthzCheck_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(healthz.Checker))
	})
	return _c
}

func (_c *mockK8sManager_AddHealthzCheck_Call) Return(_a0 error) *mockK8sManager_AddHealthzCheck_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockK8sManager_AddHealthzCheck_Call) RunAndReturn(run func(string, healthz.Checker) error) *mockK8sManager_AddHealthzCheck_Call {
	_c.Call.Return(run)
	return _c
}

// AddReadyzCheck provides a mock function with given fields: name, check
func (_m *mockK8sManager) AddReadyzCheck(name string, check healthz.Checker) error {
	ret := _m.Called(name, check)

	var r0 error
	if rf, ok := ret.Get(0).(func(string, healthz.Checker) error); ok {
		r0 = rf(name, check)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// mockK8sManager_AddReadyzCheck_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddReadyzCheck'
type mockK8sManager_AddReadyzCheck_Call struct {
	*mock.Call
}

// AddReadyzCheck is a helper method to define mock.On call
//   - name string
//   - check healthz.Checker
func (_e *mockK8sManager_Expecter) AddReadyzCheck(name interface{}, check interface{}) *mockK8sManager_AddReadyzCheck_Call {
	return &mockK8sManager_AddReadyzCheck_Call{Call: _e.mock.On("AddReadyzCheck", name, check)}
}

func (_c *mockK8sManager_AddReadyzCheck_Call) Run(run func(name string, check healthz.Checker)) *mockK8sManager_AddReadyzCheck_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(healthz.Checker))
	})
	return _c
}

func (_c *mockK8sManager_AddReadyzCheck_Call) Return(_a0 error) *mockK8sManager_AddReadyzCheck_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockK8sManager_AddReadyzCheck_Call) RunAndReturn(run func(string, healthz.Checker) error) *mockK8sManager_AddReadyzCheck_Call {
	_c.Call.Return(run)
	return _c
}

// Elected provides a mock function with given fields:
func (_m *mockK8sManager) Elected() <-chan struct{} {
	ret := _m.Called()

	var r0 <-chan struct{}
	if rf, ok := ret.Get(0).(func() <-chan struct{}); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(<-chan struct{})
		}
	}

	return r0
}

// mockK8sManager_Elected_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Elected'
type mockK8sManager_Elected_Call struct {
	*mock.Call
}

// Elected is a helper method to define mock.On call
func (_e *mockK8sManager_Expecter) Elected() *mockK8sManager_Elected_Call {
	return &mockK8sManager_Elected_Call{Call: _e.mock.On("Elected")}
}

func (_c *mockK8sManager_Elected_Call) Run(run func()) *mockK8sManager_Elected_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockK8sManager_Elected_Call) Return(_a0 <-chan struct{}) *mockK8sManager_Elected_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockK8sManager_Elected_Call) RunAndReturn(run func() <-chan struct{}) *mockK8sManager_Elected_Call {
	_c.Call.Return(run)
	return _c
}

// GetAPIReader provides a mock function with given fields:
func (_m *mockK8sManager) GetAPIReader() client.Reader {
	ret := _m.Called()

	var r0 client.Reader
	if rf, ok := ret.Get(0).(func() client.Reader); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(client.Reader)
		}
	}

	return r0
}

// mockK8sManager_GetAPIReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAPIReader'
type mockK8sManager_GetAPIReader_Call struct {
	*mock.Call
}

// GetAPIReader is a helper method to define mock.On call
func (_e *mockK8sManager_Expecter) GetAPIReader() *mockK8sManager_GetAPIReader_Call {
	return &mockK8sManager_GetAPIReader_Call{Call: _e.mock.On("GetAPIReader")}
}

func (_c *mockK8sManager_GetAPIReader_Call) Run(run func()) *mockK8sManager_GetAPIReader_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockK8sManager_GetAPIReader_Call) Return(_a0 client.Reader) *mockK8sManager_GetAPIReader_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockK8sManager_GetAPIReader_Call) RunAndReturn(run func() client.Reader) *mockK8sManager_GetAPIReader_Call {
	_c.Call.Return(run)
	return _c
}

// GetCache provides a mock function with given fields:
func (_m *mockK8sManager) GetCache() cache.Cache {
	ret := _m.Called()

	var r0 cache.Cache
	if rf, ok := ret.Get(0).(func() cache.Cache); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(cache.Cache)
		}
	}

	return r0
}

// mockK8sManager_GetCache_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCache'
type mockK8sManager_GetCache_Call struct {
	*mock.Call
}

// GetCache is a helper method to define mock.On call
func (_e *mockK8sManager_Expecter) GetCache() *mockK8sManager_GetCache_Call {
	return &mockK8sManager_GetCache_Call{Call: _e.mock.On("GetCache")}
}

func (_c *mockK8sManager_GetCache_Call) Run(run func()) *mockK8sManager_GetCache_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockK8sManager_GetCache_Call) Return(_a0 cache.Cache) *mockK8sManager_GetCache_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockK8sManager_GetCache_Call) RunAndReturn(run func() cache.Cache) *mockK8sManager_GetCache_Call {
	_c.Call.Return(run)
	return _c
}

// GetClient provides a mock function with given fields:
func (_m *mockK8sManager) GetClient() client.Client {
	ret := _m.Called()

	var r0 client.Client
	if rf, ok := ret.Get(0).(func() client.Client); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(client.Client)
		}
	}

	return r0
}

// mockK8sManager_GetClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClient'
type mockK8sManager_GetClient_Call struct {
	*mock.Call
}

// GetClient is a helper method to define mock.On call
func (_e *mockK8sManager_Expecter) GetClient() *mockK8sManager_GetClient_Call {
	return &mockK8sManager_GetClient_Call{Call: _e.mock.On("GetClient")}
}

func (_c *mockK8sManager_GetClient_Call) Run(run func()) *mockK8sManager_GetClient_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockK8sManager_GetClient_Call) Return(_a0 client.Client) *mockK8sManager_GetClient_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockK8sManager_GetClient_Call) RunAndReturn(run func() client.Client) *mockK8sManager_GetClient_Call {
	_c.Call.Return(run)
	return _c
}

// GetConfig provides a mock function with given fields:
func (_m *mockK8sManager) GetConfig() *rest.Config {
	ret := _m.Called()

	var r0 *rest.Config
	if rf, ok := ret.Get(0).(func() *rest.Config); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rest.Config)
		}
	}

	return r0
}

// mockK8sManager_GetConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConfig'
type mockK8sManager_GetConfig_Call struct {
	*mock.Call
}

// GetConfig is a helper method to define mock.On call
func (_e *mockK8sManager_Expecter) GetConfig() *mockK8sManager_GetConfig_Call {
	return &mockK8sManager_GetConfig_Call{Call: _e.mock.On("GetConfig")}
}

func (_c *mockK8sManager_GetConfig_Call) Run(run func()) *mockK8sManager_GetConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockK8sManager_GetConfig_Call) Return(_a0 *rest.Config) *mockK8sManager_GetConfig_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockK8sManager_GetConfig_Call) RunAndReturn(run func() *rest.Config) *mockK8sManager_GetConfig_Call {
	_c.Call.Return(run)
	return _c
}

// GetControllerOptions provides a mock function with given fields:
func (_m *mockK8sManager) GetControllerOptions() config.Controller {
	ret := _m.Called()

	var r0 config.Controller
	if rf, ok := ret.Get(0).(func() config.Controller); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(config.Controller)
	}

	return r0
}

// mockK8sManager_GetControllerOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetControllerOptions'
type mockK8sManager_GetControllerOptions_Call struct {
	*mock.Call
}

// GetControllerOptions is a helper method to define mock.On call
func (_e *mockK8sManager_Expecter) GetControllerOptions() *mockK8sManager_GetControllerOptions_Call {
	return &mockK8sManager_GetControllerOptions_Call{Call: _e.mock.On("GetControllerOptions")}
}

func (_c *mockK8sManager_GetControllerOptions_Call) Run(run func()) *mockK8sManager_GetControllerOptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockK8sManager_GetControllerOptions_Call) Return(_a0 config.Controller) *mockK8sManager_GetControllerOptions_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockK8sManager_GetControllerOptions_Call) RunAndReturn(run func() config.Controller) *mockK8sManager_GetControllerOptions_Call {
	_c.Call.Return(run)
	return _c
}

// GetEventRecorderFor provides a mock function with given fields: name
func (_m *mockK8sManager) GetEventRecorderFor(name string) record.EventRecorder {
	ret := _m.Called(name)

	var r0 record.EventRecorder
	if rf, ok := ret.Get(0).(func(string) record.EventRecorder); ok {
		r0 = rf(name)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(record.EventRecorder)
		}
	}

	return r0
}

// mockK8sManager_GetEventRecorderFor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEventRecorderFor'
type mockK8sManager_GetEventRecorderFor_Call struct {
	*mock.Call
}

// GetEventRecorderFor is a helper method to define mock.On call
//   - name string
func (_e *mockK8sManager_Expecter) GetEventRecorderFor(name interface{}) *mockK8sManager_GetEventRecorderFor_Call {
	return &mockK8sManager_GetEventRecorderFor_Call{Call: _e.mock.On("GetEventRecorderFor", name)}
}

func (_c *mockK8sManager_GetEventRecorderFor_Call) Run(run func(name string)) *mockK8sManager_GetEventRecorderFor_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *mockK8sManager_GetEventRecorderFor_Call) Return(_a0 record.EventRecorder) *mockK8sManager_GetEventRecorderFor_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockK8sManager_GetEventRecorderFor_Call) RunAndReturn(run func(string) record.EventRecorder) *mockK8sManager_GetEventRecorderFor_Call {
	_c.Call.Return(run)
	return _c
}

// GetFieldIndexer provides a mock function with given fields:
func (_m *mockK8sManager) GetFieldIndexer() client.FieldIndexer {
	ret := _m.Called()

	var r0 client.FieldIndexer
	if rf, ok := ret.Get(0).(func() client.FieldIndexer); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(client.FieldIndexer)
		}
	}

	return r0
}

// mockK8sManager_GetFieldIndexer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFieldIndexer'
type mockK8sManager_GetFieldIndexer_Call struct {
	*mock.Call
}

// GetFieldIndexer is a helper method to define mock.On call
func (_e *mockK8sManager_Expecter) GetFieldIndexer() *mockK8sManager_GetFieldIndexer_Call {
	return &mockK8sManager_GetFieldIndexer_Call{Call: _e.mock.On("GetFieldIndexer")}
}

func (_c *mockK8sManager_GetFieldIndexer_Call) Run(run func()) *mockK8sManager_GetFieldIndexer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockK8sManager_GetFieldIndexer_Call) Return(_a0 client.FieldIndexer) *mockK8sManager_GetFieldIndexer_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockK8sManager_GetFieldIndexer_Call) RunAndReturn(run func() client.FieldIndexer) *mockK8sManager_GetFieldIndexer_Call {
	_c.Call.Return(run)
	return _c
}

// GetHTTPClient provides a mock function with given fields:
func (_m *mockK8sManager) GetHTTPClient() *http.Client {
	ret := _m.Called()

	var r0 *http.Client
	if rf, ok := ret.Get(0).(func() *http.Client); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Client)
		}
	}

	return r0
}

// mockK8sManager_GetHTTPClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHTTPClient'
type mockK8sManager_GetHTTPClient_Call struct {
	*mock.Call
}

// GetHTTPClient is a helper method to define mock.On call
func (_e *mockK8sManager_Expecter) GetHTTPClient() *mockK8sManager_GetHTTPClient_Call {
	return &mockK8sManager_GetHTTPClient_Call{Call: _e.mock.On("GetHTTPClient")}
}

func (_c *mockK8sManager_GetHTTPClient_Call) Run(run func()) *mockK8sManager_GetHTTPClient_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockK8sManager_GetHTTPClient_Call) Return(_a0 *http.Client) *mockK8sManager_GetHTTPClient_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockK8sManager_GetHTTPClient_Call) RunAndReturn(run func() *http.Client) *mockK8sManager_GetHTTPClient_Call {
	_c.Call.Return(run)
	return _c
}

// GetLogger provides a mock function with given fields:
func (_m *mockK8sManager) GetLogger() logr.Logger {
	ret := _m.Called()

	var r0 logr.Logger
	if rf, ok := ret.Get(0).(func() logr.Logger); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(logr.Logger)
	}

	return r0
}

// mockK8sManager_GetLogger_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLogger'
type mockK8sManager_GetLogger_Call struct {
	*mock.Call
}

// GetLogger is a helper method to define mock.On call
func (_e *mockK8sManager_Expecter) GetLogger() *mockK8sManager_GetLogger_Call {
	return &mockK8sManager_GetLogger_Call{Call: _e.mock.On("GetLogger")}
}

func (_c *mockK8sManager_GetLogger_Call) Run(run func()) *mockK8sManager_GetLogger_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockK8sManager_GetLogger_Call) Return(_a0 logr.Logger) *mockK8sManager_GetLogger_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockK8sManager_GetLogger_Call) RunAndReturn(run func() logr.Logger) *mockK8sManager_GetLogger_Call {
	_c.Call.Return(run)
	return _c
}

// GetRESTMapper provides a mock function with given fields:
func (_m *mockK8sManager) GetRESTMapper() meta.RESTMapper {
	ret := _m.Called()

	var r0 meta.RESTMapper
	if rf, ok := ret.Get(0).(func() meta.RESTMapper); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(meta.RESTMapper)
		}
	}

	return r0
}

// mockK8sManager_GetRESTMapper_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRESTMapper'
type mockK8sManager_GetRESTMapper_Call struct {
	*mock.Call
}

// GetRESTMapper is a helper method to define mock.On call
func (_e *mockK8sManager_Expecter) GetRESTMapper() *mockK8sManager_GetRESTMapper_Call {
	return &mockK8sManager_GetRESTMapper_Call{Call: _e.mock.On("GetRESTMapper")}
}

func (_c *mockK8sManager_GetRESTMapper_Call) Run(run func()) *mockK8sManager_GetRESTMapper_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockK8sManager_GetRESTMapper_Call) Return(_a0 meta.RESTMapper) *mockK8sManager_GetRESTMapper_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockK8sManager_GetRESTMapper_Call) RunAndReturn(run func() meta.RESTMapper) *mockK8sManager_GetRESTMapper_Call {
	_c.Call.Return(run)
	return _c
}

// GetScheme provides a mock function with given fields:
func (_m *mockK8sManager) GetScheme() *runtime.Scheme {
	ret := _m.Called()

	var r0 *runtime.Scheme
	if rf, ok := ret.Get(0).(func() *runtime.Scheme); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*runtime.Scheme)
		}
	}

	return r0
}

// mockK8sManager_GetScheme_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetScheme'
type mockK8sManager_GetScheme_Call struct {
	*mock.Call
}

// GetScheme is a helper method to define mock.On call
func (_e *mockK8sManager_Expecter) GetScheme() *mockK8sManager_GetScheme_Call {
	return &mockK8sManager_GetScheme_Call{Call: _e.mock.On("GetScheme")}
}

func (_c *mockK8sManager_GetScheme_Call) Run(run func()) *mockK8sManager_GetScheme_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockK8sManager_GetScheme_Call) Return(_a0 *runtime.Scheme) *mockK8sManager_GetScheme_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockK8sManager_GetScheme_Call) RunAndReturn(run func() *runtime.Scheme) *mockK8sManager_GetScheme_Call {
	_c.Call.Return(run)
	return _c
}

// GetWebhookServer provides a mock function with given fields:
func (_m *mockK8sManager) GetWebhookServer() webhook.Server {
	ret := _m.Called()

	var r0 webhook.Server
	if rf, ok := ret.Get(0).(func() webhook.Server); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(webhook.Server)
		}
	}

	return r0
}

// mockK8sManager_GetWebhookServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWebhookServer'
type mockK8sManager_GetWebhookServer_Call struct {
	*mock.Call
}

// GetWebhookServer is a helper method to define mock.On call
func (_e *mockK8sManager_Expecter) GetWebhookServer() *mockK8sManager_GetWebhookServer_Call {
	return &mockK8sManager_GetWebhookServer_Call{Call: _e.mock.On("GetWebhookServer")}
}

func (_c *mockK8sManager_GetWebhookServer_Call) Run(run func()) *mockK8sManager_GetWebhookServer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *mockK8sManager_GetWebhookServer_Call) Return(_a0 webhook.Server) *mockK8sManager_GetWebhookServer_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockK8sManager_GetWebhookServer_Call) RunAndReturn(run func() webhook.Server) *mockK8sManager_GetWebhookServer_Call {
	_c.Call.Return(run)
	return _c
}

// Start provides a mock function with given fields: ctx
func (_m *mockK8sManager) Start(ctx context.Context) error {
	ret := _m.Called(ctx)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context) error); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// mockK8sManager_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'
type mockK8sManager_Start_Call struct {
	*mock.Call
}

// Start is a helper method to define mock.On call
//   - ctx context.Context
func (_e *mockK8sManager_Expecter) Start(ctx interface{}) *mockK8sManager_Start_Call {
	return &mockK8sManager_Start_Call{Call: _e.mock.On("Start", ctx)}
}

func (_c *mockK8sManager_Start_Call) Run(run func(ctx context.Context)) *mockK8sManager_Start_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *mockK8sManager_Start_Call) Return(_a0 error) *mockK8sManager_Start_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *mockK8sManager_Start_Call) RunAndReturn(run func(context.Context) error) *mockK8sManager_Start_Call {
	_c.Call.Return(run)
	return _c
}

type mockConstructorTestingTnewMockK8sManager interface {
	mock.TestingT
	Cleanup(func())
}

// newMockK8sManager creates a new instance of mockK8sManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
func newMockK8sManager(t mockConstructorTestingTnewMockK8sManager) *mockK8sManager {
	mock := &mockK8sManager{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}