| // Code generated by mockery v2.28.0. DO NOT EDIT. |
| |
| package mocks |
| |
| import ( |
| apiserverinternalv1alpha1 "k8s.io/client-go/kubernetes/typed/apiserverinternal/v1alpha1" |
| appsv1 "k8s.io/client-go/kubernetes/typed/apps/v1" |
| |
| appsv1beta1 "k8s.io/client-go/kubernetes/typed/apps/v1beta1" |
| |
| authenticationv1 "k8s.io/client-go/kubernetes/typed/authentication/v1" |
| |
| authenticationv1beta1 "k8s.io/client-go/kubernetes/typed/authentication/v1beta1" |
| |
| authorizationv1 "k8s.io/client-go/kubernetes/typed/authorization/v1" |
| |
| authorizationv1beta1 "k8s.io/client-go/kubernetes/typed/authorization/v1beta1" |
| |
| autoscalingv1 "k8s.io/client-go/kubernetes/typed/autoscaling/v1" |
| |
| batchv1 "k8s.io/client-go/kubernetes/typed/batch/v1" |
| |
| batchv1beta1 "k8s.io/client-go/kubernetes/typed/batch/v1beta1" |
| |
| certificatesv1 "k8s.io/client-go/kubernetes/typed/certificates/v1" |
| |
| certificatesv1beta1 "k8s.io/client-go/kubernetes/typed/certificates/v1beta1" |
| |
| coordinationv1 "k8s.io/client-go/kubernetes/typed/coordination/v1" |
| |
| coordinationv1beta1 "k8s.io/client-go/kubernetes/typed/coordination/v1beta1" |
| |
| corev1 "k8s.io/client-go/kubernetes/typed/core/v1" |
| |
| discovery "k8s.io/client-go/discovery" |
| |
| discoveryv1 "k8s.io/client-go/kubernetes/typed/discovery/v1" |
| |
| discoveryv1beta1 "k8s.io/client-go/kubernetes/typed/discovery/v1beta1" |
| |
| eventsv1 "k8s.io/client-go/kubernetes/typed/events/v1" |
| |
| eventsv1beta1 "k8s.io/client-go/kubernetes/typed/events/v1beta1" |
| |
| extensionsv1beta1 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1" |
| |
| flowcontrolv1beta1 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta1" |
| |
| mock "github.com/stretchr/testify/mock" |
| |
| networkingv1 "k8s.io/client-go/kubernetes/typed/networking/v1" |
| |
| networkingv1beta1 "k8s.io/client-go/kubernetes/typed/networking/v1beta1" |
| |
| nodev1 "k8s.io/client-go/kubernetes/typed/node/v1" |
| |
| nodev1alpha1 "k8s.io/client-go/kubernetes/typed/node/v1alpha1" |
| |
| nodev1beta1 "k8s.io/client-go/kubernetes/typed/node/v1beta1" |
| |
| policyv1 "k8s.io/client-go/kubernetes/typed/policy/v1" |
| |
| policyv1beta1 "k8s.io/client-go/kubernetes/typed/policy/v1beta1" |
| |
| rbacv1 "k8s.io/client-go/kubernetes/typed/rbac/v1" |
| |
| rbacv1alpha1 "k8s.io/client-go/kubernetes/typed/rbac/v1alpha1" |
| |
| rbacv1beta1 "k8s.io/client-go/kubernetes/typed/rbac/v1beta1" |
| |
| schedulingv1 "k8s.io/client-go/kubernetes/typed/scheduling/v1" |
| |
| schedulingv1alpha1 "k8s.io/client-go/kubernetes/typed/scheduling/v1alpha1" |
| |
| schedulingv1beta1 "k8s.io/client-go/kubernetes/typed/scheduling/v1beta1" |
| |
| storagev1 "k8s.io/client-go/kubernetes/typed/storage/v1" |
| |
| storagev1alpha1 "k8s.io/client-go/kubernetes/typed/storage/v1alpha1" |
| |
| storagev1beta1 "k8s.io/client-go/kubernetes/typed/storage/v1beta1" |
| |
| v1 "k8s.io/client-go/kubernetes/typed/admissionregistration/v1" |
| |
| v1alpha1 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1alpha1" |
| |
| v1beta1 "k8s.io/client-go/kubernetes/typed/admissionregistration/v1beta1" |
| |
| v1beta2 "k8s.io/client-go/kubernetes/typed/apps/v1beta2" |
| |
| v2beta1 "k8s.io/client-go/kubernetes/typed/autoscaling/v2beta1" |
| |
| v2beta2 "k8s.io/client-go/kubernetes/typed/autoscaling/v2beta2" |
| ) |
| |
| // Interface is an autogenerated mock type for the Interface type |
| type Interface struct { |
| mock.Mock |
| } |
| |
| type Interface_Expecter struct { |
| mock *mock.Mock |
| } |
| |
| func (_m *Interface) EXPECT() *Interface_Expecter { |
| return &Interface_Expecter{mock: &_m.Mock} |
| } |
| |
| // AdmissionregistrationV1 provides a mock function with given fields: |
| func (_m *Interface) AdmissionregistrationV1() v1.AdmissionregistrationV1Interface { |
| ret := _m.Called() |
| |
| var r0 v1.AdmissionregistrationV1Interface |
| if rf, ok := ret.Get(0).(func() v1.AdmissionregistrationV1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(v1.AdmissionregistrationV1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_AdmissionregistrationV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AdmissionregistrationV1' |
| type Interface_AdmissionregistrationV1_Call struct { |
| *mock.Call |
| } |
| |
| // AdmissionregistrationV1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) AdmissionregistrationV1() *Interface_AdmissionregistrationV1_Call { |
| return &Interface_AdmissionregistrationV1_Call{Call: _e.mock.On("AdmissionregistrationV1")} |
| } |
| |
| func (_c *Interface_AdmissionregistrationV1_Call) Run(run func()) *Interface_AdmissionregistrationV1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_AdmissionregistrationV1_Call) Return(_a0 v1.AdmissionregistrationV1Interface) *Interface_AdmissionregistrationV1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_AdmissionregistrationV1_Call) RunAndReturn(run func() v1.AdmissionregistrationV1Interface) *Interface_AdmissionregistrationV1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // AdmissionregistrationV1beta1 provides a mock function with given fields: |
| func (_m *Interface) AdmissionregistrationV1beta1() v1beta1.AdmissionregistrationV1beta1Interface { |
| ret := _m.Called() |
| |
| var r0 v1beta1.AdmissionregistrationV1beta1Interface |
| if rf, ok := ret.Get(0).(func() v1beta1.AdmissionregistrationV1beta1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(v1beta1.AdmissionregistrationV1beta1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_AdmissionregistrationV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AdmissionregistrationV1beta1' |
| type Interface_AdmissionregistrationV1beta1_Call struct { |
| *mock.Call |
| } |
| |
| // AdmissionregistrationV1beta1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) AdmissionregistrationV1beta1() *Interface_AdmissionregistrationV1beta1_Call { |
| return &Interface_AdmissionregistrationV1beta1_Call{Call: _e.mock.On("AdmissionregistrationV1beta1")} |
| } |
| |
| func (_c *Interface_AdmissionregistrationV1beta1_Call) Run(run func()) *Interface_AdmissionregistrationV1beta1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_AdmissionregistrationV1beta1_Call) Return(_a0 v1beta1.AdmissionregistrationV1beta1Interface) *Interface_AdmissionregistrationV1beta1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_AdmissionregistrationV1beta1_Call) RunAndReturn(run func() v1beta1.AdmissionregistrationV1beta1Interface) *Interface_AdmissionregistrationV1beta1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // AppsV1 provides a mock function with given fields: |
| func (_m *Interface) AppsV1() appsv1.AppsV1Interface { |
| ret := _m.Called() |
| |
| var r0 appsv1.AppsV1Interface |
| if rf, ok := ret.Get(0).(func() appsv1.AppsV1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(appsv1.AppsV1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_AppsV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AppsV1' |
| type Interface_AppsV1_Call struct { |
| *mock.Call |
| } |
| |
| // AppsV1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) AppsV1() *Interface_AppsV1_Call { |
| return &Interface_AppsV1_Call{Call: _e.mock.On("AppsV1")} |
| } |
| |
| func (_c *Interface_AppsV1_Call) Run(run func()) *Interface_AppsV1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_AppsV1_Call) Return(_a0 appsv1.AppsV1Interface) *Interface_AppsV1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_AppsV1_Call) RunAndReturn(run func() appsv1.AppsV1Interface) *Interface_AppsV1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // AppsV1beta1 provides a mock function with given fields: |
| func (_m *Interface) AppsV1beta1() appsv1beta1.AppsV1beta1Interface { |
| ret := _m.Called() |
| |
| var r0 appsv1beta1.AppsV1beta1Interface |
| if rf, ok := ret.Get(0).(func() appsv1beta1.AppsV1beta1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(appsv1beta1.AppsV1beta1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_AppsV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AppsV1beta1' |
| type Interface_AppsV1beta1_Call struct { |
| *mock.Call |
| } |
| |
| // AppsV1beta1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) AppsV1beta1() *Interface_AppsV1beta1_Call { |
| return &Interface_AppsV1beta1_Call{Call: _e.mock.On("AppsV1beta1")} |
| } |
| |
| func (_c *Interface_AppsV1beta1_Call) Run(run func()) *Interface_AppsV1beta1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_AppsV1beta1_Call) Return(_a0 appsv1beta1.AppsV1beta1Interface) *Interface_AppsV1beta1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_AppsV1beta1_Call) RunAndReturn(run func() appsv1beta1.AppsV1beta1Interface) *Interface_AppsV1beta1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // AppsV1beta2 provides a mock function with given fields: |
| func (_m *Interface) AppsV1beta2() v1beta2.AppsV1beta2Interface { |
| ret := _m.Called() |
| |
| var r0 v1beta2.AppsV1beta2Interface |
| if rf, ok := ret.Get(0).(func() v1beta2.AppsV1beta2Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(v1beta2.AppsV1beta2Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_AppsV1beta2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AppsV1beta2' |
| type Interface_AppsV1beta2_Call struct { |
| *mock.Call |
| } |
| |
| // AppsV1beta2 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) AppsV1beta2() *Interface_AppsV1beta2_Call { |
| return &Interface_AppsV1beta2_Call{Call: _e.mock.On("AppsV1beta2")} |
| } |
| |
| func (_c *Interface_AppsV1beta2_Call) Run(run func()) *Interface_AppsV1beta2_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_AppsV1beta2_Call) Return(_a0 v1beta2.AppsV1beta2Interface) *Interface_AppsV1beta2_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_AppsV1beta2_Call) RunAndReturn(run func() v1beta2.AppsV1beta2Interface) *Interface_AppsV1beta2_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // AuthenticationV1 provides a mock function with given fields: |
| func (_m *Interface) AuthenticationV1() authenticationv1.AuthenticationV1Interface { |
| ret := _m.Called() |
| |
| var r0 authenticationv1.AuthenticationV1Interface |
| if rf, ok := ret.Get(0).(func() authenticationv1.AuthenticationV1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(authenticationv1.AuthenticationV1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_AuthenticationV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthenticationV1' |
| type Interface_AuthenticationV1_Call struct { |
| *mock.Call |
| } |
| |
| // AuthenticationV1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) AuthenticationV1() *Interface_AuthenticationV1_Call { |
| return &Interface_AuthenticationV1_Call{Call: _e.mock.On("AuthenticationV1")} |
| } |
| |
| func (_c *Interface_AuthenticationV1_Call) Run(run func()) *Interface_AuthenticationV1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_AuthenticationV1_Call) Return(_a0 authenticationv1.AuthenticationV1Interface) *Interface_AuthenticationV1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_AuthenticationV1_Call) RunAndReturn(run func() authenticationv1.AuthenticationV1Interface) *Interface_AuthenticationV1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // AuthenticationV1beta1 provides a mock function with given fields: |
| func (_m *Interface) AuthenticationV1beta1() authenticationv1beta1.AuthenticationV1beta1Interface { |
| ret := _m.Called() |
| |
| var r0 authenticationv1beta1.AuthenticationV1beta1Interface |
| if rf, ok := ret.Get(0).(func() authenticationv1beta1.AuthenticationV1beta1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(authenticationv1beta1.AuthenticationV1beta1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_AuthenticationV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthenticationV1beta1' |
| type Interface_AuthenticationV1beta1_Call struct { |
| *mock.Call |
| } |
| |
| // AuthenticationV1beta1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) AuthenticationV1beta1() *Interface_AuthenticationV1beta1_Call { |
| return &Interface_AuthenticationV1beta1_Call{Call: _e.mock.On("AuthenticationV1beta1")} |
| } |
| |
| func (_c *Interface_AuthenticationV1beta1_Call) Run(run func()) *Interface_AuthenticationV1beta1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_AuthenticationV1beta1_Call) Return(_a0 authenticationv1beta1.AuthenticationV1beta1Interface) *Interface_AuthenticationV1beta1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_AuthenticationV1beta1_Call) RunAndReturn(run func() authenticationv1beta1.AuthenticationV1beta1Interface) *Interface_AuthenticationV1beta1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // AuthorizationV1 provides a mock function with given fields: |
| func (_m *Interface) AuthorizationV1() authorizationv1.AuthorizationV1Interface { |
| ret := _m.Called() |
| |
| var r0 authorizationv1.AuthorizationV1Interface |
| if rf, ok := ret.Get(0).(func() authorizationv1.AuthorizationV1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(authorizationv1.AuthorizationV1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_AuthorizationV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthorizationV1' |
| type Interface_AuthorizationV1_Call struct { |
| *mock.Call |
| } |
| |
| // AuthorizationV1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) AuthorizationV1() *Interface_AuthorizationV1_Call { |
| return &Interface_AuthorizationV1_Call{Call: _e.mock.On("AuthorizationV1")} |
| } |
| |
| func (_c *Interface_AuthorizationV1_Call) Run(run func()) *Interface_AuthorizationV1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_AuthorizationV1_Call) Return(_a0 authorizationv1.AuthorizationV1Interface) *Interface_AuthorizationV1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_AuthorizationV1_Call) RunAndReturn(run func() authorizationv1.AuthorizationV1Interface) *Interface_AuthorizationV1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // AuthorizationV1beta1 provides a mock function with given fields: |
| func (_m *Interface) AuthorizationV1beta1() authorizationv1beta1.AuthorizationV1beta1Interface { |
| ret := _m.Called() |
| |
| var r0 authorizationv1beta1.AuthorizationV1beta1Interface |
| if rf, ok := ret.Get(0).(func() authorizationv1beta1.AuthorizationV1beta1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(authorizationv1beta1.AuthorizationV1beta1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_AuthorizationV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthorizationV1beta1' |
| type Interface_AuthorizationV1beta1_Call struct { |
| *mock.Call |
| } |
| |
| // AuthorizationV1beta1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) AuthorizationV1beta1() *Interface_AuthorizationV1beta1_Call { |
| return &Interface_AuthorizationV1beta1_Call{Call: _e.mock.On("AuthorizationV1beta1")} |
| } |
| |
| func (_c *Interface_AuthorizationV1beta1_Call) Run(run func()) *Interface_AuthorizationV1beta1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_AuthorizationV1beta1_Call) Return(_a0 authorizationv1beta1.AuthorizationV1beta1Interface) *Interface_AuthorizationV1beta1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_AuthorizationV1beta1_Call) RunAndReturn(run func() authorizationv1beta1.AuthorizationV1beta1Interface) *Interface_AuthorizationV1beta1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // AutoscalingV1 provides a mock function with given fields: |
| func (_m *Interface) AutoscalingV1() autoscalingv1.AutoscalingV1Interface { |
| ret := _m.Called() |
| |
| var r0 autoscalingv1.AutoscalingV1Interface |
| if rf, ok := ret.Get(0).(func() autoscalingv1.AutoscalingV1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(autoscalingv1.AutoscalingV1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_AutoscalingV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AutoscalingV1' |
| type Interface_AutoscalingV1_Call struct { |
| *mock.Call |
| } |
| |
| // AutoscalingV1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) AutoscalingV1() *Interface_AutoscalingV1_Call { |
| return &Interface_AutoscalingV1_Call{Call: _e.mock.On("AutoscalingV1")} |
| } |
| |
| func (_c *Interface_AutoscalingV1_Call) Run(run func()) *Interface_AutoscalingV1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_AutoscalingV1_Call) Return(_a0 autoscalingv1.AutoscalingV1Interface) *Interface_AutoscalingV1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_AutoscalingV1_Call) RunAndReturn(run func() autoscalingv1.AutoscalingV1Interface) *Interface_AutoscalingV1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // AutoscalingV2beta1 provides a mock function with given fields: |
| func (_m *Interface) AutoscalingV2beta1() v2beta1.AutoscalingV2beta1Interface { |
| ret := _m.Called() |
| |
| var r0 v2beta1.AutoscalingV2beta1Interface |
| if rf, ok := ret.Get(0).(func() v2beta1.AutoscalingV2beta1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(v2beta1.AutoscalingV2beta1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_AutoscalingV2beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AutoscalingV2beta1' |
| type Interface_AutoscalingV2beta1_Call struct { |
| *mock.Call |
| } |
| |
| // AutoscalingV2beta1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) AutoscalingV2beta1() *Interface_AutoscalingV2beta1_Call { |
| return &Interface_AutoscalingV2beta1_Call{Call: _e.mock.On("AutoscalingV2beta1")} |
| } |
| |
| func (_c *Interface_AutoscalingV2beta1_Call) Run(run func()) *Interface_AutoscalingV2beta1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_AutoscalingV2beta1_Call) Return(_a0 v2beta1.AutoscalingV2beta1Interface) *Interface_AutoscalingV2beta1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_AutoscalingV2beta1_Call) RunAndReturn(run func() v2beta1.AutoscalingV2beta1Interface) *Interface_AutoscalingV2beta1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // AutoscalingV2beta2 provides a mock function with given fields: |
| func (_m *Interface) AutoscalingV2beta2() v2beta2.AutoscalingV2beta2Interface { |
| ret := _m.Called() |
| |
| var r0 v2beta2.AutoscalingV2beta2Interface |
| if rf, ok := ret.Get(0).(func() v2beta2.AutoscalingV2beta2Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(v2beta2.AutoscalingV2beta2Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_AutoscalingV2beta2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AutoscalingV2beta2' |
| type Interface_AutoscalingV2beta2_Call struct { |
| *mock.Call |
| } |
| |
| // AutoscalingV2beta2 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) AutoscalingV2beta2() *Interface_AutoscalingV2beta2_Call { |
| return &Interface_AutoscalingV2beta2_Call{Call: _e.mock.On("AutoscalingV2beta2")} |
| } |
| |
| func (_c *Interface_AutoscalingV2beta2_Call) Run(run func()) *Interface_AutoscalingV2beta2_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_AutoscalingV2beta2_Call) Return(_a0 v2beta2.AutoscalingV2beta2Interface) *Interface_AutoscalingV2beta2_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_AutoscalingV2beta2_Call) RunAndReturn(run func() v2beta2.AutoscalingV2beta2Interface) *Interface_AutoscalingV2beta2_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // BatchV1 provides a mock function with given fields: |
| func (_m *Interface) BatchV1() batchv1.BatchV1Interface { |
| ret := _m.Called() |
| |
| var r0 batchv1.BatchV1Interface |
| if rf, ok := ret.Get(0).(func() batchv1.BatchV1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(batchv1.BatchV1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_BatchV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchV1' |
| type Interface_BatchV1_Call struct { |
| *mock.Call |
| } |
| |
| // BatchV1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) BatchV1() *Interface_BatchV1_Call { |
| return &Interface_BatchV1_Call{Call: _e.mock.On("BatchV1")} |
| } |
| |
| func (_c *Interface_BatchV1_Call) Run(run func()) *Interface_BatchV1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_BatchV1_Call) Return(_a0 batchv1.BatchV1Interface) *Interface_BatchV1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_BatchV1_Call) RunAndReturn(run func() batchv1.BatchV1Interface) *Interface_BatchV1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // BatchV1beta1 provides a mock function with given fields: |
| func (_m *Interface) BatchV1beta1() batchv1beta1.BatchV1beta1Interface { |
| ret := _m.Called() |
| |
| var r0 batchv1beta1.BatchV1beta1Interface |
| if rf, ok := ret.Get(0).(func() batchv1beta1.BatchV1beta1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(batchv1beta1.BatchV1beta1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_BatchV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchV1beta1' |
| type Interface_BatchV1beta1_Call struct { |
| *mock.Call |
| } |
| |
| // BatchV1beta1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) BatchV1beta1() *Interface_BatchV1beta1_Call { |
| return &Interface_BatchV1beta1_Call{Call: _e.mock.On("BatchV1beta1")} |
| } |
| |
| func (_c *Interface_BatchV1beta1_Call) Run(run func()) *Interface_BatchV1beta1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_BatchV1beta1_Call) Return(_a0 batchv1beta1.BatchV1beta1Interface) *Interface_BatchV1beta1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_BatchV1beta1_Call) RunAndReturn(run func() batchv1beta1.BatchV1beta1Interface) *Interface_BatchV1beta1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // CertificatesV1 provides a mock function with given fields: |
| func (_m *Interface) CertificatesV1() certificatesv1.CertificatesV1Interface { |
| ret := _m.Called() |
| |
| var r0 certificatesv1.CertificatesV1Interface |
| if rf, ok := ret.Get(0).(func() certificatesv1.CertificatesV1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(certificatesv1.CertificatesV1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_CertificatesV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CertificatesV1' |
| type Interface_CertificatesV1_Call struct { |
| *mock.Call |
| } |
| |
| // CertificatesV1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) CertificatesV1() *Interface_CertificatesV1_Call { |
| return &Interface_CertificatesV1_Call{Call: _e.mock.On("CertificatesV1")} |
| } |
| |
| func (_c *Interface_CertificatesV1_Call) Run(run func()) *Interface_CertificatesV1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_CertificatesV1_Call) Return(_a0 certificatesv1.CertificatesV1Interface) *Interface_CertificatesV1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_CertificatesV1_Call) RunAndReturn(run func() certificatesv1.CertificatesV1Interface) *Interface_CertificatesV1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // CertificatesV1beta1 provides a mock function with given fields: |
| func (_m *Interface) CertificatesV1beta1() certificatesv1beta1.CertificatesV1beta1Interface { |
| ret := _m.Called() |
| |
| var r0 certificatesv1beta1.CertificatesV1beta1Interface |
| if rf, ok := ret.Get(0).(func() certificatesv1beta1.CertificatesV1beta1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(certificatesv1beta1.CertificatesV1beta1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_CertificatesV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CertificatesV1beta1' |
| type Interface_CertificatesV1beta1_Call struct { |
| *mock.Call |
| } |
| |
| // CertificatesV1beta1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) CertificatesV1beta1() *Interface_CertificatesV1beta1_Call { |
| return &Interface_CertificatesV1beta1_Call{Call: _e.mock.On("CertificatesV1beta1")} |
| } |
| |
| func (_c *Interface_CertificatesV1beta1_Call) Run(run func()) *Interface_CertificatesV1beta1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_CertificatesV1beta1_Call) Return(_a0 certificatesv1beta1.CertificatesV1beta1Interface) *Interface_CertificatesV1beta1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_CertificatesV1beta1_Call) RunAndReturn(run func() certificatesv1beta1.CertificatesV1beta1Interface) *Interface_CertificatesV1beta1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // CoordinationV1 provides a mock function with given fields: |
| func (_m *Interface) CoordinationV1() coordinationv1.CoordinationV1Interface { |
| ret := _m.Called() |
| |
| var r0 coordinationv1.CoordinationV1Interface |
| if rf, ok := ret.Get(0).(func() coordinationv1.CoordinationV1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(coordinationv1.CoordinationV1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_CoordinationV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CoordinationV1' |
| type Interface_CoordinationV1_Call struct { |
| *mock.Call |
| } |
| |
| // CoordinationV1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) CoordinationV1() *Interface_CoordinationV1_Call { |
| return &Interface_CoordinationV1_Call{Call: _e.mock.On("CoordinationV1")} |
| } |
| |
| func (_c *Interface_CoordinationV1_Call) Run(run func()) *Interface_CoordinationV1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_CoordinationV1_Call) Return(_a0 coordinationv1.CoordinationV1Interface) *Interface_CoordinationV1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_CoordinationV1_Call) RunAndReturn(run func() coordinationv1.CoordinationV1Interface) *Interface_CoordinationV1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // CoordinationV1beta1 provides a mock function with given fields: |
| func (_m *Interface) CoordinationV1beta1() coordinationv1beta1.CoordinationV1beta1Interface { |
| ret := _m.Called() |
| |
| var r0 coordinationv1beta1.CoordinationV1beta1Interface |
| if rf, ok := ret.Get(0).(func() coordinationv1beta1.CoordinationV1beta1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(coordinationv1beta1.CoordinationV1beta1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_CoordinationV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CoordinationV1beta1' |
| type Interface_CoordinationV1beta1_Call struct { |
| *mock.Call |
| } |
| |
| // CoordinationV1beta1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) CoordinationV1beta1() *Interface_CoordinationV1beta1_Call { |
| return &Interface_CoordinationV1beta1_Call{Call: _e.mock.On("CoordinationV1beta1")} |
| } |
| |
| func (_c *Interface_CoordinationV1beta1_Call) Run(run func()) *Interface_CoordinationV1beta1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_CoordinationV1beta1_Call) Return(_a0 coordinationv1beta1.CoordinationV1beta1Interface) *Interface_CoordinationV1beta1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_CoordinationV1beta1_Call) RunAndReturn(run func() coordinationv1beta1.CoordinationV1beta1Interface) *Interface_CoordinationV1beta1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // CoreV1 provides a mock function with given fields: |
| func (_m *Interface) CoreV1() corev1.CoreV1Interface { |
| ret := _m.Called() |
| |
| var r0 corev1.CoreV1Interface |
| if rf, ok := ret.Get(0).(func() corev1.CoreV1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(corev1.CoreV1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_CoreV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CoreV1' |
| type Interface_CoreV1_Call struct { |
| *mock.Call |
| } |
| |
| // CoreV1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) CoreV1() *Interface_CoreV1_Call { |
| return &Interface_CoreV1_Call{Call: _e.mock.On("CoreV1")} |
| } |
| |
| func (_c *Interface_CoreV1_Call) Run(run func()) *Interface_CoreV1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_CoreV1_Call) Return(_a0 corev1.CoreV1Interface) *Interface_CoreV1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_CoreV1_Call) RunAndReturn(run func() corev1.CoreV1Interface) *Interface_CoreV1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // Discovery provides a mock function with given fields: |
| func (_m *Interface) Discovery() discovery.DiscoveryInterface { |
| ret := _m.Called() |
| |
| var r0 discovery.DiscoveryInterface |
| if rf, ok := ret.Get(0).(func() discovery.DiscoveryInterface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(discovery.DiscoveryInterface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_Discovery_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Discovery' |
| type Interface_Discovery_Call struct { |
| *mock.Call |
| } |
| |
| // Discovery is a helper method to define mock.On call |
| func (_e *Interface_Expecter) Discovery() *Interface_Discovery_Call { |
| return &Interface_Discovery_Call{Call: _e.mock.On("Discovery")} |
| } |
| |
| func (_c *Interface_Discovery_Call) Run(run func()) *Interface_Discovery_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_Discovery_Call) Return(_a0 discovery.DiscoveryInterface) *Interface_Discovery_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_Discovery_Call) RunAndReturn(run func() discovery.DiscoveryInterface) *Interface_Discovery_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // DiscoveryV1 provides a mock function with given fields: |
| func (_m *Interface) DiscoveryV1() discoveryv1.DiscoveryV1Interface { |
| ret := _m.Called() |
| |
| var r0 discoveryv1.DiscoveryV1Interface |
| if rf, ok := ret.Get(0).(func() discoveryv1.DiscoveryV1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(discoveryv1.DiscoveryV1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_DiscoveryV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DiscoveryV1' |
| type Interface_DiscoveryV1_Call struct { |
| *mock.Call |
| } |
| |
| // DiscoveryV1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) DiscoveryV1() *Interface_DiscoveryV1_Call { |
| return &Interface_DiscoveryV1_Call{Call: _e.mock.On("DiscoveryV1")} |
| } |
| |
| func (_c *Interface_DiscoveryV1_Call) Run(run func()) *Interface_DiscoveryV1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_DiscoveryV1_Call) Return(_a0 discoveryv1.DiscoveryV1Interface) *Interface_DiscoveryV1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_DiscoveryV1_Call) RunAndReturn(run func() discoveryv1.DiscoveryV1Interface) *Interface_DiscoveryV1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // DiscoveryV1beta1 provides a mock function with given fields: |
| func (_m *Interface) DiscoveryV1beta1() discoveryv1beta1.DiscoveryV1beta1Interface { |
| ret := _m.Called() |
| |
| var r0 discoveryv1beta1.DiscoveryV1beta1Interface |
| if rf, ok := ret.Get(0).(func() discoveryv1beta1.DiscoveryV1beta1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(discoveryv1beta1.DiscoveryV1beta1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_DiscoveryV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DiscoveryV1beta1' |
| type Interface_DiscoveryV1beta1_Call struct { |
| *mock.Call |
| } |
| |
| // DiscoveryV1beta1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) DiscoveryV1beta1() *Interface_DiscoveryV1beta1_Call { |
| return &Interface_DiscoveryV1beta1_Call{Call: _e.mock.On("DiscoveryV1beta1")} |
| } |
| |
| func (_c *Interface_DiscoveryV1beta1_Call) Run(run func()) *Interface_DiscoveryV1beta1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_DiscoveryV1beta1_Call) Return(_a0 discoveryv1beta1.DiscoveryV1beta1Interface) *Interface_DiscoveryV1beta1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_DiscoveryV1beta1_Call) RunAndReturn(run func() discoveryv1beta1.DiscoveryV1beta1Interface) *Interface_DiscoveryV1beta1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // EventsV1 provides a mock function with given fields: |
| func (_m *Interface) EventsV1() eventsv1.EventsV1Interface { |
| ret := _m.Called() |
| |
| var r0 eventsv1.EventsV1Interface |
| if rf, ok := ret.Get(0).(func() eventsv1.EventsV1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(eventsv1.EventsV1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_EventsV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EventsV1' |
| type Interface_EventsV1_Call struct { |
| *mock.Call |
| } |
| |
| // EventsV1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) EventsV1() *Interface_EventsV1_Call { |
| return &Interface_EventsV1_Call{Call: _e.mock.On("EventsV1")} |
| } |
| |
| func (_c *Interface_EventsV1_Call) Run(run func()) *Interface_EventsV1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_EventsV1_Call) Return(_a0 eventsv1.EventsV1Interface) *Interface_EventsV1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_EventsV1_Call) RunAndReturn(run func() eventsv1.EventsV1Interface) *Interface_EventsV1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // EventsV1beta1 provides a mock function with given fields: |
| func (_m *Interface) EventsV1beta1() eventsv1beta1.EventsV1beta1Interface { |
| ret := _m.Called() |
| |
| var r0 eventsv1beta1.EventsV1beta1Interface |
| if rf, ok := ret.Get(0).(func() eventsv1beta1.EventsV1beta1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(eventsv1beta1.EventsV1beta1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_EventsV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EventsV1beta1' |
| type Interface_EventsV1beta1_Call struct { |
| *mock.Call |
| } |
| |
| // EventsV1beta1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) EventsV1beta1() *Interface_EventsV1beta1_Call { |
| return &Interface_EventsV1beta1_Call{Call: _e.mock.On("EventsV1beta1")} |
| } |
| |
| func (_c *Interface_EventsV1beta1_Call) Run(run func()) *Interface_EventsV1beta1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_EventsV1beta1_Call) Return(_a0 eventsv1beta1.EventsV1beta1Interface) *Interface_EventsV1beta1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_EventsV1beta1_Call) RunAndReturn(run func() eventsv1beta1.EventsV1beta1Interface) *Interface_EventsV1beta1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // ExtensionsV1beta1 provides a mock function with given fields: |
| func (_m *Interface) ExtensionsV1beta1() extensionsv1beta1.ExtensionsV1beta1Interface { |
| ret := _m.Called() |
| |
| var r0 extensionsv1beta1.ExtensionsV1beta1Interface |
| if rf, ok := ret.Get(0).(func() extensionsv1beta1.ExtensionsV1beta1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(extensionsv1beta1.ExtensionsV1beta1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_ExtensionsV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExtensionsV1beta1' |
| type Interface_ExtensionsV1beta1_Call struct { |
| *mock.Call |
| } |
| |
| // ExtensionsV1beta1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) ExtensionsV1beta1() *Interface_ExtensionsV1beta1_Call { |
| return &Interface_ExtensionsV1beta1_Call{Call: _e.mock.On("ExtensionsV1beta1")} |
| } |
| |
| func (_c *Interface_ExtensionsV1beta1_Call) Run(run func()) *Interface_ExtensionsV1beta1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_ExtensionsV1beta1_Call) Return(_a0 extensionsv1beta1.ExtensionsV1beta1Interface) *Interface_ExtensionsV1beta1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_ExtensionsV1beta1_Call) RunAndReturn(run func() extensionsv1beta1.ExtensionsV1beta1Interface) *Interface_ExtensionsV1beta1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // FlowcontrolV1alpha1 provides a mock function with given fields: |
| func (_m *Interface) FlowcontrolV1alpha1() v1alpha1.FlowcontrolV1alpha1Interface { |
| ret := _m.Called() |
| |
| var r0 v1alpha1.FlowcontrolV1alpha1Interface |
| if rf, ok := ret.Get(0).(func() v1alpha1.FlowcontrolV1alpha1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(v1alpha1.FlowcontrolV1alpha1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_FlowcontrolV1alpha1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FlowcontrolV1alpha1' |
| type Interface_FlowcontrolV1alpha1_Call struct { |
| *mock.Call |
| } |
| |
| // FlowcontrolV1alpha1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) FlowcontrolV1alpha1() *Interface_FlowcontrolV1alpha1_Call { |
| return &Interface_FlowcontrolV1alpha1_Call{Call: _e.mock.On("FlowcontrolV1alpha1")} |
| } |
| |
| func (_c *Interface_FlowcontrolV1alpha1_Call) Run(run func()) *Interface_FlowcontrolV1alpha1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_FlowcontrolV1alpha1_Call) Return(_a0 v1alpha1.FlowcontrolV1alpha1Interface) *Interface_FlowcontrolV1alpha1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_FlowcontrolV1alpha1_Call) RunAndReturn(run func() v1alpha1.FlowcontrolV1alpha1Interface) *Interface_FlowcontrolV1alpha1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // FlowcontrolV1beta1 provides a mock function with given fields: |
| func (_m *Interface) FlowcontrolV1beta1() flowcontrolv1beta1.FlowcontrolV1beta1Interface { |
| ret := _m.Called() |
| |
| var r0 flowcontrolv1beta1.FlowcontrolV1beta1Interface |
| if rf, ok := ret.Get(0).(func() flowcontrolv1beta1.FlowcontrolV1beta1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(flowcontrolv1beta1.FlowcontrolV1beta1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_FlowcontrolV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FlowcontrolV1beta1' |
| type Interface_FlowcontrolV1beta1_Call struct { |
| *mock.Call |
| } |
| |
| // FlowcontrolV1beta1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) FlowcontrolV1beta1() *Interface_FlowcontrolV1beta1_Call { |
| return &Interface_FlowcontrolV1beta1_Call{Call: _e.mock.On("FlowcontrolV1beta1")} |
| } |
| |
| func (_c *Interface_FlowcontrolV1beta1_Call) Run(run func()) *Interface_FlowcontrolV1beta1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_FlowcontrolV1beta1_Call) Return(_a0 flowcontrolv1beta1.FlowcontrolV1beta1Interface) *Interface_FlowcontrolV1beta1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_FlowcontrolV1beta1_Call) RunAndReturn(run func() flowcontrolv1beta1.FlowcontrolV1beta1Interface) *Interface_FlowcontrolV1beta1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // InternalV1alpha1 provides a mock function with given fields: |
| func (_m *Interface) InternalV1alpha1() apiserverinternalv1alpha1.InternalV1alpha1Interface { |
| ret := _m.Called() |
| |
| var r0 apiserverinternalv1alpha1.InternalV1alpha1Interface |
| if rf, ok := ret.Get(0).(func() apiserverinternalv1alpha1.InternalV1alpha1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(apiserverinternalv1alpha1.InternalV1alpha1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_InternalV1alpha1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InternalV1alpha1' |
| type Interface_InternalV1alpha1_Call struct { |
| *mock.Call |
| } |
| |
| // InternalV1alpha1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) InternalV1alpha1() *Interface_InternalV1alpha1_Call { |
| return &Interface_InternalV1alpha1_Call{Call: _e.mock.On("InternalV1alpha1")} |
| } |
| |
| func (_c *Interface_InternalV1alpha1_Call) Run(run func()) *Interface_InternalV1alpha1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_InternalV1alpha1_Call) Return(_a0 apiserverinternalv1alpha1.InternalV1alpha1Interface) *Interface_InternalV1alpha1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_InternalV1alpha1_Call) RunAndReturn(run func() apiserverinternalv1alpha1.InternalV1alpha1Interface) *Interface_InternalV1alpha1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // NetworkingV1 provides a mock function with given fields: |
| func (_m *Interface) NetworkingV1() networkingv1.NetworkingV1Interface { |
| ret := _m.Called() |
| |
| var r0 networkingv1.NetworkingV1Interface |
| if rf, ok := ret.Get(0).(func() networkingv1.NetworkingV1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(networkingv1.NetworkingV1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_NetworkingV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NetworkingV1' |
| type Interface_NetworkingV1_Call struct { |
| *mock.Call |
| } |
| |
| // NetworkingV1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) NetworkingV1() *Interface_NetworkingV1_Call { |
| return &Interface_NetworkingV1_Call{Call: _e.mock.On("NetworkingV1")} |
| } |
| |
| func (_c *Interface_NetworkingV1_Call) Run(run func()) *Interface_NetworkingV1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_NetworkingV1_Call) Return(_a0 networkingv1.NetworkingV1Interface) *Interface_NetworkingV1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_NetworkingV1_Call) RunAndReturn(run func() networkingv1.NetworkingV1Interface) *Interface_NetworkingV1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // NetworkingV1beta1 provides a mock function with given fields: |
| func (_m *Interface) NetworkingV1beta1() networkingv1beta1.NetworkingV1beta1Interface { |
| ret := _m.Called() |
| |
| var r0 networkingv1beta1.NetworkingV1beta1Interface |
| if rf, ok := ret.Get(0).(func() networkingv1beta1.NetworkingV1beta1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(networkingv1beta1.NetworkingV1beta1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_NetworkingV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NetworkingV1beta1' |
| type Interface_NetworkingV1beta1_Call struct { |
| *mock.Call |
| } |
| |
| // NetworkingV1beta1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) NetworkingV1beta1() *Interface_NetworkingV1beta1_Call { |
| return &Interface_NetworkingV1beta1_Call{Call: _e.mock.On("NetworkingV1beta1")} |
| } |
| |
| func (_c *Interface_NetworkingV1beta1_Call) Run(run func()) *Interface_NetworkingV1beta1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_NetworkingV1beta1_Call) Return(_a0 networkingv1beta1.NetworkingV1beta1Interface) *Interface_NetworkingV1beta1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_NetworkingV1beta1_Call) RunAndReturn(run func() networkingv1beta1.NetworkingV1beta1Interface) *Interface_NetworkingV1beta1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // NodeV1 provides a mock function with given fields: |
| func (_m *Interface) NodeV1() nodev1.NodeV1Interface { |
| ret := _m.Called() |
| |
| var r0 nodev1.NodeV1Interface |
| if rf, ok := ret.Get(0).(func() nodev1.NodeV1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(nodev1.NodeV1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_NodeV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NodeV1' |
| type Interface_NodeV1_Call struct { |
| *mock.Call |
| } |
| |
| // NodeV1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) NodeV1() *Interface_NodeV1_Call { |
| return &Interface_NodeV1_Call{Call: _e.mock.On("NodeV1")} |
| } |
| |
| func (_c *Interface_NodeV1_Call) Run(run func()) *Interface_NodeV1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_NodeV1_Call) Return(_a0 nodev1.NodeV1Interface) *Interface_NodeV1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_NodeV1_Call) RunAndReturn(run func() nodev1.NodeV1Interface) *Interface_NodeV1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // NodeV1alpha1 provides a mock function with given fields: |
| func (_m *Interface) NodeV1alpha1() nodev1alpha1.NodeV1alpha1Interface { |
| ret := _m.Called() |
| |
| var r0 nodev1alpha1.NodeV1alpha1Interface |
| if rf, ok := ret.Get(0).(func() nodev1alpha1.NodeV1alpha1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(nodev1alpha1.NodeV1alpha1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_NodeV1alpha1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NodeV1alpha1' |
| type Interface_NodeV1alpha1_Call struct { |
| *mock.Call |
| } |
| |
| // NodeV1alpha1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) NodeV1alpha1() *Interface_NodeV1alpha1_Call { |
| return &Interface_NodeV1alpha1_Call{Call: _e.mock.On("NodeV1alpha1")} |
| } |
| |
| func (_c *Interface_NodeV1alpha1_Call) Run(run func()) *Interface_NodeV1alpha1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_NodeV1alpha1_Call) Return(_a0 nodev1alpha1.NodeV1alpha1Interface) *Interface_NodeV1alpha1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_NodeV1alpha1_Call) RunAndReturn(run func() nodev1alpha1.NodeV1alpha1Interface) *Interface_NodeV1alpha1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // NodeV1beta1 provides a mock function with given fields: |
| func (_m *Interface) NodeV1beta1() nodev1beta1.NodeV1beta1Interface { |
| ret := _m.Called() |
| |
| var r0 nodev1beta1.NodeV1beta1Interface |
| if rf, ok := ret.Get(0).(func() nodev1beta1.NodeV1beta1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(nodev1beta1.NodeV1beta1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_NodeV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NodeV1beta1' |
| type Interface_NodeV1beta1_Call struct { |
| *mock.Call |
| } |
| |
| // NodeV1beta1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) NodeV1beta1() *Interface_NodeV1beta1_Call { |
| return &Interface_NodeV1beta1_Call{Call: _e.mock.On("NodeV1beta1")} |
| } |
| |
| func (_c *Interface_NodeV1beta1_Call) Run(run func()) *Interface_NodeV1beta1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_NodeV1beta1_Call) Return(_a0 nodev1beta1.NodeV1beta1Interface) *Interface_NodeV1beta1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_NodeV1beta1_Call) RunAndReturn(run func() nodev1beta1.NodeV1beta1Interface) *Interface_NodeV1beta1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // PolicyV1 provides a mock function with given fields: |
| func (_m *Interface) PolicyV1() policyv1.PolicyV1Interface { |
| ret := _m.Called() |
| |
| var r0 policyv1.PolicyV1Interface |
| if rf, ok := ret.Get(0).(func() policyv1.PolicyV1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(policyv1.PolicyV1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_PolicyV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PolicyV1' |
| type Interface_PolicyV1_Call struct { |
| *mock.Call |
| } |
| |
| // PolicyV1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) PolicyV1() *Interface_PolicyV1_Call { |
| return &Interface_PolicyV1_Call{Call: _e.mock.On("PolicyV1")} |
| } |
| |
| func (_c *Interface_PolicyV1_Call) Run(run func()) *Interface_PolicyV1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_PolicyV1_Call) Return(_a0 policyv1.PolicyV1Interface) *Interface_PolicyV1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_PolicyV1_Call) RunAndReturn(run func() policyv1.PolicyV1Interface) *Interface_PolicyV1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // PolicyV1beta1 provides a mock function with given fields: |
| func (_m *Interface) PolicyV1beta1() policyv1beta1.PolicyV1beta1Interface { |
| ret := _m.Called() |
| |
| var r0 policyv1beta1.PolicyV1beta1Interface |
| if rf, ok := ret.Get(0).(func() policyv1beta1.PolicyV1beta1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(policyv1beta1.PolicyV1beta1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_PolicyV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PolicyV1beta1' |
| type Interface_PolicyV1beta1_Call struct { |
| *mock.Call |
| } |
| |
| // PolicyV1beta1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) PolicyV1beta1() *Interface_PolicyV1beta1_Call { |
| return &Interface_PolicyV1beta1_Call{Call: _e.mock.On("PolicyV1beta1")} |
| } |
| |
| func (_c *Interface_PolicyV1beta1_Call) Run(run func()) *Interface_PolicyV1beta1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_PolicyV1beta1_Call) Return(_a0 policyv1beta1.PolicyV1beta1Interface) *Interface_PolicyV1beta1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_PolicyV1beta1_Call) RunAndReturn(run func() policyv1beta1.PolicyV1beta1Interface) *Interface_PolicyV1beta1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // RbacV1 provides a mock function with given fields: |
| func (_m *Interface) RbacV1() rbacv1.RbacV1Interface { |
| ret := _m.Called() |
| |
| var r0 rbacv1.RbacV1Interface |
| if rf, ok := ret.Get(0).(func() rbacv1.RbacV1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(rbacv1.RbacV1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_RbacV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RbacV1' |
| type Interface_RbacV1_Call struct { |
| *mock.Call |
| } |
| |
| // RbacV1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) RbacV1() *Interface_RbacV1_Call { |
| return &Interface_RbacV1_Call{Call: _e.mock.On("RbacV1")} |
| } |
| |
| func (_c *Interface_RbacV1_Call) Run(run func()) *Interface_RbacV1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_RbacV1_Call) Return(_a0 rbacv1.RbacV1Interface) *Interface_RbacV1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_RbacV1_Call) RunAndReturn(run func() rbacv1.RbacV1Interface) *Interface_RbacV1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // RbacV1alpha1 provides a mock function with given fields: |
| func (_m *Interface) RbacV1alpha1() rbacv1alpha1.RbacV1alpha1Interface { |
| ret := _m.Called() |
| |
| var r0 rbacv1alpha1.RbacV1alpha1Interface |
| if rf, ok := ret.Get(0).(func() rbacv1alpha1.RbacV1alpha1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(rbacv1alpha1.RbacV1alpha1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_RbacV1alpha1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RbacV1alpha1' |
| type Interface_RbacV1alpha1_Call struct { |
| *mock.Call |
| } |
| |
| // RbacV1alpha1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) RbacV1alpha1() *Interface_RbacV1alpha1_Call { |
| return &Interface_RbacV1alpha1_Call{Call: _e.mock.On("RbacV1alpha1")} |
| } |
| |
| func (_c *Interface_RbacV1alpha1_Call) Run(run func()) *Interface_RbacV1alpha1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_RbacV1alpha1_Call) Return(_a0 rbacv1alpha1.RbacV1alpha1Interface) *Interface_RbacV1alpha1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_RbacV1alpha1_Call) RunAndReturn(run func() rbacv1alpha1.RbacV1alpha1Interface) *Interface_RbacV1alpha1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // RbacV1beta1 provides a mock function with given fields: |
| func (_m *Interface) RbacV1beta1() rbacv1beta1.RbacV1beta1Interface { |
| ret := _m.Called() |
| |
| var r0 rbacv1beta1.RbacV1beta1Interface |
| if rf, ok := ret.Get(0).(func() rbacv1beta1.RbacV1beta1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(rbacv1beta1.RbacV1beta1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_RbacV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RbacV1beta1' |
| type Interface_RbacV1beta1_Call struct { |
| *mock.Call |
| } |
| |
| // RbacV1beta1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) RbacV1beta1() *Interface_RbacV1beta1_Call { |
| return &Interface_RbacV1beta1_Call{Call: _e.mock.On("RbacV1beta1")} |
| } |
| |
| func (_c *Interface_RbacV1beta1_Call) Run(run func()) *Interface_RbacV1beta1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_RbacV1beta1_Call) Return(_a0 rbacv1beta1.RbacV1beta1Interface) *Interface_RbacV1beta1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_RbacV1beta1_Call) RunAndReturn(run func() rbacv1beta1.RbacV1beta1Interface) *Interface_RbacV1beta1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // SchedulingV1 provides a mock function with given fields: |
| func (_m *Interface) SchedulingV1() schedulingv1.SchedulingV1Interface { |
| ret := _m.Called() |
| |
| var r0 schedulingv1.SchedulingV1Interface |
| if rf, ok := ret.Get(0).(func() schedulingv1.SchedulingV1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(schedulingv1.SchedulingV1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_SchedulingV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SchedulingV1' |
| type Interface_SchedulingV1_Call struct { |
| *mock.Call |
| } |
| |
| // SchedulingV1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) SchedulingV1() *Interface_SchedulingV1_Call { |
| return &Interface_SchedulingV1_Call{Call: _e.mock.On("SchedulingV1")} |
| } |
| |
| func (_c *Interface_SchedulingV1_Call) Run(run func()) *Interface_SchedulingV1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_SchedulingV1_Call) Return(_a0 schedulingv1.SchedulingV1Interface) *Interface_SchedulingV1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_SchedulingV1_Call) RunAndReturn(run func() schedulingv1.SchedulingV1Interface) *Interface_SchedulingV1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // SchedulingV1alpha1 provides a mock function with given fields: |
| func (_m *Interface) SchedulingV1alpha1() schedulingv1alpha1.SchedulingV1alpha1Interface { |
| ret := _m.Called() |
| |
| var r0 schedulingv1alpha1.SchedulingV1alpha1Interface |
| if rf, ok := ret.Get(0).(func() schedulingv1alpha1.SchedulingV1alpha1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(schedulingv1alpha1.SchedulingV1alpha1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_SchedulingV1alpha1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SchedulingV1alpha1' |
| type Interface_SchedulingV1alpha1_Call struct { |
| *mock.Call |
| } |
| |
| // SchedulingV1alpha1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) SchedulingV1alpha1() *Interface_SchedulingV1alpha1_Call { |
| return &Interface_SchedulingV1alpha1_Call{Call: _e.mock.On("SchedulingV1alpha1")} |
| } |
| |
| func (_c *Interface_SchedulingV1alpha1_Call) Run(run func()) *Interface_SchedulingV1alpha1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_SchedulingV1alpha1_Call) Return(_a0 schedulingv1alpha1.SchedulingV1alpha1Interface) *Interface_SchedulingV1alpha1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_SchedulingV1alpha1_Call) RunAndReturn(run func() schedulingv1alpha1.SchedulingV1alpha1Interface) *Interface_SchedulingV1alpha1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // SchedulingV1beta1 provides a mock function with given fields: |
| func (_m *Interface) SchedulingV1beta1() schedulingv1beta1.SchedulingV1beta1Interface { |
| ret := _m.Called() |
| |
| var r0 schedulingv1beta1.SchedulingV1beta1Interface |
| if rf, ok := ret.Get(0).(func() schedulingv1beta1.SchedulingV1beta1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(schedulingv1beta1.SchedulingV1beta1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_SchedulingV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SchedulingV1beta1' |
| type Interface_SchedulingV1beta1_Call struct { |
| *mock.Call |
| } |
| |
| // SchedulingV1beta1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) SchedulingV1beta1() *Interface_SchedulingV1beta1_Call { |
| return &Interface_SchedulingV1beta1_Call{Call: _e.mock.On("SchedulingV1beta1")} |
| } |
| |
| func (_c *Interface_SchedulingV1beta1_Call) Run(run func()) *Interface_SchedulingV1beta1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_SchedulingV1beta1_Call) Return(_a0 schedulingv1beta1.SchedulingV1beta1Interface) *Interface_SchedulingV1beta1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_SchedulingV1beta1_Call) RunAndReturn(run func() schedulingv1beta1.SchedulingV1beta1Interface) *Interface_SchedulingV1beta1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // StorageV1 provides a mock function with given fields: |
| func (_m *Interface) StorageV1() storagev1.StorageV1Interface { |
| ret := _m.Called() |
| |
| var r0 storagev1.StorageV1Interface |
| if rf, ok := ret.Get(0).(func() storagev1.StorageV1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(storagev1.StorageV1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_StorageV1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StorageV1' |
| type Interface_StorageV1_Call struct { |
| *mock.Call |
| } |
| |
| // StorageV1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) StorageV1() *Interface_StorageV1_Call { |
| return &Interface_StorageV1_Call{Call: _e.mock.On("StorageV1")} |
| } |
| |
| func (_c *Interface_StorageV1_Call) Run(run func()) *Interface_StorageV1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_StorageV1_Call) Return(_a0 storagev1.StorageV1Interface) *Interface_StorageV1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_StorageV1_Call) RunAndReturn(run func() storagev1.StorageV1Interface) *Interface_StorageV1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // StorageV1alpha1 provides a mock function with given fields: |
| func (_m *Interface) StorageV1alpha1() storagev1alpha1.StorageV1alpha1Interface { |
| ret := _m.Called() |
| |
| var r0 storagev1alpha1.StorageV1alpha1Interface |
| if rf, ok := ret.Get(0).(func() storagev1alpha1.StorageV1alpha1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(storagev1alpha1.StorageV1alpha1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_StorageV1alpha1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StorageV1alpha1' |
| type Interface_StorageV1alpha1_Call struct { |
| *mock.Call |
| } |
| |
| // StorageV1alpha1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) StorageV1alpha1() *Interface_StorageV1alpha1_Call { |
| return &Interface_StorageV1alpha1_Call{Call: _e.mock.On("StorageV1alpha1")} |
| } |
| |
| func (_c *Interface_StorageV1alpha1_Call) Run(run func()) *Interface_StorageV1alpha1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_StorageV1alpha1_Call) Return(_a0 storagev1alpha1.StorageV1alpha1Interface) *Interface_StorageV1alpha1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_StorageV1alpha1_Call) RunAndReturn(run func() storagev1alpha1.StorageV1alpha1Interface) *Interface_StorageV1alpha1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| // StorageV1beta1 provides a mock function with given fields: |
| func (_m *Interface) StorageV1beta1() storagev1beta1.StorageV1beta1Interface { |
| ret := _m.Called() |
| |
| var r0 storagev1beta1.StorageV1beta1Interface |
| if rf, ok := ret.Get(0).(func() storagev1beta1.StorageV1beta1Interface); ok { |
| r0 = rf() |
| } else { |
| if ret.Get(0) != nil { |
| r0 = ret.Get(0).(storagev1beta1.StorageV1beta1Interface) |
| } |
| } |
| |
| return r0 |
| } |
| |
| // Interface_StorageV1beta1_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StorageV1beta1' |
| type Interface_StorageV1beta1_Call struct { |
| *mock.Call |
| } |
| |
| // StorageV1beta1 is a helper method to define mock.On call |
| func (_e *Interface_Expecter) StorageV1beta1() *Interface_StorageV1beta1_Call { |
| return &Interface_StorageV1beta1_Call{Call: _e.mock.On("StorageV1beta1")} |
| } |
| |
| func (_c *Interface_StorageV1beta1_Call) Run(run func()) *Interface_StorageV1beta1_Call { |
| _c.Call.Run(func(args mock.Arguments) { |
| run() |
| }) |
| return _c |
| } |
| |
| func (_c *Interface_StorageV1beta1_Call) Return(_a0 storagev1beta1.StorageV1beta1Interface) *Interface_StorageV1beta1_Call { |
| _c.Call.Return(_a0) |
| return _c |
| } |
| |
| func (_c *Interface_StorageV1beta1_Call) RunAndReturn(run func() storagev1beta1.StorageV1beta1Interface) *Interface_StorageV1beta1_Call { |
| _c.Call.Return(run) |
| return _c |
| } |
| |
| type mockConstructorTestingTNewInterface interface { |
| mock.TestingT |
| Cleanup(func()) |
| } |
| |
| // NewInterface creates a new instance of Interface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. |
| func NewInterface(t mockConstructorTestingTNewInterface) *Interface { |
| mock := &Interface{} |
| mock.Mock.Test(t) |
| |
| t.Cleanup(func() { mock.AssertExpectations(t) }) |
| |
| return mock |
| } |