// 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-ng/api/v1"
	cdccluster "github.com/tidbcloud/ticdc-service-ng/pkg/cdccluster"
	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)
}

// SetRequest mocks base method.
func (m *MockProvider) SetRequest(cpuCore, memoryGi uint32) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRequest", cpuCore, memoryGi)
}

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

// 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(size, vac string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStorage", size, vac)
}

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

// 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, tag string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetVersion", baseImage, version, tag)
}

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