diff --git a/go.mod b/go.mod index fbb77e4..a3c2949 100644 --- a/go.mod +++ b/go.mod @@ -55,6 +55,7 @@ require ( github.com/spf13/cobra v1.9.1 // indirect github.com/spf13/pflag v1.0.6 // indirect github.com/x448/float16 v0.8.4 // indirect + go.uber.org/mock v0.6.0 // indirect go.uber.org/zap v1.27.0 // indirect go.yaml.in/yaml/v2 v2.4.2 // indirect go.yaml.in/yaml/v3 v3.0.4 // indirect diff --git a/go.sum b/go.sum index 166c11b..6e726ba 100644 --- a/go.sum +++ b/go.sum @@ -138,6 +138,8 @@ go.uber.org/automaxprocs v1.6.0 h1:O3y2/QNTOdbF+e/dpXNNW7Rx2hZ4sTIPyybbxyNqTUs= go.uber.org/automaxprocs v1.6.0/go.mod h1:ifeIMSnPZuznNm6jmdzmU3/bfk01Fe2fotchwEFJ8r8= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= +go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= diff --git a/pkg/mocks/discovery_mock.go b/pkg/mocks/discovery_mock.go new file mode 100644 index 0000000..32f83a3 --- /dev/null +++ b/pkg/mocks/discovery_mock.go @@ -0,0 +1,194 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: k8s.io/client-go/discovery (interfaces: DiscoveryInterface) +// +// Generated by this command: +// +// mockgen -package=mocks -destination=pkg/mocks/discovery_mock.go k8s.io/client-go/discovery DiscoveryInterface +// + +// Package mocks is a generated GoMock package. +package mocks + +import ( + reflect "reflect" + + openapiv2 "github.com/google/gnostic-models/openapiv2" + gomock "go.uber.org/mock/gomock" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + version "k8s.io/apimachinery/pkg/version" + discovery "k8s.io/client-go/discovery" + openapi "k8s.io/client-go/openapi" + rest "k8s.io/client-go/rest" +) + +// MockDiscoveryInterface is a mock of DiscoveryInterface interface. +type MockDiscoveryInterface struct { + ctrl *gomock.Controller + recorder *MockDiscoveryInterfaceMockRecorder + isgomock struct{} +} + +// MockDiscoveryInterfaceMockRecorder is the mock recorder for MockDiscoveryInterface. +type MockDiscoveryInterfaceMockRecorder struct { + mock *MockDiscoveryInterface +} + +// NewMockDiscoveryInterface creates a new mock instance. +func NewMockDiscoveryInterface(ctrl *gomock.Controller) *MockDiscoveryInterface { + mock := &MockDiscoveryInterface{ctrl: ctrl} + mock.recorder = &MockDiscoveryInterfaceMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockDiscoveryInterface) EXPECT() *MockDiscoveryInterfaceMockRecorder { + return m.recorder +} + +// OpenAPISchema mocks base method. +func (m *MockDiscoveryInterface) OpenAPISchema() (*openapiv2.Document, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OpenAPISchema") + ret0, _ := ret[0].(*openapiv2.Document) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// OpenAPISchema indicates an expected call of OpenAPISchema. +func (mr *MockDiscoveryInterfaceMockRecorder) OpenAPISchema() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenAPISchema", reflect.TypeOf((*MockDiscoveryInterface)(nil).OpenAPISchema)) +} + +// OpenAPIV3 mocks base method. +func (m *MockDiscoveryInterface) OpenAPIV3() openapi.Client { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OpenAPIV3") + ret0, _ := ret[0].(openapi.Client) + return ret0 +} + +// OpenAPIV3 indicates an expected call of OpenAPIV3. +func (mr *MockDiscoveryInterfaceMockRecorder) OpenAPIV3() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenAPIV3", reflect.TypeOf((*MockDiscoveryInterface)(nil).OpenAPIV3)) +} + +// RESTClient mocks base method. +func (m *MockDiscoveryInterface) RESTClient() rest.Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RESTClient") + ret0, _ := ret[0].(rest.Interface) + return ret0 +} + +// RESTClient indicates an expected call of RESTClient. +func (mr *MockDiscoveryInterfaceMockRecorder) RESTClient() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RESTClient", reflect.TypeOf((*MockDiscoveryInterface)(nil).RESTClient)) +} + +// ServerGroups mocks base method. +func (m *MockDiscoveryInterface) ServerGroups() (*v1.APIGroupList, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ServerGroups") + ret0, _ := ret[0].(*v1.APIGroupList) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ServerGroups indicates an expected call of ServerGroups. +func (mr *MockDiscoveryInterfaceMockRecorder) ServerGroups() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServerGroups", reflect.TypeOf((*MockDiscoveryInterface)(nil).ServerGroups)) +} + +// ServerGroupsAndResources mocks base method. +func (m *MockDiscoveryInterface) ServerGroupsAndResources() ([]*v1.APIGroup, []*v1.APIResourceList, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ServerGroupsAndResources") + ret0, _ := ret[0].([]*v1.APIGroup) + ret1, _ := ret[1].([]*v1.APIResourceList) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// ServerGroupsAndResources indicates an expected call of ServerGroupsAndResources. +func (mr *MockDiscoveryInterfaceMockRecorder) ServerGroupsAndResources() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServerGroupsAndResources", reflect.TypeOf((*MockDiscoveryInterface)(nil).ServerGroupsAndResources)) +} + +// ServerPreferredNamespacedResources mocks base method. +func (m *MockDiscoveryInterface) ServerPreferredNamespacedResources() ([]*v1.APIResourceList, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ServerPreferredNamespacedResources") + ret0, _ := ret[0].([]*v1.APIResourceList) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ServerPreferredNamespacedResources indicates an expected call of ServerPreferredNamespacedResources. +func (mr *MockDiscoveryInterfaceMockRecorder) ServerPreferredNamespacedResources() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServerPreferredNamespacedResources", reflect.TypeOf((*MockDiscoveryInterface)(nil).ServerPreferredNamespacedResources)) +} + +// ServerPreferredResources mocks base method. +func (m *MockDiscoveryInterface) ServerPreferredResources() ([]*v1.APIResourceList, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ServerPreferredResources") + ret0, _ := ret[0].([]*v1.APIResourceList) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ServerPreferredResources indicates an expected call of ServerPreferredResources. +func (mr *MockDiscoveryInterfaceMockRecorder) ServerPreferredResources() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServerPreferredResources", reflect.TypeOf((*MockDiscoveryInterface)(nil).ServerPreferredResources)) +} + +// ServerResourcesForGroupVersion mocks base method. +func (m *MockDiscoveryInterface) ServerResourcesForGroupVersion(groupVersion string) (*v1.APIResourceList, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ServerResourcesForGroupVersion", groupVersion) + ret0, _ := ret[0].(*v1.APIResourceList) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ServerResourcesForGroupVersion indicates an expected call of ServerResourcesForGroupVersion. +func (mr *MockDiscoveryInterfaceMockRecorder) ServerResourcesForGroupVersion(groupVersion any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServerResourcesForGroupVersion", reflect.TypeOf((*MockDiscoveryInterface)(nil).ServerResourcesForGroupVersion), groupVersion) +} + +// ServerVersion mocks base method. +func (m *MockDiscoveryInterface) ServerVersion() (*version.Info, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ServerVersion") + ret0, _ := ret[0].(*version.Info) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ServerVersion indicates an expected call of ServerVersion. +func (mr *MockDiscoveryInterfaceMockRecorder) ServerVersion() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServerVersion", reflect.TypeOf((*MockDiscoveryInterface)(nil).ServerVersion)) +} + +// WithLegacy mocks base method. +func (m *MockDiscoveryInterface) WithLegacy() discovery.DiscoveryInterface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WithLegacy") + ret0, _ := ret[0].(discovery.DiscoveryInterface) + return ret0 +} + +// WithLegacy indicates an expected call of WithLegacy. +func (mr *MockDiscoveryInterfaceMockRecorder) WithLegacy() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithLegacy", reflect.TypeOf((*MockDiscoveryInterface)(nil).WithLegacy)) +} diff --git a/pkg/mocks/interface_mock.go b/pkg/mocks/interface_mock.go new file mode 100644 index 0000000..9b2b9de --- /dev/null +++ b/pkg/mocks/interface_mock.go @@ -0,0 +1,880 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: k8s.io/client-go/kubernetes (interfaces: Interface) +// +// Generated by this command: +// +// mockgen -package=mocks -destination=pkg/mocks/interface_mock.go k8s.io/client-go/kubernetes Interface +// + +// Package mocks is a generated GoMock package. +package mocks + +import ( + reflect "reflect" + + gomock "go.uber.org/mock/gomock" + discovery "k8s.io/client-go/discovery" + v1 "k8s.io/client-go/kubernetes/typed/admissionregistration/v1" + v1alpha1 "k8s.io/client-go/kubernetes/typed/admissionregistration/v1alpha1" + v1beta1 "k8s.io/client-go/kubernetes/typed/admissionregistration/v1beta1" + v1alpha10 "k8s.io/client-go/kubernetes/typed/apiserverinternal/v1alpha1" + v10 "k8s.io/client-go/kubernetes/typed/apps/v1" + v1beta10 "k8s.io/client-go/kubernetes/typed/apps/v1beta1" + v1beta2 "k8s.io/client-go/kubernetes/typed/apps/v1beta2" + v11 "k8s.io/client-go/kubernetes/typed/authentication/v1" + v1alpha11 "k8s.io/client-go/kubernetes/typed/authentication/v1alpha1" + v1beta11 "k8s.io/client-go/kubernetes/typed/authentication/v1beta1" + v12 "k8s.io/client-go/kubernetes/typed/authorization/v1" + v1beta12 "k8s.io/client-go/kubernetes/typed/authorization/v1beta1" + v13 "k8s.io/client-go/kubernetes/typed/autoscaling/v1" + v2 "k8s.io/client-go/kubernetes/typed/autoscaling/v2" + v2beta1 "k8s.io/client-go/kubernetes/typed/autoscaling/v2beta1" + v2beta2 "k8s.io/client-go/kubernetes/typed/autoscaling/v2beta2" + v14 "k8s.io/client-go/kubernetes/typed/batch/v1" + v1beta13 "k8s.io/client-go/kubernetes/typed/batch/v1beta1" + v15 "k8s.io/client-go/kubernetes/typed/certificates/v1" + v1alpha12 "k8s.io/client-go/kubernetes/typed/certificates/v1alpha1" + v1beta14 "k8s.io/client-go/kubernetes/typed/certificates/v1beta1" + v16 "k8s.io/client-go/kubernetes/typed/coordination/v1" + v1alpha2 "k8s.io/client-go/kubernetes/typed/coordination/v1alpha2" + v1beta15 "k8s.io/client-go/kubernetes/typed/coordination/v1beta1" + v17 "k8s.io/client-go/kubernetes/typed/core/v1" + v18 "k8s.io/client-go/kubernetes/typed/discovery/v1" + v1beta16 "k8s.io/client-go/kubernetes/typed/discovery/v1beta1" + v19 "k8s.io/client-go/kubernetes/typed/events/v1" + v1beta17 "k8s.io/client-go/kubernetes/typed/events/v1beta1" + v1beta18 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1" + v110 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1" + v1beta19 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta1" + v1beta20 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta2" + v1beta3 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta3" + v111 "k8s.io/client-go/kubernetes/typed/networking/v1" + v1beta110 "k8s.io/client-go/kubernetes/typed/networking/v1beta1" + v112 "k8s.io/client-go/kubernetes/typed/node/v1" + v1alpha13 "k8s.io/client-go/kubernetes/typed/node/v1alpha1" + v1beta111 "k8s.io/client-go/kubernetes/typed/node/v1beta1" + v113 "k8s.io/client-go/kubernetes/typed/policy/v1" + v1beta112 "k8s.io/client-go/kubernetes/typed/policy/v1beta1" + v114 "k8s.io/client-go/kubernetes/typed/rbac/v1" + v1alpha14 "k8s.io/client-go/kubernetes/typed/rbac/v1alpha1" + v1beta113 "k8s.io/client-go/kubernetes/typed/rbac/v1beta1" + v115 "k8s.io/client-go/kubernetes/typed/resource/v1" + v1alpha3 "k8s.io/client-go/kubernetes/typed/resource/v1alpha3" + v1beta114 "k8s.io/client-go/kubernetes/typed/resource/v1beta1" + v1beta21 "k8s.io/client-go/kubernetes/typed/resource/v1beta2" + v116 "k8s.io/client-go/kubernetes/typed/scheduling/v1" + v1alpha15 "k8s.io/client-go/kubernetes/typed/scheduling/v1alpha1" + v1beta115 "k8s.io/client-go/kubernetes/typed/scheduling/v1beta1" + v117 "k8s.io/client-go/kubernetes/typed/storage/v1" + v1alpha16 "k8s.io/client-go/kubernetes/typed/storage/v1alpha1" + v1beta116 "k8s.io/client-go/kubernetes/typed/storage/v1beta1" + v1alpha17 "k8s.io/client-go/kubernetes/typed/storagemigration/v1alpha1" +) + +// MockInterface is a mock of Interface interface. +type MockInterface struct { + ctrl *gomock.Controller + recorder *MockInterfaceMockRecorder + isgomock struct{} +} + +// MockInterfaceMockRecorder is the mock recorder for MockInterface. +type MockInterfaceMockRecorder struct { + mock *MockInterface +} + +// NewMockInterface creates a new mock instance. +func NewMockInterface(ctrl *gomock.Controller) *MockInterface { + mock := &MockInterface{ctrl: ctrl} + mock.recorder = &MockInterfaceMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder { + return m.recorder +} + +// AdmissionregistrationV1 mocks base method. +func (m *MockInterface) AdmissionregistrationV1() v1.AdmissionregistrationV1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AdmissionregistrationV1") + ret0, _ := ret[0].(v1.AdmissionregistrationV1Interface) + return ret0 +} + +// AdmissionregistrationV1 indicates an expected call of AdmissionregistrationV1. +func (mr *MockInterfaceMockRecorder) AdmissionregistrationV1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdmissionregistrationV1", reflect.TypeOf((*MockInterface)(nil).AdmissionregistrationV1)) +} + +// AdmissionregistrationV1alpha1 mocks base method. +func (m *MockInterface) AdmissionregistrationV1alpha1() v1alpha1.AdmissionregistrationV1alpha1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AdmissionregistrationV1alpha1") + ret0, _ := ret[0].(v1alpha1.AdmissionregistrationV1alpha1Interface) + return ret0 +} + +// AdmissionregistrationV1alpha1 indicates an expected call of AdmissionregistrationV1alpha1. +func (mr *MockInterfaceMockRecorder) AdmissionregistrationV1alpha1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdmissionregistrationV1alpha1", reflect.TypeOf((*MockInterface)(nil).AdmissionregistrationV1alpha1)) +} + +// AdmissionregistrationV1beta1 mocks base method. +func (m *MockInterface) AdmissionregistrationV1beta1() v1beta1.AdmissionregistrationV1beta1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AdmissionregistrationV1beta1") + ret0, _ := ret[0].(v1beta1.AdmissionregistrationV1beta1Interface) + return ret0 +} + +// AdmissionregistrationV1beta1 indicates an expected call of AdmissionregistrationV1beta1. +func (mr *MockInterfaceMockRecorder) AdmissionregistrationV1beta1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdmissionregistrationV1beta1", reflect.TypeOf((*MockInterface)(nil).AdmissionregistrationV1beta1)) +} + +// AppsV1 mocks base method. +func (m *MockInterface) AppsV1() v10.AppsV1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AppsV1") + ret0, _ := ret[0].(v10.AppsV1Interface) + return ret0 +} + +// AppsV1 indicates an expected call of AppsV1. +func (mr *MockInterfaceMockRecorder) AppsV1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppsV1", reflect.TypeOf((*MockInterface)(nil).AppsV1)) +} + +// AppsV1beta1 mocks base method. +func (m *MockInterface) AppsV1beta1() v1beta10.AppsV1beta1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AppsV1beta1") + ret0, _ := ret[0].(v1beta10.AppsV1beta1Interface) + return ret0 +} + +// AppsV1beta1 indicates an expected call of AppsV1beta1. +func (mr *MockInterfaceMockRecorder) AppsV1beta1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppsV1beta1", reflect.TypeOf((*MockInterface)(nil).AppsV1beta1)) +} + +// AppsV1beta2 mocks base method. +func (m *MockInterface) AppsV1beta2() v1beta2.AppsV1beta2Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AppsV1beta2") + ret0, _ := ret[0].(v1beta2.AppsV1beta2Interface) + return ret0 +} + +// AppsV1beta2 indicates an expected call of AppsV1beta2. +func (mr *MockInterfaceMockRecorder) AppsV1beta2() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppsV1beta2", reflect.TypeOf((*MockInterface)(nil).AppsV1beta2)) +} + +// AuthenticationV1 mocks base method. +func (m *MockInterface) AuthenticationV1() v11.AuthenticationV1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AuthenticationV1") + ret0, _ := ret[0].(v11.AuthenticationV1Interface) + return ret0 +} + +// AuthenticationV1 indicates an expected call of AuthenticationV1. +func (mr *MockInterfaceMockRecorder) AuthenticationV1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthenticationV1", reflect.TypeOf((*MockInterface)(nil).AuthenticationV1)) +} + +// AuthenticationV1alpha1 mocks base method. +func (m *MockInterface) AuthenticationV1alpha1() v1alpha11.AuthenticationV1alpha1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AuthenticationV1alpha1") + ret0, _ := ret[0].(v1alpha11.AuthenticationV1alpha1Interface) + return ret0 +} + +// AuthenticationV1alpha1 indicates an expected call of AuthenticationV1alpha1. +func (mr *MockInterfaceMockRecorder) AuthenticationV1alpha1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthenticationV1alpha1", reflect.TypeOf((*MockInterface)(nil).AuthenticationV1alpha1)) +} + +// AuthenticationV1beta1 mocks base method. +func (m *MockInterface) AuthenticationV1beta1() v1beta11.AuthenticationV1beta1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AuthenticationV1beta1") + ret0, _ := ret[0].(v1beta11.AuthenticationV1beta1Interface) + return ret0 +} + +// AuthenticationV1beta1 indicates an expected call of AuthenticationV1beta1. +func (mr *MockInterfaceMockRecorder) AuthenticationV1beta1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthenticationV1beta1", reflect.TypeOf((*MockInterface)(nil).AuthenticationV1beta1)) +} + +// AuthorizationV1 mocks base method. +func (m *MockInterface) AuthorizationV1() v12.AuthorizationV1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AuthorizationV1") + ret0, _ := ret[0].(v12.AuthorizationV1Interface) + return ret0 +} + +// AuthorizationV1 indicates an expected call of AuthorizationV1. +func (mr *MockInterfaceMockRecorder) AuthorizationV1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizationV1", reflect.TypeOf((*MockInterface)(nil).AuthorizationV1)) +} + +// AuthorizationV1beta1 mocks base method. +func (m *MockInterface) AuthorizationV1beta1() v1beta12.AuthorizationV1beta1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AuthorizationV1beta1") + ret0, _ := ret[0].(v1beta12.AuthorizationV1beta1Interface) + return ret0 +} + +// AuthorizationV1beta1 indicates an expected call of AuthorizationV1beta1. +func (mr *MockInterfaceMockRecorder) AuthorizationV1beta1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizationV1beta1", reflect.TypeOf((*MockInterface)(nil).AuthorizationV1beta1)) +} + +// AutoscalingV1 mocks base method. +func (m *MockInterface) AutoscalingV1() v13.AutoscalingV1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AutoscalingV1") + ret0, _ := ret[0].(v13.AutoscalingV1Interface) + return ret0 +} + +// AutoscalingV1 indicates an expected call of AutoscalingV1. +func (mr *MockInterfaceMockRecorder) AutoscalingV1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AutoscalingV1", reflect.TypeOf((*MockInterface)(nil).AutoscalingV1)) +} + +// AutoscalingV2 mocks base method. +func (m *MockInterface) AutoscalingV2() v2.AutoscalingV2Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AutoscalingV2") + ret0, _ := ret[0].(v2.AutoscalingV2Interface) + return ret0 +} + +// AutoscalingV2 indicates an expected call of AutoscalingV2. +func (mr *MockInterfaceMockRecorder) AutoscalingV2() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AutoscalingV2", reflect.TypeOf((*MockInterface)(nil).AutoscalingV2)) +} + +// AutoscalingV2beta1 mocks base method. +func (m *MockInterface) AutoscalingV2beta1() v2beta1.AutoscalingV2beta1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AutoscalingV2beta1") + ret0, _ := ret[0].(v2beta1.AutoscalingV2beta1Interface) + return ret0 +} + +// AutoscalingV2beta1 indicates an expected call of AutoscalingV2beta1. +func (mr *MockInterfaceMockRecorder) AutoscalingV2beta1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AutoscalingV2beta1", reflect.TypeOf((*MockInterface)(nil).AutoscalingV2beta1)) +} + +// AutoscalingV2beta2 mocks base method. +func (m *MockInterface) AutoscalingV2beta2() v2beta2.AutoscalingV2beta2Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AutoscalingV2beta2") + ret0, _ := ret[0].(v2beta2.AutoscalingV2beta2Interface) + return ret0 +} + +// AutoscalingV2beta2 indicates an expected call of AutoscalingV2beta2. +func (mr *MockInterfaceMockRecorder) AutoscalingV2beta2() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AutoscalingV2beta2", reflect.TypeOf((*MockInterface)(nil).AutoscalingV2beta2)) +} + +// BatchV1 mocks base method. +func (m *MockInterface) BatchV1() v14.BatchV1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchV1") + ret0, _ := ret[0].(v14.BatchV1Interface) + return ret0 +} + +// BatchV1 indicates an expected call of BatchV1. +func (mr *MockInterfaceMockRecorder) BatchV1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchV1", reflect.TypeOf((*MockInterface)(nil).BatchV1)) +} + +// BatchV1beta1 mocks base method. +func (m *MockInterface) BatchV1beta1() v1beta13.BatchV1beta1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchV1beta1") + ret0, _ := ret[0].(v1beta13.BatchV1beta1Interface) + return ret0 +} + +// BatchV1beta1 indicates an expected call of BatchV1beta1. +func (mr *MockInterfaceMockRecorder) BatchV1beta1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchV1beta1", reflect.TypeOf((*MockInterface)(nil).BatchV1beta1)) +} + +// CertificatesV1 mocks base method. +func (m *MockInterface) CertificatesV1() v15.CertificatesV1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CertificatesV1") + ret0, _ := ret[0].(v15.CertificatesV1Interface) + return ret0 +} + +// CertificatesV1 indicates an expected call of CertificatesV1. +func (mr *MockInterfaceMockRecorder) CertificatesV1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CertificatesV1", reflect.TypeOf((*MockInterface)(nil).CertificatesV1)) +} + +// CertificatesV1alpha1 mocks base method. +func (m *MockInterface) CertificatesV1alpha1() v1alpha12.CertificatesV1alpha1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CertificatesV1alpha1") + ret0, _ := ret[0].(v1alpha12.CertificatesV1alpha1Interface) + return ret0 +} + +// CertificatesV1alpha1 indicates an expected call of CertificatesV1alpha1. +func (mr *MockInterfaceMockRecorder) CertificatesV1alpha1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CertificatesV1alpha1", reflect.TypeOf((*MockInterface)(nil).CertificatesV1alpha1)) +} + +// CertificatesV1beta1 mocks base method. +func (m *MockInterface) CertificatesV1beta1() v1beta14.CertificatesV1beta1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CertificatesV1beta1") + ret0, _ := ret[0].(v1beta14.CertificatesV1beta1Interface) + return ret0 +} + +// CertificatesV1beta1 indicates an expected call of CertificatesV1beta1. +func (mr *MockInterfaceMockRecorder) CertificatesV1beta1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CertificatesV1beta1", reflect.TypeOf((*MockInterface)(nil).CertificatesV1beta1)) +} + +// CoordinationV1 mocks base method. +func (m *MockInterface) CoordinationV1() v16.CoordinationV1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CoordinationV1") + ret0, _ := ret[0].(v16.CoordinationV1Interface) + return ret0 +} + +// CoordinationV1 indicates an expected call of CoordinationV1. +func (mr *MockInterfaceMockRecorder) CoordinationV1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CoordinationV1", reflect.TypeOf((*MockInterface)(nil).CoordinationV1)) +} + +// CoordinationV1alpha2 mocks base method. +func (m *MockInterface) CoordinationV1alpha2() v1alpha2.CoordinationV1alpha2Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CoordinationV1alpha2") + ret0, _ := ret[0].(v1alpha2.CoordinationV1alpha2Interface) + return ret0 +} + +// CoordinationV1alpha2 indicates an expected call of CoordinationV1alpha2. +func (mr *MockInterfaceMockRecorder) CoordinationV1alpha2() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CoordinationV1alpha2", reflect.TypeOf((*MockInterface)(nil).CoordinationV1alpha2)) +} + +// CoordinationV1beta1 mocks base method. +func (m *MockInterface) CoordinationV1beta1() v1beta15.CoordinationV1beta1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CoordinationV1beta1") + ret0, _ := ret[0].(v1beta15.CoordinationV1beta1Interface) + return ret0 +} + +// CoordinationV1beta1 indicates an expected call of CoordinationV1beta1. +func (mr *MockInterfaceMockRecorder) CoordinationV1beta1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CoordinationV1beta1", reflect.TypeOf((*MockInterface)(nil).CoordinationV1beta1)) +} + +// CoreV1 mocks base method. +func (m *MockInterface) CoreV1() v17.CoreV1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CoreV1") + ret0, _ := ret[0].(v17.CoreV1Interface) + return ret0 +} + +// CoreV1 indicates an expected call of CoreV1. +func (mr *MockInterfaceMockRecorder) CoreV1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CoreV1", reflect.TypeOf((*MockInterface)(nil).CoreV1)) +} + +// Discovery mocks base method. +func (m *MockInterface) Discovery() discovery.DiscoveryInterface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Discovery") + ret0, _ := ret[0].(discovery.DiscoveryInterface) + return ret0 +} + +// Discovery indicates an expected call of Discovery. +func (mr *MockInterfaceMockRecorder) Discovery() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Discovery", reflect.TypeOf((*MockInterface)(nil).Discovery)) +} + +// DiscoveryV1 mocks base method. +func (m *MockInterface) DiscoveryV1() v18.DiscoveryV1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DiscoveryV1") + ret0, _ := ret[0].(v18.DiscoveryV1Interface) + return ret0 +} + +// DiscoveryV1 indicates an expected call of DiscoveryV1. +func (mr *MockInterfaceMockRecorder) DiscoveryV1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoveryV1", reflect.TypeOf((*MockInterface)(nil).DiscoveryV1)) +} + +// DiscoveryV1beta1 mocks base method. +func (m *MockInterface) DiscoveryV1beta1() v1beta16.DiscoveryV1beta1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DiscoveryV1beta1") + ret0, _ := ret[0].(v1beta16.DiscoveryV1beta1Interface) + return ret0 +} + +// DiscoveryV1beta1 indicates an expected call of DiscoveryV1beta1. +func (mr *MockInterfaceMockRecorder) DiscoveryV1beta1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoveryV1beta1", reflect.TypeOf((*MockInterface)(nil).DiscoveryV1beta1)) +} + +// EventsV1 mocks base method. +func (m *MockInterface) EventsV1() v19.EventsV1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EventsV1") + ret0, _ := ret[0].(v19.EventsV1Interface) + return ret0 +} + +// EventsV1 indicates an expected call of EventsV1. +func (mr *MockInterfaceMockRecorder) EventsV1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EventsV1", reflect.TypeOf((*MockInterface)(nil).EventsV1)) +} + +// EventsV1beta1 mocks base method. +func (m *MockInterface) EventsV1beta1() v1beta17.EventsV1beta1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EventsV1beta1") + ret0, _ := ret[0].(v1beta17.EventsV1beta1Interface) + return ret0 +} + +// EventsV1beta1 indicates an expected call of EventsV1beta1. +func (mr *MockInterfaceMockRecorder) EventsV1beta1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EventsV1beta1", reflect.TypeOf((*MockInterface)(nil).EventsV1beta1)) +} + +// ExtensionsV1beta1 mocks base method. +func (m *MockInterface) ExtensionsV1beta1() v1beta18.ExtensionsV1beta1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExtensionsV1beta1") + ret0, _ := ret[0].(v1beta18.ExtensionsV1beta1Interface) + return ret0 +} + +// ExtensionsV1beta1 indicates an expected call of ExtensionsV1beta1. +func (mr *MockInterfaceMockRecorder) ExtensionsV1beta1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExtensionsV1beta1", reflect.TypeOf((*MockInterface)(nil).ExtensionsV1beta1)) +} + +// FlowcontrolV1 mocks base method. +func (m *MockInterface) FlowcontrolV1() v110.FlowcontrolV1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FlowcontrolV1") + ret0, _ := ret[0].(v110.FlowcontrolV1Interface) + return ret0 +} + +// FlowcontrolV1 indicates an expected call of FlowcontrolV1. +func (mr *MockInterfaceMockRecorder) FlowcontrolV1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlowcontrolV1", reflect.TypeOf((*MockInterface)(nil).FlowcontrolV1)) +} + +// FlowcontrolV1beta1 mocks base method. +func (m *MockInterface) FlowcontrolV1beta1() v1beta19.FlowcontrolV1beta1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FlowcontrolV1beta1") + ret0, _ := ret[0].(v1beta19.FlowcontrolV1beta1Interface) + return ret0 +} + +// FlowcontrolV1beta1 indicates an expected call of FlowcontrolV1beta1. +func (mr *MockInterfaceMockRecorder) FlowcontrolV1beta1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlowcontrolV1beta1", reflect.TypeOf((*MockInterface)(nil).FlowcontrolV1beta1)) +} + +// FlowcontrolV1beta2 mocks base method. +func (m *MockInterface) FlowcontrolV1beta2() v1beta20.FlowcontrolV1beta2Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FlowcontrolV1beta2") + ret0, _ := ret[0].(v1beta20.FlowcontrolV1beta2Interface) + return ret0 +} + +// FlowcontrolV1beta2 indicates an expected call of FlowcontrolV1beta2. +func (mr *MockInterfaceMockRecorder) FlowcontrolV1beta2() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlowcontrolV1beta2", reflect.TypeOf((*MockInterface)(nil).FlowcontrolV1beta2)) +} + +// FlowcontrolV1beta3 mocks base method. +func (m *MockInterface) FlowcontrolV1beta3() v1beta3.FlowcontrolV1beta3Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FlowcontrolV1beta3") + ret0, _ := ret[0].(v1beta3.FlowcontrolV1beta3Interface) + return ret0 +} + +// FlowcontrolV1beta3 indicates an expected call of FlowcontrolV1beta3. +func (mr *MockInterfaceMockRecorder) FlowcontrolV1beta3() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlowcontrolV1beta3", reflect.TypeOf((*MockInterface)(nil).FlowcontrolV1beta3)) +} + +// InternalV1alpha1 mocks base method. +func (m *MockInterface) InternalV1alpha1() v1alpha10.InternalV1alpha1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InternalV1alpha1") + ret0, _ := ret[0].(v1alpha10.InternalV1alpha1Interface) + return ret0 +} + +// InternalV1alpha1 indicates an expected call of InternalV1alpha1. +func (mr *MockInterfaceMockRecorder) InternalV1alpha1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InternalV1alpha1", reflect.TypeOf((*MockInterface)(nil).InternalV1alpha1)) +} + +// NetworkingV1 mocks base method. +func (m *MockInterface) NetworkingV1() v111.NetworkingV1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "NetworkingV1") + ret0, _ := ret[0].(v111.NetworkingV1Interface) + return ret0 +} + +// NetworkingV1 indicates an expected call of NetworkingV1. +func (mr *MockInterfaceMockRecorder) NetworkingV1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkingV1", reflect.TypeOf((*MockInterface)(nil).NetworkingV1)) +} + +// NetworkingV1beta1 mocks base method. +func (m *MockInterface) NetworkingV1beta1() v1beta110.NetworkingV1beta1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "NetworkingV1beta1") + ret0, _ := ret[0].(v1beta110.NetworkingV1beta1Interface) + return ret0 +} + +// NetworkingV1beta1 indicates an expected call of NetworkingV1beta1. +func (mr *MockInterfaceMockRecorder) NetworkingV1beta1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkingV1beta1", reflect.TypeOf((*MockInterface)(nil).NetworkingV1beta1)) +} + +// NodeV1 mocks base method. +func (m *MockInterface) NodeV1() v112.NodeV1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "NodeV1") + ret0, _ := ret[0].(v112.NodeV1Interface) + return ret0 +} + +// NodeV1 indicates an expected call of NodeV1. +func (mr *MockInterfaceMockRecorder) NodeV1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeV1", reflect.TypeOf((*MockInterface)(nil).NodeV1)) +} + +// NodeV1alpha1 mocks base method. +func (m *MockInterface) NodeV1alpha1() v1alpha13.NodeV1alpha1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "NodeV1alpha1") + ret0, _ := ret[0].(v1alpha13.NodeV1alpha1Interface) + return ret0 +} + +// NodeV1alpha1 indicates an expected call of NodeV1alpha1. +func (mr *MockInterfaceMockRecorder) NodeV1alpha1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeV1alpha1", reflect.TypeOf((*MockInterface)(nil).NodeV1alpha1)) +} + +// NodeV1beta1 mocks base method. +func (m *MockInterface) NodeV1beta1() v1beta111.NodeV1beta1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "NodeV1beta1") + ret0, _ := ret[0].(v1beta111.NodeV1beta1Interface) + return ret0 +} + +// NodeV1beta1 indicates an expected call of NodeV1beta1. +func (mr *MockInterfaceMockRecorder) NodeV1beta1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeV1beta1", reflect.TypeOf((*MockInterface)(nil).NodeV1beta1)) +} + +// PolicyV1 mocks base method. +func (m *MockInterface) PolicyV1() v113.PolicyV1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PolicyV1") + ret0, _ := ret[0].(v113.PolicyV1Interface) + return ret0 +} + +// PolicyV1 indicates an expected call of PolicyV1. +func (mr *MockInterfaceMockRecorder) PolicyV1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PolicyV1", reflect.TypeOf((*MockInterface)(nil).PolicyV1)) +} + +// PolicyV1beta1 mocks base method. +func (m *MockInterface) PolicyV1beta1() v1beta112.PolicyV1beta1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PolicyV1beta1") + ret0, _ := ret[0].(v1beta112.PolicyV1beta1Interface) + return ret0 +} + +// PolicyV1beta1 indicates an expected call of PolicyV1beta1. +func (mr *MockInterfaceMockRecorder) PolicyV1beta1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PolicyV1beta1", reflect.TypeOf((*MockInterface)(nil).PolicyV1beta1)) +} + +// RbacV1 mocks base method. +func (m *MockInterface) RbacV1() v114.RbacV1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RbacV1") + ret0, _ := ret[0].(v114.RbacV1Interface) + return ret0 +} + +// RbacV1 indicates an expected call of RbacV1. +func (mr *MockInterfaceMockRecorder) RbacV1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RbacV1", reflect.TypeOf((*MockInterface)(nil).RbacV1)) +} + +// RbacV1alpha1 mocks base method. +func (m *MockInterface) RbacV1alpha1() v1alpha14.RbacV1alpha1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RbacV1alpha1") + ret0, _ := ret[0].(v1alpha14.RbacV1alpha1Interface) + return ret0 +} + +// RbacV1alpha1 indicates an expected call of RbacV1alpha1. +func (mr *MockInterfaceMockRecorder) RbacV1alpha1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RbacV1alpha1", reflect.TypeOf((*MockInterface)(nil).RbacV1alpha1)) +} + +// RbacV1beta1 mocks base method. +func (m *MockInterface) RbacV1beta1() v1beta113.RbacV1beta1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RbacV1beta1") + ret0, _ := ret[0].(v1beta113.RbacV1beta1Interface) + return ret0 +} + +// RbacV1beta1 indicates an expected call of RbacV1beta1. +func (mr *MockInterfaceMockRecorder) RbacV1beta1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RbacV1beta1", reflect.TypeOf((*MockInterface)(nil).RbacV1beta1)) +} + +// ResourceV1 mocks base method. +func (m *MockInterface) ResourceV1() v115.ResourceV1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResourceV1") + ret0, _ := ret[0].(v115.ResourceV1Interface) + return ret0 +} + +// ResourceV1 indicates an expected call of ResourceV1. +func (mr *MockInterfaceMockRecorder) ResourceV1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResourceV1", reflect.TypeOf((*MockInterface)(nil).ResourceV1)) +} + +// ResourceV1alpha3 mocks base method. +func (m *MockInterface) ResourceV1alpha3() v1alpha3.ResourceV1alpha3Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResourceV1alpha3") + ret0, _ := ret[0].(v1alpha3.ResourceV1alpha3Interface) + return ret0 +} + +// ResourceV1alpha3 indicates an expected call of ResourceV1alpha3. +func (mr *MockInterfaceMockRecorder) ResourceV1alpha3() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResourceV1alpha3", reflect.TypeOf((*MockInterface)(nil).ResourceV1alpha3)) +} + +// ResourceV1beta1 mocks base method. +func (m *MockInterface) ResourceV1beta1() v1beta114.ResourceV1beta1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResourceV1beta1") + ret0, _ := ret[0].(v1beta114.ResourceV1beta1Interface) + return ret0 +} + +// ResourceV1beta1 indicates an expected call of ResourceV1beta1. +func (mr *MockInterfaceMockRecorder) ResourceV1beta1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResourceV1beta1", reflect.TypeOf((*MockInterface)(nil).ResourceV1beta1)) +} + +// ResourceV1beta2 mocks base method. +func (m *MockInterface) ResourceV1beta2() v1beta21.ResourceV1beta2Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResourceV1beta2") + ret0, _ := ret[0].(v1beta21.ResourceV1beta2Interface) + return ret0 +} + +// ResourceV1beta2 indicates an expected call of ResourceV1beta2. +func (mr *MockInterfaceMockRecorder) ResourceV1beta2() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResourceV1beta2", reflect.TypeOf((*MockInterface)(nil).ResourceV1beta2)) +} + +// SchedulingV1 mocks base method. +func (m *MockInterface) SchedulingV1() v116.SchedulingV1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SchedulingV1") + ret0, _ := ret[0].(v116.SchedulingV1Interface) + return ret0 +} + +// SchedulingV1 indicates an expected call of SchedulingV1. +func (mr *MockInterfaceMockRecorder) SchedulingV1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SchedulingV1", reflect.TypeOf((*MockInterface)(nil).SchedulingV1)) +} + +// SchedulingV1alpha1 mocks base method. +func (m *MockInterface) SchedulingV1alpha1() v1alpha15.SchedulingV1alpha1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SchedulingV1alpha1") + ret0, _ := ret[0].(v1alpha15.SchedulingV1alpha1Interface) + return ret0 +} + +// SchedulingV1alpha1 indicates an expected call of SchedulingV1alpha1. +func (mr *MockInterfaceMockRecorder) SchedulingV1alpha1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SchedulingV1alpha1", reflect.TypeOf((*MockInterface)(nil).SchedulingV1alpha1)) +} + +// SchedulingV1beta1 mocks base method. +func (m *MockInterface) SchedulingV1beta1() v1beta115.SchedulingV1beta1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SchedulingV1beta1") + ret0, _ := ret[0].(v1beta115.SchedulingV1beta1Interface) + return ret0 +} + +// SchedulingV1beta1 indicates an expected call of SchedulingV1beta1. +func (mr *MockInterfaceMockRecorder) SchedulingV1beta1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SchedulingV1beta1", reflect.TypeOf((*MockInterface)(nil).SchedulingV1beta1)) +} + +// StorageV1 mocks base method. +func (m *MockInterface) StorageV1() v117.StorageV1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StorageV1") + ret0, _ := ret[0].(v117.StorageV1Interface) + return ret0 +} + +// StorageV1 indicates an expected call of StorageV1. +func (mr *MockInterfaceMockRecorder) StorageV1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageV1", reflect.TypeOf((*MockInterface)(nil).StorageV1)) +} + +// StorageV1alpha1 mocks base method. +func (m *MockInterface) StorageV1alpha1() v1alpha16.StorageV1alpha1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StorageV1alpha1") + ret0, _ := ret[0].(v1alpha16.StorageV1alpha1Interface) + return ret0 +} + +// StorageV1alpha1 indicates an expected call of StorageV1alpha1. +func (mr *MockInterfaceMockRecorder) StorageV1alpha1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageV1alpha1", reflect.TypeOf((*MockInterface)(nil).StorageV1alpha1)) +} + +// StorageV1beta1 mocks base method. +func (m *MockInterface) StorageV1beta1() v1beta116.StorageV1beta1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StorageV1beta1") + ret0, _ := ret[0].(v1beta116.StorageV1beta1Interface) + return ret0 +} + +// StorageV1beta1 indicates an expected call of StorageV1beta1. +func (mr *MockInterfaceMockRecorder) StorageV1beta1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageV1beta1", reflect.TypeOf((*MockInterface)(nil).StorageV1beta1)) +} + +// StoragemigrationV1alpha1 mocks base method. +func (m *MockInterface) StoragemigrationV1alpha1() v1alpha17.StoragemigrationV1alpha1Interface { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StoragemigrationV1alpha1") + ret0, _ := ret[0].(v1alpha17.StoragemigrationV1alpha1Interface) + return ret0 +} + +// StoragemigrationV1alpha1 indicates an expected call of StoragemigrationV1alpha1. +func (mr *MockInterfaceMockRecorder) StoragemigrationV1alpha1() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoragemigrationV1alpha1", reflect.TypeOf((*MockInterface)(nil).StoragemigrationV1alpha1)) +} diff --git a/pkg/providers/kubernetesversion/kubernetesversion_test.go b/pkg/providers/kubernetesversion/kubernetesversion_test.go new file mode 100644 index 0000000..863a133 --- /dev/null +++ b/pkg/providers/kubernetesversion/kubernetesversion_test.go @@ -0,0 +1,114 @@ +package kubernetesversion + +import ( + "context" + + "testing" + "time" + + "github.com/absaoss/karpenter-provider-vsphere/pkg/mocks" + "github.com/patrickmn/go-cache" + "github.com/stretchr/testify/assert" + "go.uber.org/mock/gomock" + "k8s.io/apimachinery/pkg/version" + _ "k8s.io/client-go/kubernetes" +) + +func TestKubeServerVersion(t *testing.T) { + // arrange + controller := gomock.NewController(t) // initialize mock controller + defer controller.Finish() // ensure resources are cleaned up + + v := version.Info{GitVersion: "v1.2.3+rke2r1"} + q := mocks.NewMockInterface(controller) + d := mocks.NewMockDiscoveryInterface(controller) + d.EXPECT().ServerVersion().Return(&v, nil).AnyTimes() + + q.EXPECT().Discovery().Return(d).AnyTimes() + + c := cache.New(time.Second*10, time.Second*2) + provider := NewKubernetesVersionProvider(q, c) + // act + str, err := provider.KubeServerVersion(context.TODO()) + + // assert + assert.NoError(t, err) + assert.Equal(t, "1.2.3", str) +} + +func TestKubeServerVersions(t *testing.T) { + var tests = []struct { + name string + expectedError bool + version *version.Info + expectedVersion string + discoveryError error + }{ + { + name: "valid version", + expectedError: false, + version: &version.Info{GitVersion: "v1.20.4+rke2r1"}, + expectedVersion: "1.20.4", + }, + { + name: "valid version without prefix", + expectedError: false, + version: &version.Info{GitVersion: "1.21.0"}, + expectedVersion: "1.21.0", + }, + { + name: "valid version with different suffix", + expectedError: false, + version: &version.Info{GitVersion: "v1.22.1+customsuffix"}, + expectedVersion: "1.22.1+customsuffix", + }, + { + name: "empty version", + expectedError: false, + version: &version.Info{GitVersion: ""}, + expectedVersion: "", + }, + { + name: "discovery error", + expectedError: true, + version: nil, + discoveryError: assert.AnError, + }, + { + name: "funny version", + expectedError: false, + version: &version.Info{GitVersion: "!!@@##???"}, + expectedVersion: "!!@@##???", + }, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + // arrange + controller := gomock.NewController(t) // initialize mock controller + defer controller.Finish() // ensure resources are cleaned up + + q := mocks.NewMockInterface(controller) + d := mocks.NewMockDiscoveryInterface(controller) + d.EXPECT().ServerVersion().Return(test.version, test.discoveryError).AnyTimes() + + q.EXPECT().Discovery().Return(d).AnyTimes() + + c := cache.New(time.Second*10, time.Second*2) + provider := NewKubernetesVersionProvider(q, c) + + // act + str, err := provider.KubeServerVersion(context.TODO()) + + // assert + if test.expectedError { + assert.Error(t, err) + return + } + + assert.NoError(t, err) // ensure no error occurred + assert.Equal(t, test.expectedVersion, str) // verify the version matches expected + + }) + } +} diff --git a/taskfile.yaml b/taskfile.yaml new file mode 100644 index 0000000..aceb2c9 --- /dev/null +++ b/taskfile.yaml @@ -0,0 +1,15 @@ +--- +version: '3' +interval: '1500ms' +# env: +# LOCALBIN: /bin +# TFENV_TERRAFORM_VERSION: 1.5.7 + +# dotenv: ['.env'] + +tasks: + mocks: + cmds: + - go install go.uber.org/mock/mockgen@v0.6.0 + - $(go env GOPATH)/bin/mockgen -package=mocks -destination=pkg/mocks/interface_mock.go k8s.io/client-go/kubernetes Interface + - $(go env GOPATH)/bin/mockgen -package=mocks -destination=pkg/mocks/discovery_mock.go k8s.io/client-go/discovery DiscoveryInterface \ No newline at end of file