multicluster_reconcilers.go

// Code generated by MockGen. DO NOT EDIT.
// Source: ./multicluster_reconcilers.go

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

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	controller "github.com/solo-io/skv2/pkg/multicluster/internal/k8s/core/v1/controller"
	reconcile "github.com/solo-io/skv2/pkg/reconcile"
	v1 "k8s.io/api/core/v1"
	predicate "sigs.k8s.io/controller-runtime/pkg/predicate"
)

// MockMulticlusterSecretReconciler is a mock of MulticlusterSecretReconciler interface
type MockMulticlusterSecretReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockMulticlusterSecretReconcilerMockRecorder
}

// MockMulticlusterSecretReconcilerMockRecorder is the mock recorder for MockMulticlusterSecretReconciler
type MockMulticlusterSecretReconcilerMockRecorder struct {
	mock *MockMulticlusterSecretReconciler
}

// NewMockMulticlusterSecretReconciler creates a new mock instance
func NewMockMulticlusterSecretReconciler(ctrl *gomock.Controller) *MockMulticlusterSecretReconciler {
	mock := &MockMulticlusterSecretReconciler{ctrl: ctrl}
	mock.recorder = &MockMulticlusterSecretReconcilerMockRecorder{mock}
	return mock
}

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

// ReconcileSecret mocks base method
func (m *MockMulticlusterSecretReconciler) ReconcileSecret(clusterName string, obj *v1.Secret) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileSecret", clusterName, obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReconcileSecret indicates an expected call of ReconcileSecret
func (mr *MockMulticlusterSecretReconcilerMockRecorder) ReconcileSecret(clusterName, obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileSecret", reflect.TypeOf((*MockMulticlusterSecretReconciler)(nil).ReconcileSecret), clusterName, obj)
}

// MockMulticlusterSecretDeletionReconciler is a mock of MulticlusterSecretDeletionReconciler interface
type MockMulticlusterSecretDeletionReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockMulticlusterSecretDeletionReconcilerMockRecorder
}

// MockMulticlusterSecretDeletionReconcilerMockRecorder is the mock recorder for MockMulticlusterSecretDeletionReconciler
type MockMulticlusterSecretDeletionReconcilerMockRecorder struct {
	mock *MockMulticlusterSecretDeletionReconciler
}

// NewMockMulticlusterSecretDeletionReconciler creates a new mock instance
func NewMockMulticlusterSecretDeletionReconciler(ctrl *gomock.Controller) *MockMulticlusterSecretDeletionReconciler {
	mock := &MockMulticlusterSecretDeletionReconciler{ctrl: ctrl}
	mock.recorder = &MockMulticlusterSecretDeletionReconcilerMockRecorder{mock}
	return mock
}

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

// ReconcileSecretDeletion mocks base method
func (m *MockMulticlusterSecretDeletionReconciler) ReconcileSecretDeletion(clusterName string, req reconcile.Request) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileSecretDeletion", clusterName, req)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReconcileSecretDeletion indicates an expected call of ReconcileSecretDeletion
func (mr *MockMulticlusterSecretDeletionReconcilerMockRecorder) ReconcileSecretDeletion(clusterName, req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileSecretDeletion", reflect.TypeOf((*MockMulticlusterSecretDeletionReconciler)(nil).ReconcileSecretDeletion), clusterName, req)
}

// MockMulticlusterSecretReconcileLoop is a mock of MulticlusterSecretReconcileLoop interface
type MockMulticlusterSecretReconcileLoop struct {
	ctrl     *gomock.Controller
	recorder *MockMulticlusterSecretReconcileLoopMockRecorder
}

// MockMulticlusterSecretReconcileLoopMockRecorder is the mock recorder for MockMulticlusterSecretReconcileLoop
type MockMulticlusterSecretReconcileLoopMockRecorder struct {
	mock *MockMulticlusterSecretReconcileLoop
}

// NewMockMulticlusterSecretReconcileLoop creates a new mock instance
func NewMockMulticlusterSecretReconcileLoop(ctrl *gomock.Controller) *MockMulticlusterSecretReconcileLoop {
	mock := &MockMulticlusterSecretReconcileLoop{ctrl: ctrl}
	mock.recorder = &MockMulticlusterSecretReconcileLoopMockRecorder{mock}
	return mock
}

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

// AddMulticlusterSecretReconciler mocks base method
func (m *MockMulticlusterSecretReconcileLoop) AddMulticlusterSecretReconciler(ctx context.Context, rec controller.MulticlusterSecretReconciler, predicates ...predicate.Predicate) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, rec}
	for _, a := range predicates {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "AddMulticlusterSecretReconciler", varargs...)
}

// AddMulticlusterSecretReconciler indicates an expected call of AddMulticlusterSecretReconciler
func (mr *MockMulticlusterSecretReconcileLoopMockRecorder) AddMulticlusterSecretReconciler(ctx, rec interface{}, predicates ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, rec}, predicates...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddMulticlusterSecretReconciler", reflect.TypeOf((*MockMulticlusterSecretReconcileLoop)(nil).AddMulticlusterSecretReconciler), varargs...)
}

// MockMulticlusterServiceAccountReconciler is a mock of MulticlusterServiceAccountReconciler interface
type MockMulticlusterServiceAccountReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockMulticlusterServiceAccountReconcilerMockRecorder
}

// MockMulticlusterServiceAccountReconcilerMockRecorder is the mock recorder for MockMulticlusterServiceAccountReconciler
type MockMulticlusterServiceAccountReconcilerMockRecorder struct {
	mock *MockMulticlusterServiceAccountReconciler
}

// NewMockMulticlusterServiceAccountReconciler creates a new mock instance
func NewMockMulticlusterServiceAccountReconciler(ctrl *gomock.Controller) *MockMulticlusterServiceAccountReconciler {
	mock := &MockMulticlusterServiceAccountReconciler{ctrl: ctrl}
	mock.recorder = &MockMulticlusterServiceAccountReconcilerMockRecorder{mock}
	return mock
}

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

// ReconcileServiceAccount mocks base method
func (m *MockMulticlusterServiceAccountReconciler) ReconcileServiceAccount(clusterName string, obj *v1.ServiceAccount) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileServiceAccount", clusterName, obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReconcileServiceAccount indicates an expected call of ReconcileServiceAccount
func (mr *MockMulticlusterServiceAccountReconcilerMockRecorder) ReconcileServiceAccount(clusterName, obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileServiceAccount", reflect.TypeOf((*MockMulticlusterServiceAccountReconciler)(nil).ReconcileServiceAccount), clusterName, obj)
}

// MockMulticlusterServiceAccountDeletionReconciler is a mock of MulticlusterServiceAccountDeletionReconciler interface
type MockMulticlusterServiceAccountDeletionReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockMulticlusterServiceAccountDeletionReconcilerMockRecorder
}

// MockMulticlusterServiceAccountDeletionReconcilerMockRecorder is the mock recorder for MockMulticlusterServiceAccountDeletionReconciler
type MockMulticlusterServiceAccountDeletionReconcilerMockRecorder struct {
	mock *MockMulticlusterServiceAccountDeletionReconciler
}

// NewMockMulticlusterServiceAccountDeletionReconciler creates a new mock instance
func NewMockMulticlusterServiceAccountDeletionReconciler(ctrl *gomock.Controller) *MockMulticlusterServiceAccountDeletionReconciler {
	mock := &MockMulticlusterServiceAccountDeletionReconciler{ctrl: ctrl}
	mock.recorder = &MockMulticlusterServiceAccountDeletionReconcilerMockRecorder{mock}
	return mock
}

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

// ReconcileServiceAccountDeletion mocks base method
func (m *MockMulticlusterServiceAccountDeletionReconciler) ReconcileServiceAccountDeletion(clusterName string, req reconcile.Request) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileServiceAccountDeletion", clusterName, req)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReconcileServiceAccountDeletion indicates an expected call of ReconcileServiceAccountDeletion
func (mr *MockMulticlusterServiceAccountDeletionReconcilerMockRecorder) ReconcileServiceAccountDeletion(clusterName, req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileServiceAccountDeletion", reflect.TypeOf((*MockMulticlusterServiceAccountDeletionReconciler)(nil).ReconcileServiceAccountDeletion), clusterName, req)
}

// MockMulticlusterServiceAccountReconcileLoop is a mock of MulticlusterServiceAccountReconcileLoop interface
type MockMulticlusterServiceAccountReconcileLoop struct {
	ctrl     *gomock.Controller
	recorder *MockMulticlusterServiceAccountReconcileLoopMockRecorder
}

// MockMulticlusterServiceAccountReconcileLoopMockRecorder is the mock recorder for MockMulticlusterServiceAccountReconcileLoop
type MockMulticlusterServiceAccountReconcileLoopMockRecorder struct {
	mock *MockMulticlusterServiceAccountReconcileLoop
}

// NewMockMulticlusterServiceAccountReconcileLoop creates a new mock instance
func NewMockMulticlusterServiceAccountReconcileLoop(ctrl *gomock.Controller) *MockMulticlusterServiceAccountReconcileLoop {
	mock := &MockMulticlusterServiceAccountReconcileLoop{ctrl: ctrl}
	mock.recorder = &MockMulticlusterServiceAccountReconcileLoopMockRecorder{mock}
	return mock
}

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

// AddMulticlusterServiceAccountReconciler mocks base method
func (m *MockMulticlusterServiceAccountReconcileLoop) AddMulticlusterServiceAccountReconciler(ctx context.Context, rec controller.MulticlusterServiceAccountReconciler, predicates ...predicate.Predicate) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, rec}
	for _, a := range predicates {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "AddMulticlusterServiceAccountReconciler", varargs...)
}

// AddMulticlusterServiceAccountReconciler indicates an expected call of AddMulticlusterServiceAccountReconciler
func (mr *MockMulticlusterServiceAccountReconcileLoopMockRecorder) AddMulticlusterServiceAccountReconciler(ctx, rec interface{}, predicates ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, rec}, predicates...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddMulticlusterServiceAccountReconciler", reflect.TypeOf((*MockMulticlusterServiceAccountReconcileLoop)(nil).AddMulticlusterServiceAccountReconciler), varargs...)
}

// MockMulticlusterNamespaceReconciler is a mock of MulticlusterNamespaceReconciler interface
type MockMulticlusterNamespaceReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockMulticlusterNamespaceReconcilerMockRecorder
}

// MockMulticlusterNamespaceReconcilerMockRecorder is the mock recorder for MockMulticlusterNamespaceReconciler
type MockMulticlusterNamespaceReconcilerMockRecorder struct {
	mock *MockMulticlusterNamespaceReconciler
}

// NewMockMulticlusterNamespaceReconciler creates a new mock instance
func NewMockMulticlusterNamespaceReconciler(ctrl *gomock.Controller) *MockMulticlusterNamespaceReconciler {
	mock := &MockMulticlusterNamespaceReconciler{ctrl: ctrl}
	mock.recorder = &MockMulticlusterNamespaceReconcilerMockRecorder{mock}
	return mock
}

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

// ReconcileNamespace mocks base method
func (m *MockMulticlusterNamespaceReconciler) ReconcileNamespace(clusterName string, obj *v1.Namespace) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileNamespace", clusterName, obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReconcileNamespace indicates an expected call of ReconcileNamespace
func (mr *MockMulticlusterNamespaceReconcilerMockRecorder) ReconcileNamespace(clusterName, obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileNamespace", reflect.TypeOf((*MockMulticlusterNamespaceReconciler)(nil).ReconcileNamespace), clusterName, obj)
}

// MockMulticlusterNamespaceDeletionReconciler is a mock of MulticlusterNamespaceDeletionReconciler interface
type MockMulticlusterNamespaceDeletionReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockMulticlusterNamespaceDeletionReconcilerMockRecorder
}

// MockMulticlusterNamespaceDeletionReconcilerMockRecorder is the mock recorder for MockMulticlusterNamespaceDeletionReconciler
type MockMulticlusterNamespaceDeletionReconcilerMockRecorder struct {
	mock *MockMulticlusterNamespaceDeletionReconciler
}

// NewMockMulticlusterNamespaceDeletionReconciler creates a new mock instance
func NewMockMulticlusterNamespaceDeletionReconciler(ctrl *gomock.Controller) *MockMulticlusterNamespaceDeletionReconciler {
	mock := &MockMulticlusterNamespaceDeletionReconciler{ctrl: ctrl}
	mock.recorder = &MockMulticlusterNamespaceDeletionReconcilerMockRecorder{mock}
	return mock
}

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

// ReconcileNamespaceDeletion mocks base method
func (m *MockMulticlusterNamespaceDeletionReconciler) ReconcileNamespaceDeletion(clusterName string, req reconcile.Request) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileNamespaceDeletion", clusterName, req)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReconcileNamespaceDeletion indicates an expected call of ReconcileNamespaceDeletion
func (mr *MockMulticlusterNamespaceDeletionReconcilerMockRecorder) ReconcileNamespaceDeletion(clusterName, req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileNamespaceDeletion", reflect.TypeOf((*MockMulticlusterNamespaceDeletionReconciler)(nil).ReconcileNamespaceDeletion), clusterName, req)
}

// MockMulticlusterNamespaceReconcileLoop is a mock of MulticlusterNamespaceReconcileLoop interface
type MockMulticlusterNamespaceReconcileLoop struct {
	ctrl     *gomock.Controller
	recorder *MockMulticlusterNamespaceReconcileLoopMockRecorder
}

// MockMulticlusterNamespaceReconcileLoopMockRecorder is the mock recorder for MockMulticlusterNamespaceReconcileLoop
type MockMulticlusterNamespaceReconcileLoopMockRecorder struct {
	mock *MockMulticlusterNamespaceReconcileLoop
}

// NewMockMulticlusterNamespaceReconcileLoop creates a new mock instance
func NewMockMulticlusterNamespaceReconcileLoop(ctrl *gomock.Controller) *MockMulticlusterNamespaceReconcileLoop {
	mock := &MockMulticlusterNamespaceReconcileLoop{ctrl: ctrl}
	mock.recorder = &MockMulticlusterNamespaceReconcileLoopMockRecorder{mock}
	return mock
}

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

// AddMulticlusterNamespaceReconciler mocks base method
func (m *MockMulticlusterNamespaceReconcileLoop) AddMulticlusterNamespaceReconciler(ctx context.Context, rec controller.MulticlusterNamespaceReconciler, predicates ...predicate.Predicate) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, rec}
	for _, a := range predicates {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "AddMulticlusterNamespaceReconciler", varargs...)
}

// AddMulticlusterNamespaceReconciler indicates an expected call of AddMulticlusterNamespaceReconciler
func (mr *MockMulticlusterNamespaceReconcileLoopMockRecorder) AddMulticlusterNamespaceReconciler(ctx, rec interface{}, predicates ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, rec}, predicates...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddMulticlusterNamespaceReconciler", reflect.TypeOf((*MockMulticlusterNamespaceReconcileLoop)(nil).AddMulticlusterNamespaceReconciler), varargs...)
}