sigs.k8s.io/cluster-api-provider-aws@v1.5.5/test/mocks/capa_clusterscoper_mock.go

/*
Copyright The Kubernetes Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

	http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

// Code generated by MockGen. DO NOT EDIT.
// Source: sigs.k8s.io/cluster-api-provider-aws/pkg/cloud (interfaces: ClusterScoper)

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

import (
	reflect "reflect"

	client "github.com/aws/aws-sdk-go/aws/client"
	logr "github.com/go-logr/logr"
	gomock "github.com/golang/mock/gomock"
	v1beta1 "sigs.k8s.io/cluster-api-provider-aws/api/v1beta1"
	cloud "sigs.k8s.io/cluster-api-provider-aws/pkg/cloud"
	throttle "sigs.k8s.io/cluster-api-provider-aws/pkg/cloud/throttle"
	v1beta10 "sigs.k8s.io/cluster-api/api/v1beta1"
	client0 "sigs.k8s.io/controller-runtime/pkg/client"
)

// MockClusterScoper is a mock of ClusterScoper interface.
type MockClusterScoper struct {
	ctrl     *gomock.Controller
	recorder *MockClusterScoperMockRecorder
}

// MockClusterScoperMockRecorder is the mock recorder for MockClusterScoper.
type MockClusterScoperMockRecorder struct {
	mock *MockClusterScoper
}

// NewMockClusterScoper creates a new mock instance.
func NewMockClusterScoper(ctrl *gomock.Controller) *MockClusterScoper {
	mock := &MockClusterScoper{ctrl: ctrl}
	mock.recorder = &MockClusterScoperMockRecorder{mock}
	return mock
}

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

// APIServerPort mocks base method.
func (m *MockClusterScoper) APIServerPort() int32 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "APIServerPort")
	ret0, _ := ret[0].(int32)
	return ret0
}

// APIServerPort indicates an expected call of APIServerPort.
func (mr *MockClusterScoperMockRecorder) APIServerPort() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "APIServerPort", reflect.TypeOf((*MockClusterScoper)(nil).APIServerPort))
}

// AdditionalTags mocks base method.
func (m *MockClusterScoper) AdditionalTags() v1beta1.Tags {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AdditionalTags")
	ret0, _ := ret[0].(v1beta1.Tags)
	return ret0
}

// AdditionalTags indicates an expected call of AdditionalTags.
func (mr *MockClusterScoperMockRecorder) AdditionalTags() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdditionalTags", reflect.TypeOf((*MockClusterScoper)(nil).AdditionalTags))
}

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

// Close indicates an expected call of Close.
func (mr *MockClusterScoperMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockClusterScoper)(nil).Close))
}

// ClusterObj mocks base method.
func (m *MockClusterScoper) ClusterObj() cloud.ClusterObject {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterObj")
	ret0, _ := ret[0].(cloud.ClusterObject)
	return ret0
}

// ClusterObj indicates an expected call of ClusterObj.
func (mr *MockClusterScoperMockRecorder) ClusterObj() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterObj", reflect.TypeOf((*MockClusterScoper)(nil).ClusterObj))
}

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

// ControllerName indicates an expected call of ControllerName.
func (mr *MockClusterScoperMockRecorder) ControllerName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ControllerName", reflect.TypeOf((*MockClusterScoper)(nil).ControllerName))
}

// Enabled mocks base method.
func (m *MockClusterScoper) Enabled() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Enabled")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Enabled indicates an expected call of Enabled.
func (mr *MockClusterScoperMockRecorder) Enabled() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Enabled", reflect.TypeOf((*MockClusterScoper)(nil).Enabled))
}

// Error mocks base method.
func (m *MockClusterScoper) Error(arg0 error, arg1 string, arg2 ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Error", varargs...)
}

// Error indicates an expected call of Error.
func (mr *MockClusterScoperMockRecorder) Error(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockClusterScoper)(nil).Error), varargs...)
}

// IdentityRef mocks base method.
func (m *MockClusterScoper) IdentityRef() *v1beta1.AWSIdentityReference {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IdentityRef")
	ret0, _ := ret[0].(*v1beta1.AWSIdentityReference)
	return ret0
}

// IdentityRef indicates an expected call of IdentityRef.
func (mr *MockClusterScoperMockRecorder) IdentityRef() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IdentityRef", reflect.TypeOf((*MockClusterScoper)(nil).IdentityRef))
}

// Info mocks base method.
func (m *MockClusterScoper) Info(arg0 string, arg1 ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Info", varargs...)
}

// Info indicates an expected call of Info.
func (mr *MockClusterScoperMockRecorder) Info(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockClusterScoper)(nil).Info), varargs...)
}

// InfraCluster mocks base method.
func (m *MockClusterScoper) InfraCluster() cloud.ClusterObject {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InfraCluster")
	ret0, _ := ret[0].(cloud.ClusterObject)
	return ret0
}

// InfraCluster indicates an expected call of InfraCluster.
func (mr *MockClusterScoperMockRecorder) InfraCluster() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InfraCluster", reflect.TypeOf((*MockClusterScoper)(nil).InfraCluster))
}

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

// InfraClusterName indicates an expected call of InfraClusterName.
func (mr *MockClusterScoperMockRecorder) InfraClusterName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InfraClusterName", reflect.TypeOf((*MockClusterScoper)(nil).InfraClusterName))
}

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

// KubernetesClusterName indicates an expected call of KubernetesClusterName.
func (mr *MockClusterScoperMockRecorder) KubernetesClusterName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KubernetesClusterName", reflect.TypeOf((*MockClusterScoper)(nil).KubernetesClusterName))
}

// ListOptionsLabelSelector mocks base method.
func (m *MockClusterScoper) ListOptionsLabelSelector() client0.ListOption {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListOptionsLabelSelector")
	ret0, _ := ret[0].(client0.ListOption)
	return ret0
}

// ListOptionsLabelSelector indicates an expected call of ListOptionsLabelSelector.
func (mr *MockClusterScoperMockRecorder) ListOptionsLabelSelector() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOptionsLabelSelector", reflect.TypeOf((*MockClusterScoper)(nil).ListOptionsLabelSelector))
}

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

// Name indicates an expected call of Name.
func (mr *MockClusterScoperMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockClusterScoper)(nil).Name))
}

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

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

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

// PatchObject indicates an expected call of PatchObject.
func (mr *MockClusterScoperMockRecorder) PatchObject() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchObject", reflect.TypeOf((*MockClusterScoper)(nil).PatchObject))
}

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

// Region indicates an expected call of Region.
func (mr *MockClusterScoperMockRecorder) Region() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Region", reflect.TypeOf((*MockClusterScoper)(nil).Region))
}

// ServiceLimiter mocks base method.
func (m *MockClusterScoper) ServiceLimiter(arg0 string) *throttle.ServiceLimiter {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ServiceLimiter", arg0)
	ret0, _ := ret[0].(*throttle.ServiceLimiter)
	return ret0
}

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

// Session mocks base method.
func (m *MockClusterScoper) Session() client.ConfigProvider {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Session")
	ret0, _ := ret[0].(client.ConfigProvider)
	return ret0
}

// Session indicates an expected call of Session.
func (mr *MockClusterScoperMockRecorder) Session() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Session", reflect.TypeOf((*MockClusterScoper)(nil).Session))
}

// SetFailureDomain mocks base method.
func (m *MockClusterScoper) SetFailureDomain(arg0 string, arg1 v1beta10.FailureDomainSpec) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetFailureDomain", arg0, arg1)
}

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

// V mocks base method.
func (m *MockClusterScoper) V(arg0 int) logr.Logger {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "V", arg0)
	ret0, _ := ret[0].(logr.Logger)
	return ret0
}

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

// WithName mocks base method.
func (m *MockClusterScoper) WithName(arg0 string) logr.Logger {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WithName", arg0)
	ret0, _ := ret[0].(logr.Logger)
	return ret0
}

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

// WithValues mocks base method.
func (m *MockClusterScoper) WithValues(arg0 ...interface{}) logr.Logger {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WithValues", varargs...)
	ret0, _ := ret[0].(logr.Logger)
	return ret0
}

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