mocks.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/gardener/gardener/extensions/pkg/controller/common (interfaces: Resolver,Checker,CheckerFactory,Watchdog,WatchdogFactory,WatchdogManager)

// Package mock is a generated GoMock package.
package mock

import (
	context "context"
	reflect "reflect"

	common "github.com/gardener/gardener/extensions/pkg/controller/common"
	gomock "github.com/golang/mock/gomock"
	client "sigs.k8s.io/controller-runtime/pkg/client"
)

// MockResolver is a mock of Resolver interface.
type MockResolver struct {
	ctrl     *gomock.Controller
	recorder *MockResolverMockRecorder
}

// MockResolverMockRecorder is the mock recorder for MockResolver.
type MockResolverMockRecorder struct {
	mock *MockResolver
}

// NewMockResolver creates a new mock instance.
func NewMockResolver(ctrl *gomock.Controller) *MockResolver {
	mock := &MockResolver{ctrl: ctrl}
	mock.recorder = &MockResolverMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockResolver) EXPECT() *MockResolverMockRecorder {
	return m.recorder
}

// LookupTXT mocks base method.
func (m *MockResolver) LookupTXT(arg0 context.Context, arg1 string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LookupTXT", arg0, arg1)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LookupTXT indicates an expected call of LookupTXT.
func (mr *MockResolverMockRecorder) LookupTXT(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LookupTXT", reflect.TypeOf((*MockResolver)(nil).LookupTXT), arg0, arg1)
}

// MockChecker is a mock of Checker interface.
type MockChecker struct {
	ctrl     *gomock.Controller
	recorder *MockCheckerMockRecorder
}

// MockCheckerMockRecorder is the mock recorder for MockChecker.
type MockCheckerMockRecorder struct {
	mock *MockChecker
}

// NewMockChecker creates a new mock instance.
func NewMockChecker(ctrl *gomock.Controller) *MockChecker {
	mock := &MockChecker{ctrl: ctrl}
	mock.recorder = &MockCheckerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockChecker) EXPECT() *MockCheckerMockRecorder {
	return m.recorder
}

// Check mocks base method.
func (m *MockChecker) Check(arg0 context.Context) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Check", arg0)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Check indicates an expected call of Check.
func (mr *MockCheckerMockRecorder) Check(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Check", reflect.TypeOf((*MockChecker)(nil).Check), arg0)
}

// MockCheckerFactory is a mock of CheckerFactory interface.
type MockCheckerFactory struct {
	ctrl     *gomock.Controller
	recorder *MockCheckerFactoryMockRecorder
}

// MockCheckerFactoryMockRecorder is the mock recorder for MockCheckerFactory.
type MockCheckerFactoryMockRecorder struct {
	mock *MockCheckerFactory
}

// NewMockCheckerFactory creates a new mock instance.
func NewMockCheckerFactory(ctrl *gomock.Controller) *MockCheckerFactory {
	mock := &MockCheckerFactory{ctrl: ctrl}
	mock.recorder = &MockCheckerFactoryMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockCheckerFactory) EXPECT() *MockCheckerFactoryMockRecorder {
	return m.recorder
}

// NewChecker mocks base method.
func (m *MockCheckerFactory) NewChecker(arg0 context.Context, arg1 client.Client, arg2, arg3 string) (common.Checker, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewChecker", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(common.Checker)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewChecker indicates an expected call of NewChecker.
func (mr *MockCheckerFactoryMockRecorder) NewChecker(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewChecker", reflect.TypeOf((*MockCheckerFactory)(nil).NewChecker), arg0, arg1, arg2, arg3)
}

// MockWatchdog is a mock of Watchdog interface.
type MockWatchdog struct {
	ctrl     *gomock.Controller
	recorder *MockWatchdogMockRecorder
}

// MockWatchdogMockRecorder is the mock recorder for MockWatchdog.
type MockWatchdogMockRecorder struct {
	mock *MockWatchdog
}

// NewMockWatchdog creates a new mock instance.
func NewMockWatchdog(ctrl *gomock.Controller) *MockWatchdog {
	mock := &MockWatchdog{ctrl: ctrl}
	mock.recorder = &MockWatchdogMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockWatchdog) EXPECT() *MockWatchdogMockRecorder {
	return m.recorder
}

// AddContext mocks base method.
func (m *MockWatchdog) AddContext(arg0 context.Context, arg1 string) (context.Context, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddContext", arg0, arg1)
	ret0, _ := ret[0].(context.Context)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// AddContext indicates an expected call of AddContext.
func (mr *MockWatchdogMockRecorder) AddContext(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddContext", reflect.TypeOf((*MockWatchdog)(nil).AddContext), arg0, arg1)
}

// RemoveContext mocks base method.
func (m *MockWatchdog) RemoveContext(arg0 string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveContext", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// RemoveContext indicates an expected call of RemoveContext.
func (mr *MockWatchdogMockRecorder) RemoveContext(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveContext", reflect.TypeOf((*MockWatchdog)(nil).RemoveContext), arg0)
}

// Result mocks base method.
func (m *MockWatchdog) Result() (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Result")
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Result indicates an expected call of Result.
func (mr *MockWatchdogMockRecorder) Result() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Result", reflect.TypeOf((*MockWatchdog)(nil).Result))
}

// Start mocks base method.
func (m *MockWatchdog) Start(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Start", arg0)
}

// Start indicates an expected call of Start.
func (mr *MockWatchdogMockRecorder) Start(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockWatchdog)(nil).Start), arg0)
}

// Stop mocks base method.
func (m *MockWatchdog) Stop() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Stop")
}

// Stop indicates an expected call of Stop.
func (mr *MockWatchdogMockRecorder) Stop() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockWatchdog)(nil).Stop))
}

// MockWatchdogFactory is a mock of WatchdogFactory interface.
type MockWatchdogFactory struct {
	ctrl     *gomock.Controller
	recorder *MockWatchdogFactoryMockRecorder
}

// MockWatchdogFactoryMockRecorder is the mock recorder for MockWatchdogFactory.
type MockWatchdogFactoryMockRecorder struct {
	mock *MockWatchdogFactory
}

// NewMockWatchdogFactory creates a new mock instance.
func NewMockWatchdogFactory(ctrl *gomock.Controller) *MockWatchdogFactory {
	mock := &MockWatchdogFactory{ctrl: ctrl}
	mock.recorder = &MockWatchdogFactoryMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockWatchdogFactory) EXPECT() *MockWatchdogFactoryMockRecorder {
	return m.recorder
}

// NewWatchdog mocks base method.
func (m *MockWatchdogFactory) NewWatchdog(arg0 context.Context, arg1 client.Client, arg2, arg3 string) (common.Watchdog, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewWatchdog", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(common.Watchdog)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewWatchdog indicates an expected call of NewWatchdog.
func (mr *MockWatchdogFactoryMockRecorder) NewWatchdog(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewWatchdog", reflect.TypeOf((*MockWatchdogFactory)(nil).NewWatchdog), arg0, arg1, arg2, arg3)
}

// MockWatchdogManager is a mock of WatchdogManager interface.
type MockWatchdogManager struct {
	ctrl     *gomock.Controller
	recorder *MockWatchdogManagerMockRecorder
}

// MockWatchdogManagerMockRecorder is the mock recorder for MockWatchdogManager.
type MockWatchdogManagerMockRecorder struct {
	mock *MockWatchdogManager
}

// NewMockWatchdogManager creates a new mock instance.
func NewMockWatchdogManager(ctrl *gomock.Controller) *MockWatchdogManager {
	mock := &MockWatchdogManager{ctrl: ctrl}
	mock.recorder = &MockWatchdogManagerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockWatchdogManager) EXPECT() *MockWatchdogManagerMockRecorder {
	return m.recorder
}

// GetResultAndContext mocks base method.
func (m *MockWatchdogManager) GetResultAndContext(arg0 context.Context, arg1 client.Client, arg2, arg3, arg4 string) (bool, context.Context, func(), error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetResultAndContext", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(context.Context)
	ret2, _ := ret[2].(func())
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

// GetResultAndContext indicates an expected call of GetResultAndContext.
func (mr *MockWatchdogManagerMockRecorder) GetResultAndContext(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResultAndContext", reflect.TypeOf((*MockWatchdogManager)(nil).GetResultAndContext), arg0, arg1, arg2, arg3, arg4)
}