interface_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: app/api-server/pkg/clusters/interface.go

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

import (
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	v1alpha1 "github.com/nautes-labs/nautes/api/kubernetes/v1alpha1"
)

// MockClusterRegistrationOperator is a mock of ClusterRegistrationOperator interface.
type MockClusterRegistrationOperator struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRegistrationOperatorMockRecorder
}

// MockClusterRegistrationOperatorMockRecorder is the mock recorder for MockClusterRegistrationOperator.
type MockClusterRegistrationOperatorMockRecorder struct {
	mock *MockClusterRegistrationOperator
}

// NewMockClusterRegistrationOperator creates a new mock instance.
func NewMockClusterRegistrationOperator(ctrl *gomock.Controller) *MockClusterRegistrationOperator {
	mock := &MockClusterRegistrationOperator{ctrl: ctrl}
	mock.recorder = &MockClusterRegistrationOperatorMockRecorder{mock}
	return mock
}

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

// GetClsuter mocks base method.
func (m *MockClusterRegistrationOperator) GetClsuter(tenantLocalPath, clusterName string) (*v1alpha1.Cluster, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClsuter", tenantLocalPath, clusterName)
	ret0, _ := ret[0].(*v1alpha1.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClsuter indicates an expected call of GetClsuter.
func (mr *MockClusterRegistrationOperatorMockRecorder) GetClsuter(tenantLocalPath, clusterName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClsuter", reflect.TypeOf((*MockClusterRegistrationOperator)(nil).GetClsuter), tenantLocalPath, clusterName)
}

// ListClusters mocks base method.
func (m *MockClusterRegistrationOperator) ListClusters(tenantLocalPath string) ([]*v1alpha1.Cluster, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClusters", tenantLocalPath)
	ret0, _ := ret[0].([]*v1alpha1.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClusters indicates an expected call of ListClusters.
func (mr *MockClusterRegistrationOperatorMockRecorder) ListClusters(tenantLocalPath interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusters", reflect.TypeOf((*MockClusterRegistrationOperator)(nil).ListClusters), tenantLocalPath)
}

// RemoveCluster mocks base method.
func (m *MockClusterRegistrationOperator) RemoveCluster(params *ClusterRegistrationParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveCluster", params)
	ret0, _ := ret[0].(error)
	return ret0
}

// RemoveCluster indicates an expected call of RemoveCluster.
func (mr *MockClusterRegistrationOperatorMockRecorder) RemoveCluster(params interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveCluster", reflect.TypeOf((*MockClusterRegistrationOperator)(nil).RemoveCluster), params)
}

// SaveCluster mocks base method.
func (m *MockClusterRegistrationOperator) SaveCluster(params *ClusterRegistrationParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveCluster", params)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveCluster indicates an expected call of SaveCluster.
func (mr *MockClusterRegistrationOperatorMockRecorder) SaveCluster(params interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveCluster", reflect.TypeOf((*MockClusterRegistrationOperator)(nil).SaveCluster), params)
}

// MockDefaultValueProvider is a mock of DefaultValueProvider interface.
type MockDefaultValueProvider struct {
	ctrl     *gomock.Controller
	recorder *MockDefaultValueProviderMockRecorder
}

// MockDefaultValueProviderMockRecorder is the mock recorder for MockDefaultValueProvider.
type MockDefaultValueProviderMockRecorder struct {
	mock *MockDefaultValueProvider
}

// NewMockDefaultValueProvider creates a new mock instance.
func NewMockDefaultValueProvider(ctrl *gomock.Controller) *MockDefaultValueProvider {
	mock := &MockDefaultValueProvider{ctrl: ctrl}
	mock.recorder = &MockDefaultValueProviderMockRecorder{mock}
	return mock
}

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

// GetDefaultValue mocks base method.
func (m *MockDefaultValueProvider) GetDefaultValue(field string, opt *DefaultValueOptions) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefaultValue", field, opt)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDefaultValue indicates an expected call of GetDefaultValue.
func (mr *MockDefaultValueProviderMockRecorder) GetDefaultValue(field, opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultValue", reflect.TypeOf((*MockDefaultValueProvider)(nil).GetDefaultValue), field, opt)
}

// MockPipeline is a mock of Pipeline interface.
type MockPipeline struct {
	ctrl     *gomock.Controller
	recorder *MockPipelineMockRecorder
}

// MockPipelineMockRecorder is the mock recorder for MockPipeline.
type MockPipelineMockRecorder struct {
	mock *MockPipeline
}

// NewMockPipeline creates a new mock instance.
func NewMockPipeline(ctrl *gomock.Controller) *MockPipeline {
	mock := &MockPipeline{ctrl: ctrl}
	mock.recorder = &MockPipelineMockRecorder{mock}
	return mock
}

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

// GetDefaultValue mocks base method.
func (m *MockPipeline) GetDefaultValue(field string, opt *DefaultValueOptions) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefaultValue", field, opt)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDefaultValue indicates an expected call of GetDefaultValue.
func (mr *MockPipelineMockRecorder) GetDefaultValue(field, opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultValue", reflect.TypeOf((*MockPipeline)(nil).GetDefaultValue), field, opt)
}

// GetOauthURL mocks base method.
func (m *MockPipeline) GetOauthURL(param *ClusterRegistrationParams) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOauthURL", param)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOauthURL indicates an expected call of GetOauthURL.
func (mr *MockPipelineMockRecorder) GetOauthURL(param interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOauthURL", reflect.TypeOf((*MockPipeline)(nil).GetOauthURL), param)
}

// GetPipelineServer mocks base method.
func (m *MockPipeline) GetPipelineServer(param *ClusterRegistrationParams) *PipelineServer {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPipelineServer", param)
	ret0, _ := ret[0].(*PipelineServer)
	return ret0
}

// GetPipelineServer indicates an expected call of GetPipelineServer.
func (mr *MockPipelineMockRecorder) GetPipelineServer(param interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPipelineServer", reflect.TypeOf((*MockPipeline)(nil).GetPipelineServer), param)
}

// MockDeployment is a mock of Deployment interface.
type MockDeployment struct {
	ctrl     *gomock.Controller
	recorder *MockDeploymentMockRecorder
}

// MockDeploymentMockRecorder is the mock recorder for MockDeployment.
type MockDeploymentMockRecorder struct {
	mock *MockDeployment
}

// NewMockDeployment creates a new mock instance.
func NewMockDeployment(ctrl *gomock.Controller) *MockDeployment {
	mock := &MockDeployment{ctrl: ctrl}
	mock.recorder = &MockDeploymentMockRecorder{mock}
	return mock
}

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

// GetDefaultValue mocks base method.
func (m *MockDeployment) GetDefaultValue(field string, opt *DefaultValueOptions) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefaultValue", field, opt)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDefaultValue indicates an expected call of GetDefaultValue.
func (mr *MockDeploymentMockRecorder) GetDefaultValue(field, opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultValue", reflect.TypeOf((*MockDeployment)(nil).GetDefaultValue), field, opt)
}

// GetDeploymentServer mocks base method.
func (m *MockDeployment) GetDeploymentServer(param *ClusterRegistrationParams) *DeploymentServer {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDeploymentServer", param)
	ret0, _ := ret[0].(*DeploymentServer)
	return ret0
}

// GetDeploymentServer indicates an expected call of GetDeploymentServer.
func (mr *MockDeploymentMockRecorder) GetDeploymentServer(param interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeploymentServer", reflect.TypeOf((*MockDeployment)(nil).GetDeploymentServer), param)
}

// GetOauthURL mocks base method.
func (m *MockDeployment) GetOauthURL(param *ClusterRegistrationParams) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOauthURL", param)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOauthURL indicates an expected call of GetOauthURL.
func (mr *MockDeploymentMockRecorder) GetOauthURL(param interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOauthURL", reflect.TypeOf((*MockDeployment)(nil).GetOauthURL), param)
}

// MockGateway is a mock of Gateway interface.
type MockGateway struct {
	ctrl     *gomock.Controller
	recorder *MockGatewayMockRecorder
}

// MockGatewayMockRecorder is the mock recorder for MockGateway.
type MockGatewayMockRecorder struct {
	mock *MockGateway
}

// NewMockGateway creates a new mock instance.
func NewMockGateway(ctrl *gomock.Controller) *MockGateway {
	mock := &MockGateway{ctrl: ctrl}
	mock.recorder = &MockGatewayMockRecorder{mock}
	return mock
}

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

// GetDefaultValue mocks base method.
func (m *MockGateway) GetDefaultValue(field string, opt *DefaultValueOptions) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefaultValue", field, opt)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDefaultValue indicates an expected call of GetDefaultValue.
func (mr *MockGatewayMockRecorder) GetDefaultValue(field, opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultValue", reflect.TypeOf((*MockGateway)(nil).GetDefaultValue), field, opt)
}

// GetGatewayServer mocks base method.
func (m *MockGateway) GetGatewayServer(param *ClusterRegistrationParams) *GatewayServer {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGatewayServer", param)
	ret0, _ := ret[0].(*GatewayServer)
	return ret0
}

// GetGatewayServer indicates an expected call of GetGatewayServer.
func (mr *MockGatewayMockRecorder) GetGatewayServer(param interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGatewayServer", reflect.TypeOf((*MockGateway)(nil).GetGatewayServer), param)
}

// MockOAuthProxy is a mock of OAuthProxy interface.
type MockOAuthProxy struct {
	ctrl     *gomock.Controller
	recorder *MockOAuthProxyMockRecorder
}

// MockOAuthProxyMockRecorder is the mock recorder for MockOAuthProxy.
type MockOAuthProxyMockRecorder struct {
	mock *MockOAuthProxy
}

// NewMockOAuthProxy creates a new mock instance.
func NewMockOAuthProxy(ctrl *gomock.Controller) *MockOAuthProxy {
	mock := &MockOAuthProxy{ctrl: ctrl}
	mock.recorder = &MockOAuthProxyMockRecorder{mock}
	return mock
}

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

// GetDefaultValue mocks base method.
func (m *MockOAuthProxy) GetDefaultValue(field string, opt *DefaultValueOptions) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefaultValue", field, opt)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDefaultValue indicates an expected call of GetDefaultValue.
func (mr *MockOAuthProxyMockRecorder) GetDefaultValue(field, opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultValue", reflect.TypeOf((*MockOAuthProxy)(nil).GetDefaultValue), field, opt)
}

// GetOauthProxyServer mocks base method.
func (m *MockOAuthProxy) GetOauthProxyServer(param *ClusterRegistrationParams) *OAuthProxyServer {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOauthProxyServer", param)
	ret0, _ := ret[0].(*OAuthProxyServer)
	return ret0
}

// GetOauthProxyServer indicates an expected call of GetOauthProxyServer.
func (mr *MockOAuthProxyMockRecorder) GetOauthProxyServer(param interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOauthProxyServer", reflect.TypeOf((*MockOAuthProxy)(nil).GetOauthProxyServer), param)
}

// MockSecretManagement is a mock of SecretManagement interface.
type MockSecretManagement struct {
	ctrl     *gomock.Controller
	recorder *MockSecretManagementMockRecorder
}

// MockSecretManagementMockRecorder is the mock recorder for MockSecretManagement.
type MockSecretManagementMockRecorder struct {
	mock *MockSecretManagement
}

// NewMockSecretManagement creates a new mock instance.
func NewMockSecretManagement(ctrl *gomock.Controller) *MockSecretManagement {
	mock := &MockSecretManagement{ctrl: ctrl}
	mock.recorder = &MockSecretManagementMockRecorder{mock}
	return mock
}

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

// GetDefaultValue mocks base method.
func (m *MockSecretManagement) GetDefaultValue(field string, opt *DefaultValueOptions) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefaultValue", field, opt)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDefaultValue indicates an expected call of GetDefaultValue.
func (mr *MockSecretManagementMockRecorder) GetDefaultValue(field, opt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultValue", reflect.TypeOf((*MockSecretManagement)(nil).GetDefaultValue), field, opt)
}