mirror of https://github.com/rancher/wrangler.git
1461 lines
58 KiB
Go
1461 lines
58 KiB
Go
// Code generated by MockGen. DO NOT EDIT.
|
|
// Source: ../controller.go
|
|
//
|
|
// Generated by this command:
|
|
//
|
|
// mockgen -package fake -destination ./controller.go -source ../controller.go
|
|
//
|
|
|
|
// Package fake is a generated GoMock package.
|
|
package fake
|
|
|
|
import (
|
|
context "context"
|
|
reflect "reflect"
|
|
time "time"
|
|
|
|
generic "github.com/rancher/wrangler/v3/pkg/generic"
|
|
gomock "go.uber.org/mock/gomock"
|
|
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
runtime "k8s.io/apimachinery/pkg/runtime"
|
|
schema "k8s.io/apimachinery/pkg/runtime/schema"
|
|
types "k8s.io/apimachinery/pkg/types"
|
|
watch "k8s.io/apimachinery/pkg/watch"
|
|
rest "k8s.io/client-go/rest"
|
|
cache "k8s.io/client-go/tools/cache"
|
|
)
|
|
|
|
// MockControllerMeta is a mock of ControllerMeta interface.
|
|
type MockControllerMeta struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockControllerMetaMockRecorder
|
|
}
|
|
|
|
// MockControllerMetaMockRecorder is the mock recorder for MockControllerMeta.
|
|
type MockControllerMetaMockRecorder struct {
|
|
mock *MockControllerMeta
|
|
}
|
|
|
|
// NewMockControllerMeta creates a new mock instance.
|
|
func NewMockControllerMeta(ctrl *gomock.Controller) *MockControllerMeta {
|
|
mock := &MockControllerMeta{ctrl: ctrl}
|
|
mock.recorder = &MockControllerMetaMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockControllerMeta) EXPECT() *MockControllerMetaMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// AddGenericHandler mocks base method.
|
|
func (m *MockControllerMeta) AddGenericHandler(ctx context.Context, name string, handler generic.Handler) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "AddGenericHandler", ctx, name, handler)
|
|
}
|
|
|
|
// AddGenericHandler indicates an expected call of AddGenericHandler.
|
|
func (mr *MockControllerMetaMockRecorder) AddGenericHandler(ctx, name, handler any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddGenericHandler", reflect.TypeOf((*MockControllerMeta)(nil).AddGenericHandler), ctx, name, handler)
|
|
}
|
|
|
|
// AddGenericRemoveHandler mocks base method.
|
|
func (m *MockControllerMeta) AddGenericRemoveHandler(ctx context.Context, name string, handler generic.Handler) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "AddGenericRemoveHandler", ctx, name, handler)
|
|
}
|
|
|
|
// AddGenericRemoveHandler indicates an expected call of AddGenericRemoveHandler.
|
|
func (mr *MockControllerMetaMockRecorder) AddGenericRemoveHandler(ctx, name, handler any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddGenericRemoveHandler", reflect.TypeOf((*MockControllerMeta)(nil).AddGenericRemoveHandler), ctx, name, handler)
|
|
}
|
|
|
|
// GroupVersionKind mocks base method.
|
|
func (m *MockControllerMeta) GroupVersionKind() schema.GroupVersionKind {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GroupVersionKind")
|
|
ret0, _ := ret[0].(schema.GroupVersionKind)
|
|
return ret0
|
|
}
|
|
|
|
// GroupVersionKind indicates an expected call of GroupVersionKind.
|
|
func (mr *MockControllerMetaMockRecorder) GroupVersionKind() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GroupVersionKind", reflect.TypeOf((*MockControllerMeta)(nil).GroupVersionKind))
|
|
}
|
|
|
|
// Informer mocks base method.
|
|
func (m *MockControllerMeta) Informer() cache.SharedIndexInformer {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Informer")
|
|
ret0, _ := ret[0].(cache.SharedIndexInformer)
|
|
return ret0
|
|
}
|
|
|
|
// Informer indicates an expected call of Informer.
|
|
func (mr *MockControllerMetaMockRecorder) Informer() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Informer", reflect.TypeOf((*MockControllerMeta)(nil).Informer))
|
|
}
|
|
|
|
// Updater mocks base method.
|
|
func (m *MockControllerMeta) Updater() generic.Updater {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Updater")
|
|
ret0, _ := ret[0].(generic.Updater)
|
|
return ret0
|
|
}
|
|
|
|
// Updater indicates an expected call of Updater.
|
|
func (mr *MockControllerMetaMockRecorder) Updater() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Updater", reflect.TypeOf((*MockControllerMeta)(nil).Updater))
|
|
}
|
|
|
|
// MockRuntimeMetaObject is a mock of RuntimeMetaObject interface.
|
|
type MockRuntimeMetaObject struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockRuntimeMetaObjectMockRecorder
|
|
}
|
|
|
|
// MockRuntimeMetaObjectMockRecorder is the mock recorder for MockRuntimeMetaObject.
|
|
type MockRuntimeMetaObjectMockRecorder struct {
|
|
mock *MockRuntimeMetaObject
|
|
}
|
|
|
|
// NewMockRuntimeMetaObject creates a new mock instance.
|
|
func NewMockRuntimeMetaObject(ctrl *gomock.Controller) *MockRuntimeMetaObject {
|
|
mock := &MockRuntimeMetaObject{ctrl: ctrl}
|
|
mock.recorder = &MockRuntimeMetaObjectMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockRuntimeMetaObject) EXPECT() *MockRuntimeMetaObjectMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// DeepCopyObject mocks base method.
|
|
func (m *MockRuntimeMetaObject) DeepCopyObject() runtime.Object {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DeepCopyObject")
|
|
ret0, _ := ret[0].(runtime.Object)
|
|
return ret0
|
|
}
|
|
|
|
// DeepCopyObject indicates an expected call of DeepCopyObject.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) DeepCopyObject() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeepCopyObject", reflect.TypeOf((*MockRuntimeMetaObject)(nil).DeepCopyObject))
|
|
}
|
|
|
|
// GetAnnotations mocks base method.
|
|
func (m *MockRuntimeMetaObject) GetAnnotations() map[string]string {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetAnnotations")
|
|
ret0, _ := ret[0].(map[string]string)
|
|
return ret0
|
|
}
|
|
|
|
// GetAnnotations indicates an expected call of GetAnnotations.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) GetAnnotations() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAnnotations", reflect.TypeOf((*MockRuntimeMetaObject)(nil).GetAnnotations))
|
|
}
|
|
|
|
// GetCreationTimestamp mocks base method.
|
|
func (m *MockRuntimeMetaObject) GetCreationTimestamp() v1.Time {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetCreationTimestamp")
|
|
ret0, _ := ret[0].(v1.Time)
|
|
return ret0
|
|
}
|
|
|
|
// GetCreationTimestamp indicates an expected call of GetCreationTimestamp.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) GetCreationTimestamp() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCreationTimestamp", reflect.TypeOf((*MockRuntimeMetaObject)(nil).GetCreationTimestamp))
|
|
}
|
|
|
|
// GetDeletionGracePeriodSeconds mocks base method.
|
|
func (m *MockRuntimeMetaObject) GetDeletionGracePeriodSeconds() *int64 {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetDeletionGracePeriodSeconds")
|
|
ret0, _ := ret[0].(*int64)
|
|
return ret0
|
|
}
|
|
|
|
// GetDeletionGracePeriodSeconds indicates an expected call of GetDeletionGracePeriodSeconds.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) GetDeletionGracePeriodSeconds() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeletionGracePeriodSeconds", reflect.TypeOf((*MockRuntimeMetaObject)(nil).GetDeletionGracePeriodSeconds))
|
|
}
|
|
|
|
// GetDeletionTimestamp mocks base method.
|
|
func (m *MockRuntimeMetaObject) GetDeletionTimestamp() *v1.Time {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetDeletionTimestamp")
|
|
ret0, _ := ret[0].(*v1.Time)
|
|
return ret0
|
|
}
|
|
|
|
// GetDeletionTimestamp indicates an expected call of GetDeletionTimestamp.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) GetDeletionTimestamp() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeletionTimestamp", reflect.TypeOf((*MockRuntimeMetaObject)(nil).GetDeletionTimestamp))
|
|
}
|
|
|
|
// GetFinalizers mocks base method.
|
|
func (m *MockRuntimeMetaObject) GetFinalizers() []string {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetFinalizers")
|
|
ret0, _ := ret[0].([]string)
|
|
return ret0
|
|
}
|
|
|
|
// GetFinalizers indicates an expected call of GetFinalizers.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) GetFinalizers() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFinalizers", reflect.TypeOf((*MockRuntimeMetaObject)(nil).GetFinalizers))
|
|
}
|
|
|
|
// GetGenerateName mocks base method.
|
|
func (m *MockRuntimeMetaObject) GetGenerateName() string {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetGenerateName")
|
|
ret0, _ := ret[0].(string)
|
|
return ret0
|
|
}
|
|
|
|
// GetGenerateName indicates an expected call of GetGenerateName.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) GetGenerateName() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGenerateName", reflect.TypeOf((*MockRuntimeMetaObject)(nil).GetGenerateName))
|
|
}
|
|
|
|
// GetGeneration mocks base method.
|
|
func (m *MockRuntimeMetaObject) GetGeneration() int64 {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetGeneration")
|
|
ret0, _ := ret[0].(int64)
|
|
return ret0
|
|
}
|
|
|
|
// GetGeneration indicates an expected call of GetGeneration.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) GetGeneration() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGeneration", reflect.TypeOf((*MockRuntimeMetaObject)(nil).GetGeneration))
|
|
}
|
|
|
|
// GetLabels mocks base method.
|
|
func (m *MockRuntimeMetaObject) GetLabels() map[string]string {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetLabels")
|
|
ret0, _ := ret[0].(map[string]string)
|
|
return ret0
|
|
}
|
|
|
|
// GetLabels indicates an expected call of GetLabels.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) GetLabels() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLabels", reflect.TypeOf((*MockRuntimeMetaObject)(nil).GetLabels))
|
|
}
|
|
|
|
// GetManagedFields mocks base method.
|
|
func (m *MockRuntimeMetaObject) GetManagedFields() []v1.ManagedFieldsEntry {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetManagedFields")
|
|
ret0, _ := ret[0].([]v1.ManagedFieldsEntry)
|
|
return ret0
|
|
}
|
|
|
|
// GetManagedFields indicates an expected call of GetManagedFields.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) GetManagedFields() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedFields", reflect.TypeOf((*MockRuntimeMetaObject)(nil).GetManagedFields))
|
|
}
|
|
|
|
// GetName mocks base method.
|
|
func (m *MockRuntimeMetaObject) GetName() string {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetName")
|
|
ret0, _ := ret[0].(string)
|
|
return ret0
|
|
}
|
|
|
|
// GetName indicates an expected call of GetName.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) GetName() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetName", reflect.TypeOf((*MockRuntimeMetaObject)(nil).GetName))
|
|
}
|
|
|
|
// GetNamespace mocks base method.
|
|
func (m *MockRuntimeMetaObject) GetNamespace() string {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetNamespace")
|
|
ret0, _ := ret[0].(string)
|
|
return ret0
|
|
}
|
|
|
|
// GetNamespace indicates an expected call of GetNamespace.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) GetNamespace() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespace", reflect.TypeOf((*MockRuntimeMetaObject)(nil).GetNamespace))
|
|
}
|
|
|
|
// GetObjectKind mocks base method.
|
|
func (m *MockRuntimeMetaObject) GetObjectKind() schema.ObjectKind {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetObjectKind")
|
|
ret0, _ := ret[0].(schema.ObjectKind)
|
|
return ret0
|
|
}
|
|
|
|
// GetObjectKind indicates an expected call of GetObjectKind.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) GetObjectKind() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectKind", reflect.TypeOf((*MockRuntimeMetaObject)(nil).GetObjectKind))
|
|
}
|
|
|
|
// GetOwnerReferences mocks base method.
|
|
func (m *MockRuntimeMetaObject) GetOwnerReferences() []v1.OwnerReference {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetOwnerReferences")
|
|
ret0, _ := ret[0].([]v1.OwnerReference)
|
|
return ret0
|
|
}
|
|
|
|
// GetOwnerReferences indicates an expected call of GetOwnerReferences.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) GetOwnerReferences() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOwnerReferences", reflect.TypeOf((*MockRuntimeMetaObject)(nil).GetOwnerReferences))
|
|
}
|
|
|
|
// GetResourceVersion mocks base method.
|
|
func (m *MockRuntimeMetaObject) GetResourceVersion() string {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetResourceVersion")
|
|
ret0, _ := ret[0].(string)
|
|
return ret0
|
|
}
|
|
|
|
// GetResourceVersion indicates an expected call of GetResourceVersion.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) GetResourceVersion() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourceVersion", reflect.TypeOf((*MockRuntimeMetaObject)(nil).GetResourceVersion))
|
|
}
|
|
|
|
// GetSelfLink mocks base method.
|
|
func (m *MockRuntimeMetaObject) GetSelfLink() string {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetSelfLink")
|
|
ret0, _ := ret[0].(string)
|
|
return ret0
|
|
}
|
|
|
|
// GetSelfLink indicates an expected call of GetSelfLink.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) GetSelfLink() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSelfLink", reflect.TypeOf((*MockRuntimeMetaObject)(nil).GetSelfLink))
|
|
}
|
|
|
|
// GetUID mocks base method.
|
|
func (m *MockRuntimeMetaObject) GetUID() types.UID {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetUID")
|
|
ret0, _ := ret[0].(types.UID)
|
|
return ret0
|
|
}
|
|
|
|
// GetUID indicates an expected call of GetUID.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) GetUID() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUID", reflect.TypeOf((*MockRuntimeMetaObject)(nil).GetUID))
|
|
}
|
|
|
|
// SetAnnotations mocks base method.
|
|
func (m *MockRuntimeMetaObject) SetAnnotations(annotations map[string]string) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetAnnotations", annotations)
|
|
}
|
|
|
|
// SetAnnotations indicates an expected call of SetAnnotations.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) SetAnnotations(annotations any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAnnotations", reflect.TypeOf((*MockRuntimeMetaObject)(nil).SetAnnotations), annotations)
|
|
}
|
|
|
|
// SetCreationTimestamp mocks base method.
|
|
func (m *MockRuntimeMetaObject) SetCreationTimestamp(timestamp v1.Time) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetCreationTimestamp", timestamp)
|
|
}
|
|
|
|
// SetCreationTimestamp indicates an expected call of SetCreationTimestamp.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) SetCreationTimestamp(timestamp any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreationTimestamp", reflect.TypeOf((*MockRuntimeMetaObject)(nil).SetCreationTimestamp), timestamp)
|
|
}
|
|
|
|
// SetDeletionGracePeriodSeconds mocks base method.
|
|
func (m *MockRuntimeMetaObject) SetDeletionGracePeriodSeconds(arg0 *int64) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetDeletionGracePeriodSeconds", arg0)
|
|
}
|
|
|
|
// SetDeletionGracePeriodSeconds indicates an expected call of SetDeletionGracePeriodSeconds.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) SetDeletionGracePeriodSeconds(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDeletionGracePeriodSeconds", reflect.TypeOf((*MockRuntimeMetaObject)(nil).SetDeletionGracePeriodSeconds), arg0)
|
|
}
|
|
|
|
// SetDeletionTimestamp mocks base method.
|
|
func (m *MockRuntimeMetaObject) SetDeletionTimestamp(timestamp *v1.Time) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetDeletionTimestamp", timestamp)
|
|
}
|
|
|
|
// SetDeletionTimestamp indicates an expected call of SetDeletionTimestamp.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) SetDeletionTimestamp(timestamp any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDeletionTimestamp", reflect.TypeOf((*MockRuntimeMetaObject)(nil).SetDeletionTimestamp), timestamp)
|
|
}
|
|
|
|
// SetFinalizers mocks base method.
|
|
func (m *MockRuntimeMetaObject) SetFinalizers(finalizers []string) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetFinalizers", finalizers)
|
|
}
|
|
|
|
// SetFinalizers indicates an expected call of SetFinalizers.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) SetFinalizers(finalizers any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFinalizers", reflect.TypeOf((*MockRuntimeMetaObject)(nil).SetFinalizers), finalizers)
|
|
}
|
|
|
|
// SetGenerateName mocks base method.
|
|
func (m *MockRuntimeMetaObject) SetGenerateName(name string) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetGenerateName", name)
|
|
}
|
|
|
|
// SetGenerateName indicates an expected call of SetGenerateName.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) SetGenerateName(name any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGenerateName", reflect.TypeOf((*MockRuntimeMetaObject)(nil).SetGenerateName), name)
|
|
}
|
|
|
|
// SetGeneration mocks base method.
|
|
func (m *MockRuntimeMetaObject) SetGeneration(generation int64) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetGeneration", generation)
|
|
}
|
|
|
|
// SetGeneration indicates an expected call of SetGeneration.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) SetGeneration(generation any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGeneration", reflect.TypeOf((*MockRuntimeMetaObject)(nil).SetGeneration), generation)
|
|
}
|
|
|
|
// SetLabels mocks base method.
|
|
func (m *MockRuntimeMetaObject) SetLabels(labels map[string]string) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetLabels", labels)
|
|
}
|
|
|
|
// SetLabels indicates an expected call of SetLabels.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) SetLabels(labels any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLabels", reflect.TypeOf((*MockRuntimeMetaObject)(nil).SetLabels), labels)
|
|
}
|
|
|
|
// SetManagedFields mocks base method.
|
|
func (m *MockRuntimeMetaObject) SetManagedFields(managedFields []v1.ManagedFieldsEntry) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetManagedFields", managedFields)
|
|
}
|
|
|
|
// SetManagedFields indicates an expected call of SetManagedFields.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) SetManagedFields(managedFields any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetManagedFields", reflect.TypeOf((*MockRuntimeMetaObject)(nil).SetManagedFields), managedFields)
|
|
}
|
|
|
|
// SetName mocks base method.
|
|
func (m *MockRuntimeMetaObject) SetName(name string) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetName", name)
|
|
}
|
|
|
|
// SetName indicates an expected call of SetName.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) SetName(name any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetName", reflect.TypeOf((*MockRuntimeMetaObject)(nil).SetName), name)
|
|
}
|
|
|
|
// SetNamespace mocks base method.
|
|
func (m *MockRuntimeMetaObject) SetNamespace(namespace string) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetNamespace", namespace)
|
|
}
|
|
|
|
// SetNamespace indicates an expected call of SetNamespace.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) SetNamespace(namespace any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNamespace", reflect.TypeOf((*MockRuntimeMetaObject)(nil).SetNamespace), namespace)
|
|
}
|
|
|
|
// SetOwnerReferences mocks base method.
|
|
func (m *MockRuntimeMetaObject) SetOwnerReferences(arg0 []v1.OwnerReference) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetOwnerReferences", arg0)
|
|
}
|
|
|
|
// SetOwnerReferences indicates an expected call of SetOwnerReferences.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) SetOwnerReferences(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetOwnerReferences", reflect.TypeOf((*MockRuntimeMetaObject)(nil).SetOwnerReferences), arg0)
|
|
}
|
|
|
|
// SetResourceVersion mocks base method.
|
|
func (m *MockRuntimeMetaObject) SetResourceVersion(version string) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetResourceVersion", version)
|
|
}
|
|
|
|
// SetResourceVersion indicates an expected call of SetResourceVersion.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) SetResourceVersion(version any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetResourceVersion", reflect.TypeOf((*MockRuntimeMetaObject)(nil).SetResourceVersion), version)
|
|
}
|
|
|
|
// SetSelfLink mocks base method.
|
|
func (m *MockRuntimeMetaObject) SetSelfLink(selfLink string) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetSelfLink", selfLink)
|
|
}
|
|
|
|
// SetSelfLink indicates an expected call of SetSelfLink.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) SetSelfLink(selfLink any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSelfLink", reflect.TypeOf((*MockRuntimeMetaObject)(nil).SetSelfLink), selfLink)
|
|
}
|
|
|
|
// SetUID mocks base method.
|
|
func (m *MockRuntimeMetaObject) SetUID(uid types.UID) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetUID", uid)
|
|
}
|
|
|
|
// SetUID indicates an expected call of SetUID.
|
|
func (mr *MockRuntimeMetaObjectMockRecorder) SetUID(uid any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUID", reflect.TypeOf((*MockRuntimeMetaObject)(nil).SetUID), uid)
|
|
}
|
|
|
|
// MockControllerInterface is a mock of ControllerInterface interface.
|
|
type MockControllerInterface[T generic.RuntimeMetaObject, TList runtime.Object] struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockControllerInterfaceMockRecorder[T, TList]
|
|
}
|
|
|
|
// MockControllerInterfaceMockRecorder is the mock recorder for MockControllerInterface.
|
|
type MockControllerInterfaceMockRecorder[T generic.RuntimeMetaObject, TList runtime.Object] struct {
|
|
mock *MockControllerInterface[T, TList]
|
|
}
|
|
|
|
// NewMockControllerInterface creates a new mock instance.
|
|
func NewMockControllerInterface[T generic.RuntimeMetaObject, TList runtime.Object](ctrl *gomock.Controller) *MockControllerInterface[T, TList] {
|
|
mock := &MockControllerInterface[T, TList]{ctrl: ctrl}
|
|
mock.recorder = &MockControllerInterfaceMockRecorder[T, TList]{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockControllerInterface[T, TList]) EXPECT() *MockControllerInterfaceMockRecorder[T, TList] {
|
|
return m.recorder
|
|
}
|
|
|
|
// AddGenericHandler mocks base method.
|
|
func (m *MockControllerInterface[T, TList]) AddGenericHandler(ctx context.Context, name string, handler generic.Handler) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "AddGenericHandler", ctx, name, handler)
|
|
}
|
|
|
|
// AddGenericHandler indicates an expected call of AddGenericHandler.
|
|
func (mr *MockControllerInterfaceMockRecorder[T, TList]) AddGenericHandler(ctx, name, handler any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddGenericHandler", reflect.TypeOf((*MockControllerInterface[T, TList])(nil).AddGenericHandler), ctx, name, handler)
|
|
}
|
|
|
|
// AddGenericRemoveHandler mocks base method.
|
|
func (m *MockControllerInterface[T, TList]) AddGenericRemoveHandler(ctx context.Context, name string, handler generic.Handler) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "AddGenericRemoveHandler", ctx, name, handler)
|
|
}
|
|
|
|
// AddGenericRemoveHandler indicates an expected call of AddGenericRemoveHandler.
|
|
func (mr *MockControllerInterfaceMockRecorder[T, TList]) AddGenericRemoveHandler(ctx, name, handler any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddGenericRemoveHandler", reflect.TypeOf((*MockControllerInterface[T, TList])(nil).AddGenericRemoveHandler), ctx, name, handler)
|
|
}
|
|
|
|
// Cache mocks base method.
|
|
func (m *MockControllerInterface[T, TList]) Cache() generic.CacheInterface[T] {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Cache")
|
|
ret0, _ := ret[0].(generic.CacheInterface[T])
|
|
return ret0
|
|
}
|
|
|
|
// Cache indicates an expected call of Cache.
|
|
func (mr *MockControllerInterfaceMockRecorder[T, TList]) Cache() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cache", reflect.TypeOf((*MockControllerInterface[T, TList])(nil).Cache))
|
|
}
|
|
|
|
// Create mocks base method.
|
|
func (m *MockControllerInterface[T, TList]) Create(arg0 T) (T, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Create", arg0)
|
|
ret0, _ := ret[0].(T)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Create indicates an expected call of Create.
|
|
func (mr *MockControllerInterfaceMockRecorder[T, TList]) Create(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockControllerInterface[T, TList])(nil).Create), arg0)
|
|
}
|
|
|
|
// Delete mocks base method.
|
|
func (m *MockControllerInterface[T, TList]) Delete(namespace, name string, options *v1.DeleteOptions) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Delete", namespace, name, options)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Delete indicates an expected call of Delete.
|
|
func (mr *MockControllerInterfaceMockRecorder[T, TList]) Delete(namespace, name, options any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockControllerInterface[T, TList])(nil).Delete), namespace, name, options)
|
|
}
|
|
|
|
// Enqueue mocks base method.
|
|
func (m *MockControllerInterface[T, TList]) Enqueue(namespace, name string) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "Enqueue", namespace, name)
|
|
}
|
|
|
|
// Enqueue indicates an expected call of Enqueue.
|
|
func (mr *MockControllerInterfaceMockRecorder[T, TList]) Enqueue(namespace, name any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Enqueue", reflect.TypeOf((*MockControllerInterface[T, TList])(nil).Enqueue), namespace, name)
|
|
}
|
|
|
|
// EnqueueAfter mocks base method.
|
|
func (m *MockControllerInterface[T, TList]) EnqueueAfter(namespace, name string, duration time.Duration) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "EnqueueAfter", namespace, name, duration)
|
|
}
|
|
|
|
// EnqueueAfter indicates an expected call of EnqueueAfter.
|
|
func (mr *MockControllerInterfaceMockRecorder[T, TList]) EnqueueAfter(namespace, name, duration any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnqueueAfter", reflect.TypeOf((*MockControllerInterface[T, TList])(nil).EnqueueAfter), namespace, name, duration)
|
|
}
|
|
|
|
// Get mocks base method.
|
|
func (m *MockControllerInterface[T, TList]) Get(namespace, name string, options v1.GetOptions) (T, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Get", namespace, name, options)
|
|
ret0, _ := ret[0].(T)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Get indicates an expected call of Get.
|
|
func (mr *MockControllerInterfaceMockRecorder[T, TList]) Get(namespace, name, options any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockControllerInterface[T, TList])(nil).Get), namespace, name, options)
|
|
}
|
|
|
|
// GroupVersionKind mocks base method.
|
|
func (m *MockControllerInterface[T, TList]) GroupVersionKind() schema.GroupVersionKind {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GroupVersionKind")
|
|
ret0, _ := ret[0].(schema.GroupVersionKind)
|
|
return ret0
|
|
}
|
|
|
|
// GroupVersionKind indicates an expected call of GroupVersionKind.
|
|
func (mr *MockControllerInterfaceMockRecorder[T, TList]) GroupVersionKind() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GroupVersionKind", reflect.TypeOf((*MockControllerInterface[T, TList])(nil).GroupVersionKind))
|
|
}
|
|
|
|
// Informer mocks base method.
|
|
func (m *MockControllerInterface[T, TList]) Informer() cache.SharedIndexInformer {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Informer")
|
|
ret0, _ := ret[0].(cache.SharedIndexInformer)
|
|
return ret0
|
|
}
|
|
|
|
// Informer indicates an expected call of Informer.
|
|
func (mr *MockControllerInterfaceMockRecorder[T, TList]) Informer() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Informer", reflect.TypeOf((*MockControllerInterface[T, TList])(nil).Informer))
|
|
}
|
|
|
|
// List mocks base method.
|
|
func (m *MockControllerInterface[T, TList]) List(namespace string, opts v1.ListOptions) (TList, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "List", namespace, opts)
|
|
ret0, _ := ret[0].(TList)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// List indicates an expected call of List.
|
|
func (mr *MockControllerInterfaceMockRecorder[T, TList]) List(namespace, opts any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockControllerInterface[T, TList])(nil).List), namespace, opts)
|
|
}
|
|
|
|
// OnChange mocks base method.
|
|
func (m *MockControllerInterface[T, TList]) OnChange(ctx context.Context, name string, sync generic.ObjectHandler[T]) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "OnChange", ctx, name, sync)
|
|
}
|
|
|
|
// OnChange indicates an expected call of OnChange.
|
|
func (mr *MockControllerInterfaceMockRecorder[T, TList]) OnChange(ctx, name, sync any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnChange", reflect.TypeOf((*MockControllerInterface[T, TList])(nil).OnChange), ctx, name, sync)
|
|
}
|
|
|
|
// OnRemove mocks base method.
|
|
func (m *MockControllerInterface[T, TList]) OnRemove(ctx context.Context, name string, sync generic.ObjectHandler[T]) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "OnRemove", ctx, name, sync)
|
|
}
|
|
|
|
// OnRemove indicates an expected call of OnRemove.
|
|
func (mr *MockControllerInterfaceMockRecorder[T, TList]) OnRemove(ctx, name, sync any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnRemove", reflect.TypeOf((*MockControllerInterface[T, TList])(nil).OnRemove), ctx, name, sync)
|
|
}
|
|
|
|
// Patch mocks base method.
|
|
func (m *MockControllerInterface[T, TList]) Patch(namespace, name string, pt types.PatchType, data []byte, subresources ...string) (T, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []any{namespace, name, pt, data}
|
|
for _, a := range subresources {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "Patch", varargs...)
|
|
ret0, _ := ret[0].(T)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Patch indicates an expected call of Patch.
|
|
func (mr *MockControllerInterfaceMockRecorder[T, TList]) Patch(namespace, name, pt, data any, subresources ...any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]any{namespace, name, pt, data}, subresources...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Patch", reflect.TypeOf((*MockControllerInterface[T, TList])(nil).Patch), varargs...)
|
|
}
|
|
|
|
// Update mocks base method.
|
|
func (m *MockControllerInterface[T, TList]) Update(arg0 T) (T, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Update", arg0)
|
|
ret0, _ := ret[0].(T)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Update indicates an expected call of Update.
|
|
func (mr *MockControllerInterfaceMockRecorder[T, TList]) Update(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockControllerInterface[T, TList])(nil).Update), arg0)
|
|
}
|
|
|
|
// UpdateStatus mocks base method.
|
|
func (m *MockControllerInterface[T, TList]) UpdateStatus(arg0 T) (T, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateStatus", arg0)
|
|
ret0, _ := ret[0].(T)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// UpdateStatus indicates an expected call of UpdateStatus.
|
|
func (mr *MockControllerInterfaceMockRecorder[T, TList]) UpdateStatus(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStatus", reflect.TypeOf((*MockControllerInterface[T, TList])(nil).UpdateStatus), arg0)
|
|
}
|
|
|
|
// Updater mocks base method.
|
|
func (m *MockControllerInterface[T, TList]) Updater() generic.Updater {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Updater")
|
|
ret0, _ := ret[0].(generic.Updater)
|
|
return ret0
|
|
}
|
|
|
|
// Updater indicates an expected call of Updater.
|
|
func (mr *MockControllerInterfaceMockRecorder[T, TList]) Updater() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Updater", reflect.TypeOf((*MockControllerInterface[T, TList])(nil).Updater))
|
|
}
|
|
|
|
// Watch mocks base method.
|
|
func (m *MockControllerInterface[T, TList]) Watch(namespace string, opts v1.ListOptions) (watch.Interface, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Watch", namespace, opts)
|
|
ret0, _ := ret[0].(watch.Interface)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Watch indicates an expected call of Watch.
|
|
func (mr *MockControllerInterfaceMockRecorder[T, TList]) Watch(namespace, opts any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Watch", reflect.TypeOf((*MockControllerInterface[T, TList])(nil).Watch), namespace, opts)
|
|
}
|
|
|
|
// WithImpersonation mocks base method.
|
|
func (m *MockControllerInterface[T, TList]) WithImpersonation(impersonate rest.ImpersonationConfig) (generic.ClientInterface[T, TList], error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "WithImpersonation", impersonate)
|
|
ret0, _ := ret[0].(generic.ClientInterface[T, TList])
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// WithImpersonation indicates an expected call of WithImpersonation.
|
|
func (mr *MockControllerInterfaceMockRecorder[T, TList]) WithImpersonation(impersonate any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithImpersonation", reflect.TypeOf((*MockControllerInterface[T, TList])(nil).WithImpersonation), impersonate)
|
|
}
|
|
|
|
// MockNonNamespacedControllerInterface is a mock of NonNamespacedControllerInterface interface.
|
|
type MockNonNamespacedControllerInterface[T generic.RuntimeMetaObject, TList runtime.Object] struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockNonNamespacedControllerInterfaceMockRecorder[T, TList]
|
|
}
|
|
|
|
// MockNonNamespacedControllerInterfaceMockRecorder is the mock recorder for MockNonNamespacedControllerInterface.
|
|
type MockNonNamespacedControllerInterfaceMockRecorder[T generic.RuntimeMetaObject, TList runtime.Object] struct {
|
|
mock *MockNonNamespacedControllerInterface[T, TList]
|
|
}
|
|
|
|
// NewMockNonNamespacedControllerInterface creates a new mock instance.
|
|
func NewMockNonNamespacedControllerInterface[T generic.RuntimeMetaObject, TList runtime.Object](ctrl *gomock.Controller) *MockNonNamespacedControllerInterface[T, TList] {
|
|
mock := &MockNonNamespacedControllerInterface[T, TList]{ctrl: ctrl}
|
|
mock.recorder = &MockNonNamespacedControllerInterfaceMockRecorder[T, TList]{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockNonNamespacedControllerInterface[T, TList]) EXPECT() *MockNonNamespacedControllerInterfaceMockRecorder[T, TList] {
|
|
return m.recorder
|
|
}
|
|
|
|
// AddGenericHandler mocks base method.
|
|
func (m *MockNonNamespacedControllerInterface[T, TList]) AddGenericHandler(ctx context.Context, name string, handler generic.Handler) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "AddGenericHandler", ctx, name, handler)
|
|
}
|
|
|
|
// AddGenericHandler indicates an expected call of AddGenericHandler.
|
|
func (mr *MockNonNamespacedControllerInterfaceMockRecorder[T, TList]) AddGenericHandler(ctx, name, handler any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddGenericHandler", reflect.TypeOf((*MockNonNamespacedControllerInterface[T, TList])(nil).AddGenericHandler), ctx, name, handler)
|
|
}
|
|
|
|
// AddGenericRemoveHandler mocks base method.
|
|
func (m *MockNonNamespacedControllerInterface[T, TList]) AddGenericRemoveHandler(ctx context.Context, name string, handler generic.Handler) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "AddGenericRemoveHandler", ctx, name, handler)
|
|
}
|
|
|
|
// AddGenericRemoveHandler indicates an expected call of AddGenericRemoveHandler.
|
|
func (mr *MockNonNamespacedControllerInterfaceMockRecorder[T, TList]) AddGenericRemoveHandler(ctx, name, handler any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddGenericRemoveHandler", reflect.TypeOf((*MockNonNamespacedControllerInterface[T, TList])(nil).AddGenericRemoveHandler), ctx, name, handler)
|
|
}
|
|
|
|
// Cache mocks base method.
|
|
func (m *MockNonNamespacedControllerInterface[T, TList]) Cache() generic.NonNamespacedCacheInterface[T] {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Cache")
|
|
ret0, _ := ret[0].(generic.NonNamespacedCacheInterface[T])
|
|
return ret0
|
|
}
|
|
|
|
// Cache indicates an expected call of Cache.
|
|
func (mr *MockNonNamespacedControllerInterfaceMockRecorder[T, TList]) Cache() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cache", reflect.TypeOf((*MockNonNamespacedControllerInterface[T, TList])(nil).Cache))
|
|
}
|
|
|
|
// Create mocks base method.
|
|
func (m *MockNonNamespacedControllerInterface[T, TList]) Create(arg0 T) (T, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Create", arg0)
|
|
ret0, _ := ret[0].(T)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Create indicates an expected call of Create.
|
|
func (mr *MockNonNamespacedControllerInterfaceMockRecorder[T, TList]) Create(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockNonNamespacedControllerInterface[T, TList])(nil).Create), arg0)
|
|
}
|
|
|
|
// Delete mocks base method.
|
|
func (m *MockNonNamespacedControllerInterface[T, TList]) Delete(name string, options *v1.DeleteOptions) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Delete", name, options)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Delete indicates an expected call of Delete.
|
|
func (mr *MockNonNamespacedControllerInterfaceMockRecorder[T, TList]) Delete(name, options any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockNonNamespacedControllerInterface[T, TList])(nil).Delete), name, options)
|
|
}
|
|
|
|
// Enqueue mocks base method.
|
|
func (m *MockNonNamespacedControllerInterface[T, TList]) Enqueue(name string) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "Enqueue", name)
|
|
}
|
|
|
|
// Enqueue indicates an expected call of Enqueue.
|
|
func (mr *MockNonNamespacedControllerInterfaceMockRecorder[T, TList]) Enqueue(name any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Enqueue", reflect.TypeOf((*MockNonNamespacedControllerInterface[T, TList])(nil).Enqueue), name)
|
|
}
|
|
|
|
// EnqueueAfter mocks base method.
|
|
func (m *MockNonNamespacedControllerInterface[T, TList]) EnqueueAfter(name string, duration time.Duration) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "EnqueueAfter", name, duration)
|
|
}
|
|
|
|
// EnqueueAfter indicates an expected call of EnqueueAfter.
|
|
func (mr *MockNonNamespacedControllerInterfaceMockRecorder[T, TList]) EnqueueAfter(name, duration any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnqueueAfter", reflect.TypeOf((*MockNonNamespacedControllerInterface[T, TList])(nil).EnqueueAfter), name, duration)
|
|
}
|
|
|
|
// Get mocks base method.
|
|
func (m *MockNonNamespacedControllerInterface[T, TList]) Get(name string, options v1.GetOptions) (T, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Get", name, options)
|
|
ret0, _ := ret[0].(T)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Get indicates an expected call of Get.
|
|
func (mr *MockNonNamespacedControllerInterfaceMockRecorder[T, TList]) Get(name, options any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockNonNamespacedControllerInterface[T, TList])(nil).Get), name, options)
|
|
}
|
|
|
|
// GroupVersionKind mocks base method.
|
|
func (m *MockNonNamespacedControllerInterface[T, TList]) GroupVersionKind() schema.GroupVersionKind {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GroupVersionKind")
|
|
ret0, _ := ret[0].(schema.GroupVersionKind)
|
|
return ret0
|
|
}
|
|
|
|
// GroupVersionKind indicates an expected call of GroupVersionKind.
|
|
func (mr *MockNonNamespacedControllerInterfaceMockRecorder[T, TList]) GroupVersionKind() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GroupVersionKind", reflect.TypeOf((*MockNonNamespacedControllerInterface[T, TList])(nil).GroupVersionKind))
|
|
}
|
|
|
|
// Informer mocks base method.
|
|
func (m *MockNonNamespacedControllerInterface[T, TList]) Informer() cache.SharedIndexInformer {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Informer")
|
|
ret0, _ := ret[0].(cache.SharedIndexInformer)
|
|
return ret0
|
|
}
|
|
|
|
// Informer indicates an expected call of Informer.
|
|
func (mr *MockNonNamespacedControllerInterfaceMockRecorder[T, TList]) Informer() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Informer", reflect.TypeOf((*MockNonNamespacedControllerInterface[T, TList])(nil).Informer))
|
|
}
|
|
|
|
// List mocks base method.
|
|
func (m *MockNonNamespacedControllerInterface[T, TList]) List(opts v1.ListOptions) (TList, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "List", opts)
|
|
ret0, _ := ret[0].(TList)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// List indicates an expected call of List.
|
|
func (mr *MockNonNamespacedControllerInterfaceMockRecorder[T, TList]) List(opts any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockNonNamespacedControllerInterface[T, TList])(nil).List), opts)
|
|
}
|
|
|
|
// OnChange mocks base method.
|
|
func (m *MockNonNamespacedControllerInterface[T, TList]) OnChange(ctx context.Context, name string, sync generic.ObjectHandler[T]) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "OnChange", ctx, name, sync)
|
|
}
|
|
|
|
// OnChange indicates an expected call of OnChange.
|
|
func (mr *MockNonNamespacedControllerInterfaceMockRecorder[T, TList]) OnChange(ctx, name, sync any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnChange", reflect.TypeOf((*MockNonNamespacedControllerInterface[T, TList])(nil).OnChange), ctx, name, sync)
|
|
}
|
|
|
|
// OnRemove mocks base method.
|
|
func (m *MockNonNamespacedControllerInterface[T, TList]) OnRemove(ctx context.Context, name string, sync generic.ObjectHandler[T]) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "OnRemove", ctx, name, sync)
|
|
}
|
|
|
|
// OnRemove indicates an expected call of OnRemove.
|
|
func (mr *MockNonNamespacedControllerInterfaceMockRecorder[T, TList]) OnRemove(ctx, name, sync any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnRemove", reflect.TypeOf((*MockNonNamespacedControllerInterface[T, TList])(nil).OnRemove), ctx, name, sync)
|
|
}
|
|
|
|
// Patch mocks base method.
|
|
func (m *MockNonNamespacedControllerInterface[T, TList]) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (T, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []any{name, pt, data}
|
|
for _, a := range subresources {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "Patch", varargs...)
|
|
ret0, _ := ret[0].(T)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Patch indicates an expected call of Patch.
|
|
func (mr *MockNonNamespacedControllerInterfaceMockRecorder[T, TList]) Patch(name, pt, data any, subresources ...any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]any{name, pt, data}, subresources...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Patch", reflect.TypeOf((*MockNonNamespacedControllerInterface[T, TList])(nil).Patch), varargs...)
|
|
}
|
|
|
|
// Update mocks base method.
|
|
func (m *MockNonNamespacedControllerInterface[T, TList]) Update(arg0 T) (T, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Update", arg0)
|
|
ret0, _ := ret[0].(T)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Update indicates an expected call of Update.
|
|
func (mr *MockNonNamespacedControllerInterfaceMockRecorder[T, TList]) Update(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockNonNamespacedControllerInterface[T, TList])(nil).Update), arg0)
|
|
}
|
|
|
|
// UpdateStatus mocks base method.
|
|
func (m *MockNonNamespacedControllerInterface[T, TList]) UpdateStatus(arg0 T) (T, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateStatus", arg0)
|
|
ret0, _ := ret[0].(T)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// UpdateStatus indicates an expected call of UpdateStatus.
|
|
func (mr *MockNonNamespacedControllerInterfaceMockRecorder[T, TList]) UpdateStatus(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStatus", reflect.TypeOf((*MockNonNamespacedControllerInterface[T, TList])(nil).UpdateStatus), arg0)
|
|
}
|
|
|
|
// Updater mocks base method.
|
|
func (m *MockNonNamespacedControllerInterface[T, TList]) Updater() generic.Updater {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Updater")
|
|
ret0, _ := ret[0].(generic.Updater)
|
|
return ret0
|
|
}
|
|
|
|
// Updater indicates an expected call of Updater.
|
|
func (mr *MockNonNamespacedControllerInterfaceMockRecorder[T, TList]) Updater() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Updater", reflect.TypeOf((*MockNonNamespacedControllerInterface[T, TList])(nil).Updater))
|
|
}
|
|
|
|
// Watch mocks base method.
|
|
func (m *MockNonNamespacedControllerInterface[T, TList]) Watch(opts v1.ListOptions) (watch.Interface, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Watch", opts)
|
|
ret0, _ := ret[0].(watch.Interface)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Watch indicates an expected call of Watch.
|
|
func (mr *MockNonNamespacedControllerInterfaceMockRecorder[T, TList]) Watch(opts any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Watch", reflect.TypeOf((*MockNonNamespacedControllerInterface[T, TList])(nil).Watch), opts)
|
|
}
|
|
|
|
// WithImpersonation mocks base method.
|
|
func (m *MockNonNamespacedControllerInterface[T, TList]) WithImpersonation(impersonate rest.ImpersonationConfig) (generic.NonNamespacedClientInterface[T, TList], error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "WithImpersonation", impersonate)
|
|
ret0, _ := ret[0].(generic.NonNamespacedClientInterface[T, TList])
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// WithImpersonation indicates an expected call of WithImpersonation.
|
|
func (mr *MockNonNamespacedControllerInterfaceMockRecorder[T, TList]) WithImpersonation(impersonate any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithImpersonation", reflect.TypeOf((*MockNonNamespacedControllerInterface[T, TList])(nil).WithImpersonation), impersonate)
|
|
}
|
|
|
|
// MockClientInterface is a mock of ClientInterface interface.
|
|
type MockClientInterface[T generic.RuntimeMetaObject, TList runtime.Object] struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockClientInterfaceMockRecorder[T, TList]
|
|
}
|
|
|
|
// MockClientInterfaceMockRecorder is the mock recorder for MockClientInterface.
|
|
type MockClientInterfaceMockRecorder[T generic.RuntimeMetaObject, TList runtime.Object] struct {
|
|
mock *MockClientInterface[T, TList]
|
|
}
|
|
|
|
// NewMockClientInterface creates a new mock instance.
|
|
func NewMockClientInterface[T generic.RuntimeMetaObject, TList runtime.Object](ctrl *gomock.Controller) *MockClientInterface[T, TList] {
|
|
mock := &MockClientInterface[T, TList]{ctrl: ctrl}
|
|
mock.recorder = &MockClientInterfaceMockRecorder[T, TList]{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockClientInterface[T, TList]) EXPECT() *MockClientInterfaceMockRecorder[T, TList] {
|
|
return m.recorder
|
|
}
|
|
|
|
// Create mocks base method.
|
|
func (m *MockClientInterface[T, TList]) Create(arg0 T) (T, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Create", arg0)
|
|
ret0, _ := ret[0].(T)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Create indicates an expected call of Create.
|
|
func (mr *MockClientInterfaceMockRecorder[T, TList]) Create(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockClientInterface[T, TList])(nil).Create), arg0)
|
|
}
|
|
|
|
// Delete mocks base method.
|
|
func (m *MockClientInterface[T, TList]) Delete(namespace, name string, options *v1.DeleteOptions) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Delete", namespace, name, options)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Delete indicates an expected call of Delete.
|
|
func (mr *MockClientInterfaceMockRecorder[T, TList]) Delete(namespace, name, options any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockClientInterface[T, TList])(nil).Delete), namespace, name, options)
|
|
}
|
|
|
|
// Get mocks base method.
|
|
func (m *MockClientInterface[T, TList]) Get(namespace, name string, options v1.GetOptions) (T, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Get", namespace, name, options)
|
|
ret0, _ := ret[0].(T)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Get indicates an expected call of Get.
|
|
func (mr *MockClientInterfaceMockRecorder[T, TList]) Get(namespace, name, options any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockClientInterface[T, TList])(nil).Get), namespace, name, options)
|
|
}
|
|
|
|
// List mocks base method.
|
|
func (m *MockClientInterface[T, TList]) List(namespace string, opts v1.ListOptions) (TList, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "List", namespace, opts)
|
|
ret0, _ := ret[0].(TList)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// List indicates an expected call of List.
|
|
func (mr *MockClientInterfaceMockRecorder[T, TList]) List(namespace, opts any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockClientInterface[T, TList])(nil).List), namespace, opts)
|
|
}
|
|
|
|
// Patch mocks base method.
|
|
func (m *MockClientInterface[T, TList]) Patch(namespace, name string, pt types.PatchType, data []byte, subresources ...string) (T, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []any{namespace, name, pt, data}
|
|
for _, a := range subresources {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "Patch", varargs...)
|
|
ret0, _ := ret[0].(T)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Patch indicates an expected call of Patch.
|
|
func (mr *MockClientInterfaceMockRecorder[T, TList]) Patch(namespace, name, pt, data any, subresources ...any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]any{namespace, name, pt, data}, subresources...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Patch", reflect.TypeOf((*MockClientInterface[T, TList])(nil).Patch), varargs...)
|
|
}
|
|
|
|
// Update mocks base method.
|
|
func (m *MockClientInterface[T, TList]) Update(arg0 T) (T, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Update", arg0)
|
|
ret0, _ := ret[0].(T)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Update indicates an expected call of Update.
|
|
func (mr *MockClientInterfaceMockRecorder[T, TList]) Update(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockClientInterface[T, TList])(nil).Update), arg0)
|
|
}
|
|
|
|
// UpdateStatus mocks base method.
|
|
func (m *MockClientInterface[T, TList]) UpdateStatus(arg0 T) (T, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateStatus", arg0)
|
|
ret0, _ := ret[0].(T)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// UpdateStatus indicates an expected call of UpdateStatus.
|
|
func (mr *MockClientInterfaceMockRecorder[T, TList]) UpdateStatus(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStatus", reflect.TypeOf((*MockClientInterface[T, TList])(nil).UpdateStatus), arg0)
|
|
}
|
|
|
|
// Watch mocks base method.
|
|
func (m *MockClientInterface[T, TList]) Watch(namespace string, opts v1.ListOptions) (watch.Interface, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Watch", namespace, opts)
|
|
ret0, _ := ret[0].(watch.Interface)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Watch indicates an expected call of Watch.
|
|
func (mr *MockClientInterfaceMockRecorder[T, TList]) Watch(namespace, opts any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Watch", reflect.TypeOf((*MockClientInterface[T, TList])(nil).Watch), namespace, opts)
|
|
}
|
|
|
|
// WithImpersonation mocks base method.
|
|
func (m *MockClientInterface[T, TList]) WithImpersonation(impersonate rest.ImpersonationConfig) (generic.ClientInterface[T, TList], error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "WithImpersonation", impersonate)
|
|
ret0, _ := ret[0].(generic.ClientInterface[T, TList])
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// WithImpersonation indicates an expected call of WithImpersonation.
|
|
func (mr *MockClientInterfaceMockRecorder[T, TList]) WithImpersonation(impersonate any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithImpersonation", reflect.TypeOf((*MockClientInterface[T, TList])(nil).WithImpersonation), impersonate)
|
|
}
|
|
|
|
// MockNonNamespacedClientInterface is a mock of NonNamespacedClientInterface interface.
|
|
type MockNonNamespacedClientInterface[T generic.RuntimeMetaObject, TList runtime.Object] struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockNonNamespacedClientInterfaceMockRecorder[T, TList]
|
|
}
|
|
|
|
// MockNonNamespacedClientInterfaceMockRecorder is the mock recorder for MockNonNamespacedClientInterface.
|
|
type MockNonNamespacedClientInterfaceMockRecorder[T generic.RuntimeMetaObject, TList runtime.Object] struct {
|
|
mock *MockNonNamespacedClientInterface[T, TList]
|
|
}
|
|
|
|
// NewMockNonNamespacedClientInterface creates a new mock instance.
|
|
func NewMockNonNamespacedClientInterface[T generic.RuntimeMetaObject, TList runtime.Object](ctrl *gomock.Controller) *MockNonNamespacedClientInterface[T, TList] {
|
|
mock := &MockNonNamespacedClientInterface[T, TList]{ctrl: ctrl}
|
|
mock.recorder = &MockNonNamespacedClientInterfaceMockRecorder[T, TList]{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockNonNamespacedClientInterface[T, TList]) EXPECT() *MockNonNamespacedClientInterfaceMockRecorder[T, TList] {
|
|
return m.recorder
|
|
}
|
|
|
|
// Create mocks base method.
|
|
func (m *MockNonNamespacedClientInterface[T, TList]) Create(arg0 T) (T, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Create", arg0)
|
|
ret0, _ := ret[0].(T)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Create indicates an expected call of Create.
|
|
func (mr *MockNonNamespacedClientInterfaceMockRecorder[T, TList]) Create(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockNonNamespacedClientInterface[T, TList])(nil).Create), arg0)
|
|
}
|
|
|
|
// Delete mocks base method.
|
|
func (m *MockNonNamespacedClientInterface[T, TList]) Delete(name string, options *v1.DeleteOptions) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Delete", name, options)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Delete indicates an expected call of Delete.
|
|
func (mr *MockNonNamespacedClientInterfaceMockRecorder[T, TList]) Delete(name, options any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockNonNamespacedClientInterface[T, TList])(nil).Delete), name, options)
|
|
}
|
|
|
|
// Get mocks base method.
|
|
func (m *MockNonNamespacedClientInterface[T, TList]) Get(name string, options v1.GetOptions) (T, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Get", name, options)
|
|
ret0, _ := ret[0].(T)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Get indicates an expected call of Get.
|
|
func (mr *MockNonNamespacedClientInterfaceMockRecorder[T, TList]) Get(name, options any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockNonNamespacedClientInterface[T, TList])(nil).Get), name, options)
|
|
}
|
|
|
|
// List mocks base method.
|
|
func (m *MockNonNamespacedClientInterface[T, TList]) List(opts v1.ListOptions) (TList, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "List", opts)
|
|
ret0, _ := ret[0].(TList)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// List indicates an expected call of List.
|
|
func (mr *MockNonNamespacedClientInterfaceMockRecorder[T, TList]) List(opts any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockNonNamespacedClientInterface[T, TList])(nil).List), opts)
|
|
}
|
|
|
|
// Patch mocks base method.
|
|
func (m *MockNonNamespacedClientInterface[T, TList]) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (T, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []any{name, pt, data}
|
|
for _, a := range subresources {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "Patch", varargs...)
|
|
ret0, _ := ret[0].(T)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Patch indicates an expected call of Patch.
|
|
func (mr *MockNonNamespacedClientInterfaceMockRecorder[T, TList]) Patch(name, pt, data any, subresources ...any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]any{name, pt, data}, subresources...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Patch", reflect.TypeOf((*MockNonNamespacedClientInterface[T, TList])(nil).Patch), varargs...)
|
|
}
|
|
|
|
// Update mocks base method.
|
|
func (m *MockNonNamespacedClientInterface[T, TList]) Update(arg0 T) (T, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Update", arg0)
|
|
ret0, _ := ret[0].(T)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Update indicates an expected call of Update.
|
|
func (mr *MockNonNamespacedClientInterfaceMockRecorder[T, TList]) Update(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockNonNamespacedClientInterface[T, TList])(nil).Update), arg0)
|
|
}
|
|
|
|
// UpdateStatus mocks base method.
|
|
func (m *MockNonNamespacedClientInterface[T, TList]) UpdateStatus(arg0 T) (T, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateStatus", arg0)
|
|
ret0, _ := ret[0].(T)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// UpdateStatus indicates an expected call of UpdateStatus.
|
|
func (mr *MockNonNamespacedClientInterfaceMockRecorder[T, TList]) UpdateStatus(arg0 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStatus", reflect.TypeOf((*MockNonNamespacedClientInterface[T, TList])(nil).UpdateStatus), arg0)
|
|
}
|
|
|
|
// Watch mocks base method.
|
|
func (m *MockNonNamespacedClientInterface[T, TList]) Watch(opts v1.ListOptions) (watch.Interface, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Watch", opts)
|
|
ret0, _ := ret[0].(watch.Interface)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Watch indicates an expected call of Watch.
|
|
func (mr *MockNonNamespacedClientInterfaceMockRecorder[T, TList]) Watch(opts any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Watch", reflect.TypeOf((*MockNonNamespacedClientInterface[T, TList])(nil).Watch), opts)
|
|
}
|
|
|
|
// WithImpersonation mocks base method.
|
|
func (m *MockNonNamespacedClientInterface[T, TList]) WithImpersonation(impersonate rest.ImpersonationConfig) (generic.NonNamespacedClientInterface[T, TList], error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "WithImpersonation", impersonate)
|
|
ret0, _ := ret[0].(generic.NonNamespacedClientInterface[T, TList])
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// WithImpersonation indicates an expected call of WithImpersonation.
|
|
func (mr *MockNonNamespacedClientInterfaceMockRecorder[T, TList]) WithImpersonation(impersonate any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithImpersonation", reflect.TypeOf((*MockNonNamespacedClientInterface[T, TList])(nil).WithImpersonation), impersonate)
|
|
}
|