// Code generated by MockGen. DO NOT EDIT.
// Source: pkg/cdccluster/provider.go

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

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	v1 "github.com/tidbcloud/ticdc-service/api/v1"
	cdccluster "github.com/tidbcloud/ticdc-service/pkg/cdccluster"
	v10 "k8s.io/api/core/v1"
	types "k8s.io/apimachinery/pkg/types"
	client "sigs.k8s.io/controller-runtime/pkg/client"
)

// MockProvider is a mock of Provider interface.
type MockProvider struct {
	ctrl     *gomock.Controller
	recorder *MockProviderMockRecorder
}

// MockProviderMockRecorder is the mock recorder for MockProvider.
type MockProviderMockRecorder struct {
	mock *MockProvider
}

// NewMockProvider creates a new mock instance.
func NewMockProvider(ctrl *gomock.Controller) *MockProvider {
	mock := &MockProvider{ctrl: ctrl}
	mock.recorder = &MockProviderMockRecorder{mock}
	return mock
}

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

// ApplyCR mocks base method.
func (m *MockProvider) ApplyCR(ctx context.Context, cli client.Client) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyCR", ctx, cli)
	ret0, _ := ret[0].(error)
	return ret0
}

// ApplyCR indicates an expected call of ApplyCR.
func (mr *MockProviderMockRecorder) ApplyCR(ctx, cli interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyCR", reflect.TypeOf((*MockProvider)(nil).ApplyCR), ctx, cli)
}

// DeleteCR mocks base method.
func (m *MockProvider) DeleteCR(ctx context.Context, cli client.Client, name types.NamespacedName) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCR", ctx, cli, name)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteCR indicates an expected call of DeleteCR.
func (mr *MockProviderMockRecorder) DeleteCR(ctx, cli, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCR", reflect.TypeOf((*MockProvider)(nil).DeleteCR), ctx, cli, name)
}

// GetClusterStatus mocks base method.
func (m *MockProvider) GetClusterStatus(ctx context.Context, cli client.Client) (*v1.TiCDCStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClusterStatus", ctx, cli)
	ret0, _ := ret[0].(*v1.TiCDCStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterStatus indicates an expected call of GetClusterStatus.
func (mr *MockProviderMockRecorder) GetClusterStatus(ctx, cli interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterStatus", reflect.TypeOf((*MockProvider)(nil).GetClusterStatus), ctx, cli)
}

// Init mocks base method.
func (m *MockProvider) Init(arg0, arg1 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Init", arg0, arg1)
}

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

// NeedReschedule mocks base method.
func (m *MockProvider) NeedReschedule(ctx context.Context, cli client.Client, desiredNode *cdccluster.Node) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NeedReschedule", ctx, cli, desiredNode)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NeedReschedule indicates an expected call of NeedReschedule.
func (mr *MockProviderMockRecorder) NeedReschedule(ctx, cli, desiredNode interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NeedReschedule", reflect.TypeOf((*MockProvider)(nil).NeedReschedule), ctx, cli, desiredNode)
}

// Rescheduled mocks base method.
func (m *MockProvider) Rescheduled(ctx context.Context, cli client.Client) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Rescheduled", ctx, cli)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Rescheduled indicates an expected call of Rescheduled.
func (mr *MockProviderMockRecorder) Rescheduled(ctx, cli interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rescheduled", reflect.TypeOf((*MockProvider)(nil).Rescheduled), ctx, cli)
}

// SetConfigField mocks base method.
func (m *MockProvider) SetConfigField(key string, value interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetConfigField", key, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetConfigField indicates an expected call of SetConfigField.
func (mr *MockProviderMockRecorder) SetConfigField(key, value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetConfigField", reflect.TypeOf((*MockProvider)(nil).SetConfigField), key, value)
}

// SetNodeSelector mocks base method.
func (m *MockProvider) SetNodeSelector(labelSelector map[string]string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetNodeSelector", labelSelector)
}

// SetNodeSelector indicates an expected call of SetNodeSelector.
func (mr *MockProviderMockRecorder) SetNodeSelector(labelSelector interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNodeSelector", reflect.TypeOf((*MockProvider)(nil).SetNodeSelector), labelSelector)
}

// SetReplicas mocks base method.
func (m *MockProvider) SetReplicas(replicas int32) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetReplicas", replicas)
}

// SetReplicas indicates an expected call of SetReplicas.
func (mr *MockProviderMockRecorder) SetReplicas(replicas interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReplicas", reflect.TypeOf((*MockProvider)(nil).SetReplicas), replicas)
}

// SetRestart mocks base method.
func (m *MockProvider) SetRestart(restartedAt string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRestart", restartedAt)
}

// SetRestart indicates an expected call of SetRestart.
func (mr *MockProviderMockRecorder) SetRestart(restartedAt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRestart", reflect.TypeOf((*MockProvider)(nil).SetRestart), restartedAt)
}

// SetStorage mocks base method.
func (m *MockProvider) SetStorage(class, size string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStorage", class, size)
}

// SetStorage indicates an expected call of SetStorage.
func (mr *MockProviderMockRecorder) SetStorage(class, size interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStorage", reflect.TypeOf((*MockProvider)(nil).SetStorage), class, size)
}

// SetTolerations mocks base method.
func (m *MockProvider) SetTolerations(tolerations []v10.Toleration) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTolerations", tolerations)
}

// SetTolerations indicates an expected call of SetTolerations.
func (mr *MockProviderMockRecorder) SetTolerations(tolerations interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTolerations", reflect.TypeOf((*MockProvider)(nil).SetTolerations), tolerations)
}

// SetTomlConfig mocks base method.
func (m *MockProvider) SetTomlConfig(conf string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetTomlConfig", conf)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetTomlConfig indicates an expected call of SetTomlConfig.
func (mr *MockProviderMockRecorder) SetTomlConfig(conf interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTomlConfig", reflect.TypeOf((*MockProvider)(nil).SetTomlConfig), conf)
}

// SetUpstreamCluster mocks base method.
func (m *MockProvider) SetUpstreamCluster(namespace, name string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpstreamCluster", namespace, name)
}

// SetUpstreamCluster indicates an expected call of SetUpstreamCluster.
func (mr *MockProviderMockRecorder) SetUpstreamCluster(namespace, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpstreamCluster", reflect.TypeOf((*MockProvider)(nil).SetUpstreamCluster), namespace, name)
}

// SetVersion mocks base method.
func (m *MockProvider) SetVersion(baseImage, version string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetVersion", baseImage, version)
}

// SetVersion indicates an expected call of SetVersion.
func (mr *MockProviderMockRecorder) SetVersion(baseImage, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetVersion", reflect.TypeOf((*MockProvider)(nil).SetVersion), baseImage, version)
}