// Code generated by MockGen. DO NOT EDIT.
// Source: ./pkg/domain/facade/infra.go

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

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	entity "github.com/tidbcloud/chaos-svc/pkg/domain/entity"
	facade "github.com/tidbcloud/chaos-svc/pkg/domain/facade"
	v1alpha1 "github.com/tidbcloud/eks-provider/api/v1alpha1"
	v1 "github.com/tidbcloud/infra-api/api/v1"
	bizerr "github.com/tidbcloud/pkgv2/bizerr"
)

// MockInfra is a mock of Infra interface.
type MockInfra struct {
	ctrl     *gomock.Controller
	recorder *MockInfraMockRecorder
}

// MockInfraMockRecorder is the mock recorder for MockInfra.
type MockInfraMockRecorder struct {
	mock *MockInfra
}

// NewMockInfra creates a new mock instance.
func NewMockInfra(ctrl *gomock.Controller) *MockInfra {
	mock := &MockInfra{ctrl: ctrl}
	mock.recorder = &MockInfraMockRecorder{mock}
	return mock
}

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

// ChaosServerName mocks base method.
func (m *MockInfra) ChaosServerName(projectID uint64, networkName string) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChaosServerName", projectID, networkName)
	ret0, _ := ret[0].(string)
	return ret0
}

// ChaosServerName indicates an expected call of ChaosServerName.
func (mr *MockInfraMockRecorder) ChaosServerName(projectID, networkName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChaosServerName", reflect.TypeOf((*MockInfra)(nil).ChaosServerName), projectID, networkName)
}

// CreateChaosServerIgnoreExist mocks base method.
func (m *MockInfra) CreateChaosServerIgnoreExist(ctx context.Context, server *v1alpha1.ChaosServer) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateChaosServerIgnoreExist", ctx, server)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// CreateChaosServerIgnoreExist indicates an expected call of CreateChaosServerIgnoreExist.
func (mr *MockInfraMockRecorder) CreateChaosServerIgnoreExist(ctx, server interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateChaosServerIgnoreExist", reflect.TypeOf((*MockInfra)(nil).CreateChaosServerIgnoreExist), ctx, server)
}

// CreateWorkflowIgnoreExist mocks base method.
func (m *MockInfra) CreateWorkflowIgnoreExist(ctx context.Context, workflow *entity.Workflow) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateWorkflowIgnoreExist", ctx, workflow)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// CreateWorkflowIgnoreExist indicates an expected call of CreateWorkflowIgnoreExist.
func (mr *MockInfraMockRecorder) CreateWorkflowIgnoreExist(ctx, workflow interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWorkflowIgnoreExist", reflect.TypeOf((*MockInfra)(nil).CreateWorkflowIgnoreExist), ctx, workflow)
}

// DeleteChaosServerIgnoreNotFound mocks base method.
func (m *MockInfra) DeleteChaosServerIgnoreNotFound(ctx context.Context, projectID uint64, networkName string) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteChaosServerIgnoreNotFound", ctx, projectID, networkName)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// DeleteChaosServerIgnoreNotFound indicates an expected call of DeleteChaosServerIgnoreNotFound.
func (mr *MockInfraMockRecorder) DeleteChaosServerIgnoreNotFound(ctx, projectID, networkName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteChaosServerIgnoreNotFound", reflect.TypeOf((*MockInfra)(nil).DeleteChaosServerIgnoreNotFound), ctx, projectID, networkName)
}

// DeleteWorkflowIgnoreNotFound mocks base method.
func (m *MockInfra) DeleteWorkflowIgnoreNotFound(ctx context.Context, projectID, workflowID uint64) bizerr.BizError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWorkflowIgnoreNotFound", ctx, projectID, workflowID)
	ret0, _ := ret[0].(bizerr.BizError)
	return ret0
}

// DeleteWorkflowIgnoreNotFound indicates an expected call of DeleteWorkflowIgnoreNotFound.
func (mr *MockInfraMockRecorder) DeleteWorkflowIgnoreNotFound(ctx, projectID, workflowID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWorkflowIgnoreNotFound", reflect.TypeOf((*MockInfra)(nil).DeleteWorkflowIgnoreNotFound), ctx, projectID, workflowID)
}

// GetChaosServer mocks base method.
func (m *MockInfra) GetChaosServer(ctx context.Context, projectID uint64, networkName string) (*v1alpha1.ChaosServer, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChaosServer", ctx, projectID, networkName)
	ret0, _ := ret[0].(*v1alpha1.ChaosServer)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetChaosServer indicates an expected call of GetChaosServer.
func (mr *MockInfraMockRecorder) GetChaosServer(ctx, projectID, networkName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChaosServer", reflect.TypeOf((*MockInfra)(nil).GetChaosServer), ctx, projectID, networkName)
}

// GetTiDBCluster mocks base method.
func (m *MockInfra) GetTiDBCluster(ctx context.Context, projectID, clusterID uint64) (*facade.TiDBCluster, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTiDBCluster", ctx, projectID, clusterID)
	ret0, _ := ret[0].(*facade.TiDBCluster)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetTiDBCluster indicates an expected call of GetTiDBCluster.
func (mr *MockInfraMockRecorder) GetTiDBCluster(ctx, projectID, clusterID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTiDBCluster", reflect.TypeOf((*MockInfra)(nil).GetTiDBCluster), ctx, projectID, clusterID)
}

// GetTiDBClusterCloudObj mocks base method.
func (m *MockInfra) GetTiDBClusterCloudObj(ctx context.Context, projectID, clusterID uint64) (*v1.Cluster, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTiDBClusterCloudObj", ctx, projectID, clusterID)
	ret0, _ := ret[0].(*v1.Cluster)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetTiDBClusterCloudObj indicates an expected call of GetTiDBClusterCloudObj.
func (mr *MockInfraMockRecorder) GetTiDBClusterCloudObj(ctx, projectID, clusterID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTiDBClusterCloudObj", reflect.TypeOf((*MockInfra)(nil).GetTiDBClusterCloudObj), ctx, projectID, clusterID)
}

// GetWorkflow mocks base method.
func (m *MockInfra) GetWorkflow(ctx context.Context, projectID, workflowID uint64) (*v1alpha1.ChaosWorkflow, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkflow", ctx, projectID, workflowID)
	ret0, _ := ret[0].(*v1alpha1.ChaosWorkflow)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetWorkflow indicates an expected call of GetWorkflow.
func (mr *MockInfraMockRecorder) GetWorkflow(ctx, projectID, workflowID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflow", reflect.TypeOf((*MockInfra)(nil).GetWorkflow), ctx, projectID, workflowID)
}

// ListTiDBClusters mocks base method.
func (m *MockInfra) ListTiDBClusters(ctx context.Context, projectID uint64, filter *facade.TiDBClusterFilter) ([]*facade.TiDBCluster, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTiDBClusters", ctx, projectID, filter)
	ret0, _ := ret[0].([]*facade.TiDBCluster)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// ListTiDBClusters indicates an expected call of ListTiDBClusters.
func (mr *MockInfraMockRecorder) ListTiDBClusters(ctx, projectID, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTiDBClusters", reflect.TypeOf((*MockInfra)(nil).ListTiDBClusters), ctx, projectID, filter)
}

// ListWorkflowNodes mocks base method.
func (m *MockInfra) ListWorkflowNodes(ctx context.Context, projectID, workflowID uint64) ([]v1alpha1.ChaosWorkflowNode, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListWorkflowNodes", ctx, projectID, workflowID)
	ret0, _ := ret[0].([]v1alpha1.ChaosWorkflowNode)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// ListWorkflowNodes indicates an expected call of ListWorkflowNodes.
func (mr *MockInfraMockRecorder) ListWorkflowNodes(ctx, projectID, workflowID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWorkflowNodes", reflect.TypeOf((*MockInfra)(nil).ListWorkflowNodes), ctx, projectID, workflowID)
}

// Namespace mocks base method.
func (m *MockInfra) Namespace(projectID uint64) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Namespace", projectID)
	ret0, _ := ret[0].(string)
	return ret0
}

// Namespace indicates an expected call of Namespace.
func (mr *MockInfraMockRecorder) Namespace(projectID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Namespace", reflect.TypeOf((*MockInfra)(nil).Namespace), projectID)
}

// WorkflowName mocks base method.
func (m *MockInfra) WorkflowName(workflowID uint64) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WorkflowName", workflowID)
	ret0, _ := ret[0].(string)
	return ret0
}

// WorkflowName indicates an expected call of WorkflowName.
func (mr *MockInfraMockRecorder) WorkflowName(workflowID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkflowName", reflect.TypeOf((*MockInfra)(nil).WorkflowName), workflowID)
}