1
2
3
4 package kubecli
5
6 import (
7 context "context"
8 time "time"
9
10 gomock "github.com/golang/mock/gomock"
11 v1 "github.com/openshift/client-go/route/clientset/versioned/typed/route/v1"
12 v10 "github.com/openshift/client-go/security/clientset/versioned/typed/security/v1"
13 v11 "k8s.io/api/autoscaling/v1"
14 clientset "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset"
15 v12 "k8s.io/apimachinery/pkg/apis/meta/v1"
16 types "k8s.io/apimachinery/pkg/types"
17 watch "k8s.io/apimachinery/pkg/watch"
18 discovery "k8s.io/client-go/discovery"
19 dynamic "k8s.io/client-go/dynamic"
20 v13 "k8s.io/client-go/kubernetes/typed/admissionregistration/v1"
21 v1alpha1 "k8s.io/client-go/kubernetes/typed/admissionregistration/v1alpha1"
22 v1beta1 "k8s.io/client-go/kubernetes/typed/admissionregistration/v1beta1"
23 v1alpha10 "k8s.io/client-go/kubernetes/typed/apiserverinternal/v1alpha1"
24 v14 "k8s.io/client-go/kubernetes/typed/apps/v1"
25 v1beta10 "k8s.io/client-go/kubernetes/typed/apps/v1beta1"
26 v1beta2 "k8s.io/client-go/kubernetes/typed/apps/v1beta2"
27 v15 "k8s.io/client-go/kubernetes/typed/authentication/v1"
28 v1alpha11 "k8s.io/client-go/kubernetes/typed/authentication/v1alpha1"
29 v1beta11 "k8s.io/client-go/kubernetes/typed/authentication/v1beta1"
30 v16 "k8s.io/client-go/kubernetes/typed/authorization/v1"
31 v1beta12 "k8s.io/client-go/kubernetes/typed/authorization/v1beta1"
32 v17 "k8s.io/client-go/kubernetes/typed/autoscaling/v1"
33 v2 "k8s.io/client-go/kubernetes/typed/autoscaling/v2"
34 v2beta1 "k8s.io/client-go/kubernetes/typed/autoscaling/v2beta1"
35 v2beta2 "k8s.io/client-go/kubernetes/typed/autoscaling/v2beta2"
36 v18 "k8s.io/client-go/kubernetes/typed/batch/v1"
37 v1beta13 "k8s.io/client-go/kubernetes/typed/batch/v1beta1"
38 v19 "k8s.io/client-go/kubernetes/typed/certificates/v1"
39 v1alpha12 "k8s.io/client-go/kubernetes/typed/certificates/v1alpha1"
40 v1beta14 "k8s.io/client-go/kubernetes/typed/certificates/v1beta1"
41 v110 "k8s.io/client-go/kubernetes/typed/coordination/v1"
42 v1beta15 "k8s.io/client-go/kubernetes/typed/coordination/v1beta1"
43 v111 "k8s.io/client-go/kubernetes/typed/core/v1"
44 v112 "k8s.io/client-go/kubernetes/typed/discovery/v1"
45 v1beta16 "k8s.io/client-go/kubernetes/typed/discovery/v1beta1"
46 v113 "k8s.io/client-go/kubernetes/typed/events/v1"
47 v1beta17 "k8s.io/client-go/kubernetes/typed/events/v1beta1"
48 v1beta18 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
49 v114 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1"
50 v1beta19 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta1"
51 v1beta20 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta2"
52 v1beta3 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta3"
53 v115 "k8s.io/client-go/kubernetes/typed/networking/v1"
54 v1alpha13 "k8s.io/client-go/kubernetes/typed/networking/v1alpha1"
55 v1beta110 "k8s.io/client-go/kubernetes/typed/networking/v1beta1"
56 v116 "k8s.io/client-go/kubernetes/typed/node/v1"
57 v1alpha14 "k8s.io/client-go/kubernetes/typed/node/v1alpha1"
58 v1beta111 "k8s.io/client-go/kubernetes/typed/node/v1beta1"
59 v117 "k8s.io/client-go/kubernetes/typed/policy/v1"
60 v1beta112 "k8s.io/client-go/kubernetes/typed/policy/v1beta1"
61 v118 "k8s.io/client-go/kubernetes/typed/rbac/v1"
62 v1alpha15 "k8s.io/client-go/kubernetes/typed/rbac/v1alpha1"
63 v1beta113 "k8s.io/client-go/kubernetes/typed/rbac/v1beta1"
64 v1alpha2 "k8s.io/client-go/kubernetes/typed/resource/v1alpha2"
65 v119 "k8s.io/client-go/kubernetes/typed/scheduling/v1"
66 v1alpha16 "k8s.io/client-go/kubernetes/typed/scheduling/v1alpha1"
67 v1beta114 "k8s.io/client-go/kubernetes/typed/scheduling/v1beta1"
68 v120 "k8s.io/client-go/kubernetes/typed/storage/v1"
69 v1alpha17 "k8s.io/client-go/kubernetes/typed/storage/v1alpha1"
70 v1beta115 "k8s.io/client-go/kubernetes/typed/storage/v1beta1"
71 v1alpha18 "k8s.io/client-go/kubernetes/typed/storagemigration/v1alpha1"
72 rest "k8s.io/client-go/rest"
73 v121 "kubevirt.io/api/core/v1"
74 versioned "kubevirt.io/client-go/generated/containerized-data-importer/clientset/versioned"
75 versioned0 "kubevirt.io/client-go/generated/external-snapshotter/clientset/versioned"
76 versioned1 "kubevirt.io/client-go/generated/kubevirt/clientset/versioned"
77 v1alpha19 "kubevirt.io/client-go/generated/kubevirt/clientset/versioned/typed/clone/v1alpha1"
78 v122 "kubevirt.io/client-go/generated/kubevirt/clientset/versioned/typed/core/v1"
79 v1beta116 "kubevirt.io/client-go/generated/kubevirt/clientset/versioned/typed/export/v1beta1"
80 v1beta117 "kubevirt.io/client-go/generated/kubevirt/clientset/versioned/typed/instancetype/v1beta1"
81 v1alpha110 "kubevirt.io/client-go/generated/kubevirt/clientset/versioned/typed/migrations/v1alpha1"
82 v1alpha111 "kubevirt.io/client-go/generated/kubevirt/clientset/versioned/typed/pool/v1alpha1"
83 v1beta118 "kubevirt.io/client-go/generated/kubevirt/clientset/versioned/typed/snapshot/v1beta1"
84 versioned2 "kubevirt.io/client-go/generated/network-attachment-definition-client/clientset/versioned"
85 versioned3 "kubevirt.io/client-go/generated/prometheus-operator/clientset/versioned"
86 version "kubevirt.io/client-go/version"
87 )
88
89
90 type MockKubevirtClient struct {
91 ctrl *gomock.Controller
92 recorder *_MockKubevirtClientRecorder
93 }
94
95
96 type _MockKubevirtClientRecorder struct {
97 mock *MockKubevirtClient
98 }
99
100 func NewMockKubevirtClient(ctrl *gomock.Controller) *MockKubevirtClient {
101 mock := &MockKubevirtClient{ctrl: ctrl}
102 mock.recorder = &_MockKubevirtClientRecorder{mock}
103 return mock
104 }
105
106 func (_m *MockKubevirtClient) EXPECT() *_MockKubevirtClientRecorder {
107 return _m.recorder
108 }
109
110 func (_m *MockKubevirtClient) VirtualMachineInstance(namespace string) VirtualMachineInstanceInterface {
111 ret := _m.ctrl.Call(_m, "VirtualMachineInstance", namespace)
112 ret0, _ := ret[0].(VirtualMachineInstanceInterface)
113 return ret0
114 }
115
116 func (_mr *_MockKubevirtClientRecorder) VirtualMachineInstance(arg0 interface{}) *gomock.Call {
117 return _mr.mock.ctrl.RecordCall(_mr.mock, "VirtualMachineInstance", arg0)
118 }
119
120 func (_m *MockKubevirtClient) VirtualMachineInstanceMigration(namespace string) VirtualMachineInstanceMigrationInterface {
121 ret := _m.ctrl.Call(_m, "VirtualMachineInstanceMigration", namespace)
122 ret0, _ := ret[0].(VirtualMachineInstanceMigrationInterface)
123 return ret0
124 }
125
126 func (_mr *_MockKubevirtClientRecorder) VirtualMachineInstanceMigration(arg0 interface{}) *gomock.Call {
127 return _mr.mock.ctrl.RecordCall(_mr.mock, "VirtualMachineInstanceMigration", arg0)
128 }
129
130 func (_m *MockKubevirtClient) ReplicaSet(namespace string) ReplicaSetInterface {
131 ret := _m.ctrl.Call(_m, "ReplicaSet", namespace)
132 ret0, _ := ret[0].(ReplicaSetInterface)
133 return ret0
134 }
135
136 func (_mr *_MockKubevirtClientRecorder) ReplicaSet(arg0 interface{}) *gomock.Call {
137 return _mr.mock.ctrl.RecordCall(_mr.mock, "ReplicaSet", arg0)
138 }
139
140 func (_m *MockKubevirtClient) VirtualMachinePool(namespace string) v1alpha111.VirtualMachinePoolInterface {
141 ret := _m.ctrl.Call(_m, "VirtualMachinePool", namespace)
142 ret0, _ := ret[0].(v1alpha111.VirtualMachinePoolInterface)
143 return ret0
144 }
145
146 func (_mr *_MockKubevirtClientRecorder) VirtualMachinePool(arg0 interface{}) *gomock.Call {
147 return _mr.mock.ctrl.RecordCall(_mr.mock, "VirtualMachinePool", arg0)
148 }
149
150 func (_m *MockKubevirtClient) VirtualMachine(namespace string) VirtualMachineInterface {
151 ret := _m.ctrl.Call(_m, "VirtualMachine", namespace)
152 ret0, _ := ret[0].(VirtualMachineInterface)
153 return ret0
154 }
155
156 func (_mr *_MockKubevirtClientRecorder) VirtualMachine(arg0 interface{}) *gomock.Call {
157 return _mr.mock.ctrl.RecordCall(_mr.mock, "VirtualMachine", arg0)
158 }
159
160 func (_m *MockKubevirtClient) KubeVirt(namespace string) KubeVirtInterface {
161 ret := _m.ctrl.Call(_m, "KubeVirt", namespace)
162 ret0, _ := ret[0].(KubeVirtInterface)
163 return ret0
164 }
165
166 func (_mr *_MockKubevirtClientRecorder) KubeVirt(arg0 interface{}) *gomock.Call {
167 return _mr.mock.ctrl.RecordCall(_mr.mock, "KubeVirt", arg0)
168 }
169
170 func (_m *MockKubevirtClient) VirtualMachineInstancePreset(namespace string) VirtualMachineInstancePresetInterface {
171 ret := _m.ctrl.Call(_m, "VirtualMachineInstancePreset", namespace)
172 ret0, _ := ret[0].(VirtualMachineInstancePresetInterface)
173 return ret0
174 }
175
176 func (_mr *_MockKubevirtClientRecorder) VirtualMachineInstancePreset(arg0 interface{}) *gomock.Call {
177 return _mr.mock.ctrl.RecordCall(_mr.mock, "VirtualMachineInstancePreset", arg0)
178 }
179
180 func (_m *MockKubevirtClient) VirtualMachineSnapshot(namespace string) v1beta118.VirtualMachineSnapshotInterface {
181 ret := _m.ctrl.Call(_m, "VirtualMachineSnapshot", namespace)
182 ret0, _ := ret[0].(v1beta118.VirtualMachineSnapshotInterface)
183 return ret0
184 }
185
186 func (_mr *_MockKubevirtClientRecorder) VirtualMachineSnapshot(arg0 interface{}) *gomock.Call {
187 return _mr.mock.ctrl.RecordCall(_mr.mock, "VirtualMachineSnapshot", arg0)
188 }
189
190 func (_m *MockKubevirtClient) VirtualMachineSnapshotContent(namespace string) v1beta118.VirtualMachineSnapshotContentInterface {
191 ret := _m.ctrl.Call(_m, "VirtualMachineSnapshotContent", namespace)
192 ret0, _ := ret[0].(v1beta118.VirtualMachineSnapshotContentInterface)
193 return ret0
194 }
195
196 func (_mr *_MockKubevirtClientRecorder) VirtualMachineSnapshotContent(arg0 interface{}) *gomock.Call {
197 return _mr.mock.ctrl.RecordCall(_mr.mock, "VirtualMachineSnapshotContent", arg0)
198 }
199
200 func (_m *MockKubevirtClient) VirtualMachineRestore(namespace string) v1beta118.VirtualMachineRestoreInterface {
201 ret := _m.ctrl.Call(_m, "VirtualMachineRestore", namespace)
202 ret0, _ := ret[0].(v1beta118.VirtualMachineRestoreInterface)
203 return ret0
204 }
205
206 func (_mr *_MockKubevirtClientRecorder) VirtualMachineRestore(arg0 interface{}) *gomock.Call {
207 return _mr.mock.ctrl.RecordCall(_mr.mock, "VirtualMachineRestore", arg0)
208 }
209
210 func (_m *MockKubevirtClient) VirtualMachineExport(namespace string) v1beta116.VirtualMachineExportInterface {
211 ret := _m.ctrl.Call(_m, "VirtualMachineExport", namespace)
212 ret0, _ := ret[0].(v1beta116.VirtualMachineExportInterface)
213 return ret0
214 }
215
216 func (_mr *_MockKubevirtClientRecorder) VirtualMachineExport(arg0 interface{}) *gomock.Call {
217 return _mr.mock.ctrl.RecordCall(_mr.mock, "VirtualMachineExport", arg0)
218 }
219
220 func (_m *MockKubevirtClient) VirtualMachineInstancetype(namespace string) v1beta117.VirtualMachineInstancetypeInterface {
221 ret := _m.ctrl.Call(_m, "VirtualMachineInstancetype", namespace)
222 ret0, _ := ret[0].(v1beta117.VirtualMachineInstancetypeInterface)
223 return ret0
224 }
225
226 func (_mr *_MockKubevirtClientRecorder) VirtualMachineInstancetype(arg0 interface{}) *gomock.Call {
227 return _mr.mock.ctrl.RecordCall(_mr.mock, "VirtualMachineInstancetype", arg0)
228 }
229
230 func (_m *MockKubevirtClient) VirtualMachineClusterInstancetype() v1beta117.VirtualMachineClusterInstancetypeInterface {
231 ret := _m.ctrl.Call(_m, "VirtualMachineClusterInstancetype")
232 ret0, _ := ret[0].(v1beta117.VirtualMachineClusterInstancetypeInterface)
233 return ret0
234 }
235
236 func (_mr *_MockKubevirtClientRecorder) VirtualMachineClusterInstancetype() *gomock.Call {
237 return _mr.mock.ctrl.RecordCall(_mr.mock, "VirtualMachineClusterInstancetype")
238 }
239
240 func (_m *MockKubevirtClient) VirtualMachinePreference(namespace string) v1beta117.VirtualMachinePreferenceInterface {
241 ret := _m.ctrl.Call(_m, "VirtualMachinePreference", namespace)
242 ret0, _ := ret[0].(v1beta117.VirtualMachinePreferenceInterface)
243 return ret0
244 }
245
246 func (_mr *_MockKubevirtClientRecorder) VirtualMachinePreference(arg0 interface{}) *gomock.Call {
247 return _mr.mock.ctrl.RecordCall(_mr.mock, "VirtualMachinePreference", arg0)
248 }
249
250 func (_m *MockKubevirtClient) VirtualMachineClusterPreference() v1beta117.VirtualMachineClusterPreferenceInterface {
251 ret := _m.ctrl.Call(_m, "VirtualMachineClusterPreference")
252 ret0, _ := ret[0].(v1beta117.VirtualMachineClusterPreferenceInterface)
253 return ret0
254 }
255
256 func (_mr *_MockKubevirtClientRecorder) VirtualMachineClusterPreference() *gomock.Call {
257 return _mr.mock.ctrl.RecordCall(_mr.mock, "VirtualMachineClusterPreference")
258 }
259
260 func (_m *MockKubevirtClient) MigrationPolicy() v1alpha110.MigrationPolicyInterface {
261 ret := _m.ctrl.Call(_m, "MigrationPolicy")
262 ret0, _ := ret[0].(v1alpha110.MigrationPolicyInterface)
263 return ret0
264 }
265
266 func (_mr *_MockKubevirtClientRecorder) MigrationPolicy() *gomock.Call {
267 return _mr.mock.ctrl.RecordCall(_mr.mock, "MigrationPolicy")
268 }
269
270 func (_m *MockKubevirtClient) ExpandSpec(namespace string) ExpandSpecInterface {
271 ret := _m.ctrl.Call(_m, "ExpandSpec", namespace)
272 ret0, _ := ret[0].(ExpandSpecInterface)
273 return ret0
274 }
275
276 func (_mr *_MockKubevirtClientRecorder) ExpandSpec(arg0 interface{}) *gomock.Call {
277 return _mr.mock.ctrl.RecordCall(_mr.mock, "ExpandSpec", arg0)
278 }
279
280 func (_m *MockKubevirtClient) ServerVersion() ServerVersionInterface {
281 ret := _m.ctrl.Call(_m, "ServerVersion")
282 ret0, _ := ret[0].(ServerVersionInterface)
283 return ret0
284 }
285
286 func (_mr *_MockKubevirtClientRecorder) ServerVersion() *gomock.Call {
287 return _mr.mock.ctrl.RecordCall(_mr.mock, "ServerVersion")
288 }
289
290 func (_m *MockKubevirtClient) VirtualMachineClone(namespace string) v1alpha19.VirtualMachineCloneInterface {
291 ret := _m.ctrl.Call(_m, "VirtualMachineClone", namespace)
292 ret0, _ := ret[0].(v1alpha19.VirtualMachineCloneInterface)
293 return ret0
294 }
295
296 func (_mr *_MockKubevirtClientRecorder) VirtualMachineClone(arg0 interface{}) *gomock.Call {
297 return _mr.mock.ctrl.RecordCall(_mr.mock, "VirtualMachineClone", arg0)
298 }
299
300 func (_m *MockKubevirtClient) ClusterProfiler() *ClusterProfiler {
301 ret := _m.ctrl.Call(_m, "ClusterProfiler")
302 ret0, _ := ret[0].(*ClusterProfiler)
303 return ret0
304 }
305
306 func (_mr *_MockKubevirtClientRecorder) ClusterProfiler() *gomock.Call {
307 return _mr.mock.ctrl.RecordCall(_mr.mock, "ClusterProfiler")
308 }
309
310 func (_m *MockKubevirtClient) GuestfsVersion() *GuestfsVersion {
311 ret := _m.ctrl.Call(_m, "GuestfsVersion")
312 ret0, _ := ret[0].(*GuestfsVersion)
313 return ret0
314 }
315
316 func (_mr *_MockKubevirtClientRecorder) GuestfsVersion() *gomock.Call {
317 return _mr.mock.ctrl.RecordCall(_mr.mock, "GuestfsVersion")
318 }
319
320 func (_m *MockKubevirtClient) RestClient() *rest.RESTClient {
321 ret := _m.ctrl.Call(_m, "RestClient")
322 ret0, _ := ret[0].(*rest.RESTClient)
323 return ret0
324 }
325
326 func (_mr *_MockKubevirtClientRecorder) RestClient() *gomock.Call {
327 return _mr.mock.ctrl.RecordCall(_mr.mock, "RestClient")
328 }
329
330 func (_m *MockKubevirtClient) GeneratedKubeVirtClient() versioned1.Interface {
331 ret := _m.ctrl.Call(_m, "GeneratedKubeVirtClient")
332 ret0, _ := ret[0].(versioned1.Interface)
333 return ret0
334 }
335
336 func (_mr *_MockKubevirtClientRecorder) GeneratedKubeVirtClient() *gomock.Call {
337 return _mr.mock.ctrl.RecordCall(_mr.mock, "GeneratedKubeVirtClient")
338 }
339
340 func (_m *MockKubevirtClient) CdiClient() versioned.Interface {
341 ret := _m.ctrl.Call(_m, "CdiClient")
342 ret0, _ := ret[0].(versioned.Interface)
343 return ret0
344 }
345
346 func (_mr *_MockKubevirtClientRecorder) CdiClient() *gomock.Call {
347 return _mr.mock.ctrl.RecordCall(_mr.mock, "CdiClient")
348 }
349
350 func (_m *MockKubevirtClient) NetworkClient() versioned2.Interface {
351 ret := _m.ctrl.Call(_m, "NetworkClient")
352 ret0, _ := ret[0].(versioned2.Interface)
353 return ret0
354 }
355
356 func (_mr *_MockKubevirtClientRecorder) NetworkClient() *gomock.Call {
357 return _mr.mock.ctrl.RecordCall(_mr.mock, "NetworkClient")
358 }
359
360 func (_m *MockKubevirtClient) ExtensionsClient() clientset.Interface {
361 ret := _m.ctrl.Call(_m, "ExtensionsClient")
362 ret0, _ := ret[0].(clientset.Interface)
363 return ret0
364 }
365
366 func (_mr *_MockKubevirtClientRecorder) ExtensionsClient() *gomock.Call {
367 return _mr.mock.ctrl.RecordCall(_mr.mock, "ExtensionsClient")
368 }
369
370 func (_m *MockKubevirtClient) SecClient() v10.SecurityV1Interface {
371 ret := _m.ctrl.Call(_m, "SecClient")
372 ret0, _ := ret[0].(v10.SecurityV1Interface)
373 return ret0
374 }
375
376 func (_mr *_MockKubevirtClientRecorder) SecClient() *gomock.Call {
377 return _mr.mock.ctrl.RecordCall(_mr.mock, "SecClient")
378 }
379
380 func (_m *MockKubevirtClient) RouteClient() v1.RouteV1Interface {
381 ret := _m.ctrl.Call(_m, "RouteClient")
382 ret0, _ := ret[0].(v1.RouteV1Interface)
383 return ret0
384 }
385
386 func (_mr *_MockKubevirtClientRecorder) RouteClient() *gomock.Call {
387 return _mr.mock.ctrl.RecordCall(_mr.mock, "RouteClient")
388 }
389
390 func (_m *MockKubevirtClient) DiscoveryClient() discovery.DiscoveryInterface {
391 ret := _m.ctrl.Call(_m, "DiscoveryClient")
392 ret0, _ := ret[0].(discovery.DiscoveryInterface)
393 return ret0
394 }
395
396 func (_mr *_MockKubevirtClientRecorder) DiscoveryClient() *gomock.Call {
397 return _mr.mock.ctrl.RecordCall(_mr.mock, "DiscoveryClient")
398 }
399
400 func (_m *MockKubevirtClient) PrometheusClient() versioned3.Interface {
401 ret := _m.ctrl.Call(_m, "PrometheusClient")
402 ret0, _ := ret[0].(versioned3.Interface)
403 return ret0
404 }
405
406 func (_mr *_MockKubevirtClientRecorder) PrometheusClient() *gomock.Call {
407 return _mr.mock.ctrl.RecordCall(_mr.mock, "PrometheusClient")
408 }
409
410 func (_m *MockKubevirtClient) KubernetesSnapshotClient() versioned0.Interface {
411 ret := _m.ctrl.Call(_m, "KubernetesSnapshotClient")
412 ret0, _ := ret[0].(versioned0.Interface)
413 return ret0
414 }
415
416 func (_mr *_MockKubevirtClientRecorder) KubernetesSnapshotClient() *gomock.Call {
417 return _mr.mock.ctrl.RecordCall(_mr.mock, "KubernetesSnapshotClient")
418 }
419
420 func (_m *MockKubevirtClient) DynamicClient() dynamic.Interface {
421 ret := _m.ctrl.Call(_m, "DynamicClient")
422 ret0, _ := ret[0].(dynamic.Interface)
423 return ret0
424 }
425
426 func (_mr *_MockKubevirtClientRecorder) DynamicClient() *gomock.Call {
427 return _mr.mock.ctrl.RecordCall(_mr.mock, "DynamicClient")
428 }
429
430 func (_m *MockKubevirtClient) MigrationPolicyClient() *v1alpha110.MigrationsV1alpha1Client {
431 ret := _m.ctrl.Call(_m, "MigrationPolicyClient")
432 ret0, _ := ret[0].(*v1alpha110.MigrationsV1alpha1Client)
433 return ret0
434 }
435
436 func (_mr *_MockKubevirtClientRecorder) MigrationPolicyClient() *gomock.Call {
437 return _mr.mock.ctrl.RecordCall(_mr.mock, "MigrationPolicyClient")
438 }
439
440 func (_m *MockKubevirtClient) Discovery() discovery.DiscoveryInterface {
441 ret := _m.ctrl.Call(_m, "Discovery")
442 ret0, _ := ret[0].(discovery.DiscoveryInterface)
443 return ret0
444 }
445
446 func (_mr *_MockKubevirtClientRecorder) Discovery() *gomock.Call {
447 return _mr.mock.ctrl.RecordCall(_mr.mock, "Discovery")
448 }
449
450 func (_m *MockKubevirtClient) AdmissionregistrationV1() v13.AdmissionregistrationV1Interface {
451 ret := _m.ctrl.Call(_m, "AdmissionregistrationV1")
452 ret0, _ := ret[0].(v13.AdmissionregistrationV1Interface)
453 return ret0
454 }
455
456 func (_mr *_MockKubevirtClientRecorder) AdmissionregistrationV1() *gomock.Call {
457 return _mr.mock.ctrl.RecordCall(_mr.mock, "AdmissionregistrationV1")
458 }
459
460 func (_m *MockKubevirtClient) AdmissionregistrationV1alpha1() v1alpha1.AdmissionregistrationV1alpha1Interface {
461 ret := _m.ctrl.Call(_m, "AdmissionregistrationV1alpha1")
462 ret0, _ := ret[0].(v1alpha1.AdmissionregistrationV1alpha1Interface)
463 return ret0
464 }
465
466 func (_mr *_MockKubevirtClientRecorder) AdmissionregistrationV1alpha1() *gomock.Call {
467 return _mr.mock.ctrl.RecordCall(_mr.mock, "AdmissionregistrationV1alpha1")
468 }
469
470 func (_m *MockKubevirtClient) AdmissionregistrationV1beta1() v1beta1.AdmissionregistrationV1beta1Interface {
471 ret := _m.ctrl.Call(_m, "AdmissionregistrationV1beta1")
472 ret0, _ := ret[0].(v1beta1.AdmissionregistrationV1beta1Interface)
473 return ret0
474 }
475
476 func (_mr *_MockKubevirtClientRecorder) AdmissionregistrationV1beta1() *gomock.Call {
477 return _mr.mock.ctrl.RecordCall(_mr.mock, "AdmissionregistrationV1beta1")
478 }
479
480 func (_m *MockKubevirtClient) InternalV1alpha1() v1alpha10.InternalV1alpha1Interface {
481 ret := _m.ctrl.Call(_m, "InternalV1alpha1")
482 ret0, _ := ret[0].(v1alpha10.InternalV1alpha1Interface)
483 return ret0
484 }
485
486 func (_mr *_MockKubevirtClientRecorder) InternalV1alpha1() *gomock.Call {
487 return _mr.mock.ctrl.RecordCall(_mr.mock, "InternalV1alpha1")
488 }
489
490 func (_m *MockKubevirtClient) AppsV1() v14.AppsV1Interface {
491 ret := _m.ctrl.Call(_m, "AppsV1")
492 ret0, _ := ret[0].(v14.AppsV1Interface)
493 return ret0
494 }
495
496 func (_mr *_MockKubevirtClientRecorder) AppsV1() *gomock.Call {
497 return _mr.mock.ctrl.RecordCall(_mr.mock, "AppsV1")
498 }
499
500 func (_m *MockKubevirtClient) AppsV1beta1() v1beta10.AppsV1beta1Interface {
501 ret := _m.ctrl.Call(_m, "AppsV1beta1")
502 ret0, _ := ret[0].(v1beta10.AppsV1beta1Interface)
503 return ret0
504 }
505
506 func (_mr *_MockKubevirtClientRecorder) AppsV1beta1() *gomock.Call {
507 return _mr.mock.ctrl.RecordCall(_mr.mock, "AppsV1beta1")
508 }
509
510 func (_m *MockKubevirtClient) AppsV1beta2() v1beta2.AppsV1beta2Interface {
511 ret := _m.ctrl.Call(_m, "AppsV1beta2")
512 ret0, _ := ret[0].(v1beta2.AppsV1beta2Interface)
513 return ret0
514 }
515
516 func (_mr *_MockKubevirtClientRecorder) AppsV1beta2() *gomock.Call {
517 return _mr.mock.ctrl.RecordCall(_mr.mock, "AppsV1beta2")
518 }
519
520 func (_m *MockKubevirtClient) AuthenticationV1() v15.AuthenticationV1Interface {
521 ret := _m.ctrl.Call(_m, "AuthenticationV1")
522 ret0, _ := ret[0].(v15.AuthenticationV1Interface)
523 return ret0
524 }
525
526 func (_mr *_MockKubevirtClientRecorder) AuthenticationV1() *gomock.Call {
527 return _mr.mock.ctrl.RecordCall(_mr.mock, "AuthenticationV1")
528 }
529
530 func (_m *MockKubevirtClient) AuthenticationV1alpha1() v1alpha11.AuthenticationV1alpha1Interface {
531 ret := _m.ctrl.Call(_m, "AuthenticationV1alpha1")
532 ret0, _ := ret[0].(v1alpha11.AuthenticationV1alpha1Interface)
533 return ret0
534 }
535
536 func (_mr *_MockKubevirtClientRecorder) AuthenticationV1alpha1() *gomock.Call {
537 return _mr.mock.ctrl.RecordCall(_mr.mock, "AuthenticationV1alpha1")
538 }
539
540 func (_m *MockKubevirtClient) AuthenticationV1beta1() v1beta11.AuthenticationV1beta1Interface {
541 ret := _m.ctrl.Call(_m, "AuthenticationV1beta1")
542 ret0, _ := ret[0].(v1beta11.AuthenticationV1beta1Interface)
543 return ret0
544 }
545
546 func (_mr *_MockKubevirtClientRecorder) AuthenticationV1beta1() *gomock.Call {
547 return _mr.mock.ctrl.RecordCall(_mr.mock, "AuthenticationV1beta1")
548 }
549
550 func (_m *MockKubevirtClient) AuthorizationV1() v16.AuthorizationV1Interface {
551 ret := _m.ctrl.Call(_m, "AuthorizationV1")
552 ret0, _ := ret[0].(v16.AuthorizationV1Interface)
553 return ret0
554 }
555
556 func (_mr *_MockKubevirtClientRecorder) AuthorizationV1() *gomock.Call {
557 return _mr.mock.ctrl.RecordCall(_mr.mock, "AuthorizationV1")
558 }
559
560 func (_m *MockKubevirtClient) AuthorizationV1beta1() v1beta12.AuthorizationV1beta1Interface {
561 ret := _m.ctrl.Call(_m, "AuthorizationV1beta1")
562 ret0, _ := ret[0].(v1beta12.AuthorizationV1beta1Interface)
563 return ret0
564 }
565
566 func (_mr *_MockKubevirtClientRecorder) AuthorizationV1beta1() *gomock.Call {
567 return _mr.mock.ctrl.RecordCall(_mr.mock, "AuthorizationV1beta1")
568 }
569
570 func (_m *MockKubevirtClient) AutoscalingV1() v17.AutoscalingV1Interface {
571 ret := _m.ctrl.Call(_m, "AutoscalingV1")
572 ret0, _ := ret[0].(v17.AutoscalingV1Interface)
573 return ret0
574 }
575
576 func (_mr *_MockKubevirtClientRecorder) AutoscalingV1() *gomock.Call {
577 return _mr.mock.ctrl.RecordCall(_mr.mock, "AutoscalingV1")
578 }
579
580 func (_m *MockKubevirtClient) AutoscalingV2() v2.AutoscalingV2Interface {
581 ret := _m.ctrl.Call(_m, "AutoscalingV2")
582 ret0, _ := ret[0].(v2.AutoscalingV2Interface)
583 return ret0
584 }
585
586 func (_mr *_MockKubevirtClientRecorder) AutoscalingV2() *gomock.Call {
587 return _mr.mock.ctrl.RecordCall(_mr.mock, "AutoscalingV2")
588 }
589
590 func (_m *MockKubevirtClient) AutoscalingV2beta1() v2beta1.AutoscalingV2beta1Interface {
591 ret := _m.ctrl.Call(_m, "AutoscalingV2beta1")
592 ret0, _ := ret[0].(v2beta1.AutoscalingV2beta1Interface)
593 return ret0
594 }
595
596 func (_mr *_MockKubevirtClientRecorder) AutoscalingV2beta1() *gomock.Call {
597 return _mr.mock.ctrl.RecordCall(_mr.mock, "AutoscalingV2beta1")
598 }
599
600 func (_m *MockKubevirtClient) AutoscalingV2beta2() v2beta2.AutoscalingV2beta2Interface {
601 ret := _m.ctrl.Call(_m, "AutoscalingV2beta2")
602 ret0, _ := ret[0].(v2beta2.AutoscalingV2beta2Interface)
603 return ret0
604 }
605
606 func (_mr *_MockKubevirtClientRecorder) AutoscalingV2beta2() *gomock.Call {
607 return _mr.mock.ctrl.RecordCall(_mr.mock, "AutoscalingV2beta2")
608 }
609
610 func (_m *MockKubevirtClient) BatchV1() v18.BatchV1Interface {
611 ret := _m.ctrl.Call(_m, "BatchV1")
612 ret0, _ := ret[0].(v18.BatchV1Interface)
613 return ret0
614 }
615
616 func (_mr *_MockKubevirtClientRecorder) BatchV1() *gomock.Call {
617 return _mr.mock.ctrl.RecordCall(_mr.mock, "BatchV1")
618 }
619
620 func (_m *MockKubevirtClient) BatchV1beta1() v1beta13.BatchV1beta1Interface {
621 ret := _m.ctrl.Call(_m, "BatchV1beta1")
622 ret0, _ := ret[0].(v1beta13.BatchV1beta1Interface)
623 return ret0
624 }
625
626 func (_mr *_MockKubevirtClientRecorder) BatchV1beta1() *gomock.Call {
627 return _mr.mock.ctrl.RecordCall(_mr.mock, "BatchV1beta1")
628 }
629
630 func (_m *MockKubevirtClient) CertificatesV1() v19.CertificatesV1Interface {
631 ret := _m.ctrl.Call(_m, "CertificatesV1")
632 ret0, _ := ret[0].(v19.CertificatesV1Interface)
633 return ret0
634 }
635
636 func (_mr *_MockKubevirtClientRecorder) CertificatesV1() *gomock.Call {
637 return _mr.mock.ctrl.RecordCall(_mr.mock, "CertificatesV1")
638 }
639
640 func (_m *MockKubevirtClient) CertificatesV1beta1() v1beta14.CertificatesV1beta1Interface {
641 ret := _m.ctrl.Call(_m, "CertificatesV1beta1")
642 ret0, _ := ret[0].(v1beta14.CertificatesV1beta1Interface)
643 return ret0
644 }
645
646 func (_mr *_MockKubevirtClientRecorder) CertificatesV1beta1() *gomock.Call {
647 return _mr.mock.ctrl.RecordCall(_mr.mock, "CertificatesV1beta1")
648 }
649
650 func (_m *MockKubevirtClient) CertificatesV1alpha1() v1alpha12.CertificatesV1alpha1Interface {
651 ret := _m.ctrl.Call(_m, "CertificatesV1alpha1")
652 ret0, _ := ret[0].(v1alpha12.CertificatesV1alpha1Interface)
653 return ret0
654 }
655
656 func (_mr *_MockKubevirtClientRecorder) CertificatesV1alpha1() *gomock.Call {
657 return _mr.mock.ctrl.RecordCall(_mr.mock, "CertificatesV1alpha1")
658 }
659
660 func (_m *MockKubevirtClient) CoordinationV1beta1() v1beta15.CoordinationV1beta1Interface {
661 ret := _m.ctrl.Call(_m, "CoordinationV1beta1")
662 ret0, _ := ret[0].(v1beta15.CoordinationV1beta1Interface)
663 return ret0
664 }
665
666 func (_mr *_MockKubevirtClientRecorder) CoordinationV1beta1() *gomock.Call {
667 return _mr.mock.ctrl.RecordCall(_mr.mock, "CoordinationV1beta1")
668 }
669
670 func (_m *MockKubevirtClient) CoordinationV1() v110.CoordinationV1Interface {
671 ret := _m.ctrl.Call(_m, "CoordinationV1")
672 ret0, _ := ret[0].(v110.CoordinationV1Interface)
673 return ret0
674 }
675
676 func (_mr *_MockKubevirtClientRecorder) CoordinationV1() *gomock.Call {
677 return _mr.mock.ctrl.RecordCall(_mr.mock, "CoordinationV1")
678 }
679
680 func (_m *MockKubevirtClient) CoreV1() v111.CoreV1Interface {
681 ret := _m.ctrl.Call(_m, "CoreV1")
682 ret0, _ := ret[0].(v111.CoreV1Interface)
683 return ret0
684 }
685
686 func (_mr *_MockKubevirtClientRecorder) CoreV1() *gomock.Call {
687 return _mr.mock.ctrl.RecordCall(_mr.mock, "CoreV1")
688 }
689
690 func (_m *MockKubevirtClient) DiscoveryV1() v112.DiscoveryV1Interface {
691 ret := _m.ctrl.Call(_m, "DiscoveryV1")
692 ret0, _ := ret[0].(v112.DiscoveryV1Interface)
693 return ret0
694 }
695
696 func (_mr *_MockKubevirtClientRecorder) DiscoveryV1() *gomock.Call {
697 return _mr.mock.ctrl.RecordCall(_mr.mock, "DiscoveryV1")
698 }
699
700 func (_m *MockKubevirtClient) DiscoveryV1beta1() v1beta16.DiscoveryV1beta1Interface {
701 ret := _m.ctrl.Call(_m, "DiscoveryV1beta1")
702 ret0, _ := ret[0].(v1beta16.DiscoveryV1beta1Interface)
703 return ret0
704 }
705
706 func (_mr *_MockKubevirtClientRecorder) DiscoveryV1beta1() *gomock.Call {
707 return _mr.mock.ctrl.RecordCall(_mr.mock, "DiscoveryV1beta1")
708 }
709
710 func (_m *MockKubevirtClient) EventsV1() v113.EventsV1Interface {
711 ret := _m.ctrl.Call(_m, "EventsV1")
712 ret0, _ := ret[0].(v113.EventsV1Interface)
713 return ret0
714 }
715
716 func (_mr *_MockKubevirtClientRecorder) EventsV1() *gomock.Call {
717 return _mr.mock.ctrl.RecordCall(_mr.mock, "EventsV1")
718 }
719
720 func (_m *MockKubevirtClient) EventsV1beta1() v1beta17.EventsV1beta1Interface {
721 ret := _m.ctrl.Call(_m, "EventsV1beta1")
722 ret0, _ := ret[0].(v1beta17.EventsV1beta1Interface)
723 return ret0
724 }
725
726 func (_mr *_MockKubevirtClientRecorder) EventsV1beta1() *gomock.Call {
727 return _mr.mock.ctrl.RecordCall(_mr.mock, "EventsV1beta1")
728 }
729
730 func (_m *MockKubevirtClient) ExtensionsV1beta1() v1beta18.ExtensionsV1beta1Interface {
731 ret := _m.ctrl.Call(_m, "ExtensionsV1beta1")
732 ret0, _ := ret[0].(v1beta18.ExtensionsV1beta1Interface)
733 return ret0
734 }
735
736 func (_mr *_MockKubevirtClientRecorder) ExtensionsV1beta1() *gomock.Call {
737 return _mr.mock.ctrl.RecordCall(_mr.mock, "ExtensionsV1beta1")
738 }
739
740 func (_m *MockKubevirtClient) FlowcontrolV1() v114.FlowcontrolV1Interface {
741 ret := _m.ctrl.Call(_m, "FlowcontrolV1")
742 ret0, _ := ret[0].(v114.FlowcontrolV1Interface)
743 return ret0
744 }
745
746 func (_mr *_MockKubevirtClientRecorder) FlowcontrolV1() *gomock.Call {
747 return _mr.mock.ctrl.RecordCall(_mr.mock, "FlowcontrolV1")
748 }
749
750 func (_m *MockKubevirtClient) FlowcontrolV1beta1() v1beta19.FlowcontrolV1beta1Interface {
751 ret := _m.ctrl.Call(_m, "FlowcontrolV1beta1")
752 ret0, _ := ret[0].(v1beta19.FlowcontrolV1beta1Interface)
753 return ret0
754 }
755
756 func (_mr *_MockKubevirtClientRecorder) FlowcontrolV1beta1() *gomock.Call {
757 return _mr.mock.ctrl.RecordCall(_mr.mock, "FlowcontrolV1beta1")
758 }
759
760 func (_m *MockKubevirtClient) FlowcontrolV1beta2() v1beta20.FlowcontrolV1beta2Interface {
761 ret := _m.ctrl.Call(_m, "FlowcontrolV1beta2")
762 ret0, _ := ret[0].(v1beta20.FlowcontrolV1beta2Interface)
763 return ret0
764 }
765
766 func (_mr *_MockKubevirtClientRecorder) FlowcontrolV1beta2() *gomock.Call {
767 return _mr.mock.ctrl.RecordCall(_mr.mock, "FlowcontrolV1beta2")
768 }
769
770 func (_m *MockKubevirtClient) FlowcontrolV1beta3() v1beta3.FlowcontrolV1beta3Interface {
771 ret := _m.ctrl.Call(_m, "FlowcontrolV1beta3")
772 ret0, _ := ret[0].(v1beta3.FlowcontrolV1beta3Interface)
773 return ret0
774 }
775
776 func (_mr *_MockKubevirtClientRecorder) FlowcontrolV1beta3() *gomock.Call {
777 return _mr.mock.ctrl.RecordCall(_mr.mock, "FlowcontrolV1beta3")
778 }
779
780 func (_m *MockKubevirtClient) NetworkingV1() v115.NetworkingV1Interface {
781 ret := _m.ctrl.Call(_m, "NetworkingV1")
782 ret0, _ := ret[0].(v115.NetworkingV1Interface)
783 return ret0
784 }
785
786 func (_mr *_MockKubevirtClientRecorder) NetworkingV1() *gomock.Call {
787 return _mr.mock.ctrl.RecordCall(_mr.mock, "NetworkingV1")
788 }
789
790 func (_m *MockKubevirtClient) NetworkingV1alpha1() v1alpha13.NetworkingV1alpha1Interface {
791 ret := _m.ctrl.Call(_m, "NetworkingV1alpha1")
792 ret0, _ := ret[0].(v1alpha13.NetworkingV1alpha1Interface)
793 return ret0
794 }
795
796 func (_mr *_MockKubevirtClientRecorder) NetworkingV1alpha1() *gomock.Call {
797 return _mr.mock.ctrl.RecordCall(_mr.mock, "NetworkingV1alpha1")
798 }
799
800 func (_m *MockKubevirtClient) NetworkingV1beta1() v1beta110.NetworkingV1beta1Interface {
801 ret := _m.ctrl.Call(_m, "NetworkingV1beta1")
802 ret0, _ := ret[0].(v1beta110.NetworkingV1beta1Interface)
803 return ret0
804 }
805
806 func (_mr *_MockKubevirtClientRecorder) NetworkingV1beta1() *gomock.Call {
807 return _mr.mock.ctrl.RecordCall(_mr.mock, "NetworkingV1beta1")
808 }
809
810 func (_m *MockKubevirtClient) NodeV1() v116.NodeV1Interface {
811 ret := _m.ctrl.Call(_m, "NodeV1")
812 ret0, _ := ret[0].(v116.NodeV1Interface)
813 return ret0
814 }
815
816 func (_mr *_MockKubevirtClientRecorder) NodeV1() *gomock.Call {
817 return _mr.mock.ctrl.RecordCall(_mr.mock, "NodeV1")
818 }
819
820 func (_m *MockKubevirtClient) NodeV1alpha1() v1alpha14.NodeV1alpha1Interface {
821 ret := _m.ctrl.Call(_m, "NodeV1alpha1")
822 ret0, _ := ret[0].(v1alpha14.NodeV1alpha1Interface)
823 return ret0
824 }
825
826 func (_mr *_MockKubevirtClientRecorder) NodeV1alpha1() *gomock.Call {
827 return _mr.mock.ctrl.RecordCall(_mr.mock, "NodeV1alpha1")
828 }
829
830 func (_m *MockKubevirtClient) NodeV1beta1() v1beta111.NodeV1beta1Interface {
831 ret := _m.ctrl.Call(_m, "NodeV1beta1")
832 ret0, _ := ret[0].(v1beta111.NodeV1beta1Interface)
833 return ret0
834 }
835
836 func (_mr *_MockKubevirtClientRecorder) NodeV1beta1() *gomock.Call {
837 return _mr.mock.ctrl.RecordCall(_mr.mock, "NodeV1beta1")
838 }
839
840 func (_m *MockKubevirtClient) PolicyV1() v117.PolicyV1Interface {
841 ret := _m.ctrl.Call(_m, "PolicyV1")
842 ret0, _ := ret[0].(v117.PolicyV1Interface)
843 return ret0
844 }
845
846 func (_mr *_MockKubevirtClientRecorder) PolicyV1() *gomock.Call {
847 return _mr.mock.ctrl.RecordCall(_mr.mock, "PolicyV1")
848 }
849
850 func (_m *MockKubevirtClient) PolicyV1beta1() v1beta112.PolicyV1beta1Interface {
851 ret := _m.ctrl.Call(_m, "PolicyV1beta1")
852 ret0, _ := ret[0].(v1beta112.PolicyV1beta1Interface)
853 return ret0
854 }
855
856 func (_mr *_MockKubevirtClientRecorder) PolicyV1beta1() *gomock.Call {
857 return _mr.mock.ctrl.RecordCall(_mr.mock, "PolicyV1beta1")
858 }
859
860 func (_m *MockKubevirtClient) RbacV1() v118.RbacV1Interface {
861 ret := _m.ctrl.Call(_m, "RbacV1")
862 ret0, _ := ret[0].(v118.RbacV1Interface)
863 return ret0
864 }
865
866 func (_mr *_MockKubevirtClientRecorder) RbacV1() *gomock.Call {
867 return _mr.mock.ctrl.RecordCall(_mr.mock, "RbacV1")
868 }
869
870 func (_m *MockKubevirtClient) RbacV1beta1() v1beta113.RbacV1beta1Interface {
871 ret := _m.ctrl.Call(_m, "RbacV1beta1")
872 ret0, _ := ret[0].(v1beta113.RbacV1beta1Interface)
873 return ret0
874 }
875
876 func (_mr *_MockKubevirtClientRecorder) RbacV1beta1() *gomock.Call {
877 return _mr.mock.ctrl.RecordCall(_mr.mock, "RbacV1beta1")
878 }
879
880 func (_m *MockKubevirtClient) RbacV1alpha1() v1alpha15.RbacV1alpha1Interface {
881 ret := _m.ctrl.Call(_m, "RbacV1alpha1")
882 ret0, _ := ret[0].(v1alpha15.RbacV1alpha1Interface)
883 return ret0
884 }
885
886 func (_mr *_MockKubevirtClientRecorder) RbacV1alpha1() *gomock.Call {
887 return _mr.mock.ctrl.RecordCall(_mr.mock, "RbacV1alpha1")
888 }
889
890 func (_m *MockKubevirtClient) ResourceV1alpha2() v1alpha2.ResourceV1alpha2Interface {
891 ret := _m.ctrl.Call(_m, "ResourceV1alpha2")
892 ret0, _ := ret[0].(v1alpha2.ResourceV1alpha2Interface)
893 return ret0
894 }
895
896 func (_mr *_MockKubevirtClientRecorder) ResourceV1alpha2() *gomock.Call {
897 return _mr.mock.ctrl.RecordCall(_mr.mock, "ResourceV1alpha2")
898 }
899
900 func (_m *MockKubevirtClient) SchedulingV1alpha1() v1alpha16.SchedulingV1alpha1Interface {
901 ret := _m.ctrl.Call(_m, "SchedulingV1alpha1")
902 ret0, _ := ret[0].(v1alpha16.SchedulingV1alpha1Interface)
903 return ret0
904 }
905
906 func (_mr *_MockKubevirtClientRecorder) SchedulingV1alpha1() *gomock.Call {
907 return _mr.mock.ctrl.RecordCall(_mr.mock, "SchedulingV1alpha1")
908 }
909
910 func (_m *MockKubevirtClient) SchedulingV1beta1() v1beta114.SchedulingV1beta1Interface {
911 ret := _m.ctrl.Call(_m, "SchedulingV1beta1")
912 ret0, _ := ret[0].(v1beta114.SchedulingV1beta1Interface)
913 return ret0
914 }
915
916 func (_mr *_MockKubevirtClientRecorder) SchedulingV1beta1() *gomock.Call {
917 return _mr.mock.ctrl.RecordCall(_mr.mock, "SchedulingV1beta1")
918 }
919
920 func (_m *MockKubevirtClient) SchedulingV1() v119.SchedulingV1Interface {
921 ret := _m.ctrl.Call(_m, "SchedulingV1")
922 ret0, _ := ret[0].(v119.SchedulingV1Interface)
923 return ret0
924 }
925
926 func (_mr *_MockKubevirtClientRecorder) SchedulingV1() *gomock.Call {
927 return _mr.mock.ctrl.RecordCall(_mr.mock, "SchedulingV1")
928 }
929
930 func (_m *MockKubevirtClient) StorageV1beta1() v1beta115.StorageV1beta1Interface {
931 ret := _m.ctrl.Call(_m, "StorageV1beta1")
932 ret0, _ := ret[0].(v1beta115.StorageV1beta1Interface)
933 return ret0
934 }
935
936 func (_mr *_MockKubevirtClientRecorder) StorageV1beta1() *gomock.Call {
937 return _mr.mock.ctrl.RecordCall(_mr.mock, "StorageV1beta1")
938 }
939
940 func (_m *MockKubevirtClient) StorageV1() v120.StorageV1Interface {
941 ret := _m.ctrl.Call(_m, "StorageV1")
942 ret0, _ := ret[0].(v120.StorageV1Interface)
943 return ret0
944 }
945
946 func (_mr *_MockKubevirtClientRecorder) StorageV1() *gomock.Call {
947 return _mr.mock.ctrl.RecordCall(_mr.mock, "StorageV1")
948 }
949
950 func (_m *MockKubevirtClient) StorageV1alpha1() v1alpha17.StorageV1alpha1Interface {
951 ret := _m.ctrl.Call(_m, "StorageV1alpha1")
952 ret0, _ := ret[0].(v1alpha17.StorageV1alpha1Interface)
953 return ret0
954 }
955
956 func (_mr *_MockKubevirtClientRecorder) StorageV1alpha1() *gomock.Call {
957 return _mr.mock.ctrl.RecordCall(_mr.mock, "StorageV1alpha1")
958 }
959
960 func (_m *MockKubevirtClient) StoragemigrationV1alpha1() v1alpha18.StoragemigrationV1alpha1Interface {
961 ret := _m.ctrl.Call(_m, "StoragemigrationV1alpha1")
962 ret0, _ := ret[0].(v1alpha18.StoragemigrationV1alpha1Interface)
963 return ret0
964 }
965
966 func (_mr *_MockKubevirtClientRecorder) StoragemigrationV1alpha1() *gomock.Call {
967 return _mr.mock.ctrl.RecordCall(_mr.mock, "StoragemigrationV1alpha1")
968 }
969
970 func (_m *MockKubevirtClient) Config() *rest.Config {
971 ret := _m.ctrl.Call(_m, "Config")
972 ret0, _ := ret[0].(*rest.Config)
973 return ret0
974 }
975
976 func (_mr *_MockKubevirtClientRecorder) Config() *gomock.Call {
977 return _mr.mock.ctrl.RecordCall(_mr.mock, "Config")
978 }
979
980 func (_m *MockKubevirtClient) SetRestTimeout(timeout time.Duration) (KubevirtClient, error) {
981 ret := _m.ctrl.Call(_m, "SetRestTimeout", timeout)
982 ret0, _ := ret[0].(KubevirtClient)
983 ret1, _ := ret[1].(error)
984 return ret0, ret1
985 }
986
987 func (_mr *_MockKubevirtClientRecorder) SetRestTimeout(arg0 interface{}) *gomock.Call {
988 return _mr.mock.ctrl.RecordCall(_mr.mock, "SetRestTimeout", arg0)
989 }
990
991
992 type MockVirtualMachineInstanceInterface struct {
993 ctrl *gomock.Controller
994 recorder *_MockVirtualMachineInstanceInterfaceRecorder
995 }
996
997
998 type _MockVirtualMachineInstanceInterfaceRecorder struct {
999 mock *MockVirtualMachineInstanceInterface
1000 }
1001
1002 func NewMockVirtualMachineInstanceInterface(ctrl *gomock.Controller) *MockVirtualMachineInstanceInterface {
1003 mock := &MockVirtualMachineInstanceInterface{ctrl: ctrl}
1004 mock.recorder = &_MockVirtualMachineInstanceInterfaceRecorder{mock}
1005 return mock
1006 }
1007
1008 func (_m *MockVirtualMachineInstanceInterface) EXPECT() *_MockVirtualMachineInstanceInterfaceRecorder {
1009 return _m.recorder
1010 }
1011
1012 func (_m *MockVirtualMachineInstanceInterface) Create(ctx context.Context, virtualMachineInstance *v121.VirtualMachineInstance, opts v12.CreateOptions) (*v121.VirtualMachineInstance, error) {
1013 ret := _m.ctrl.Call(_m, "Create", ctx, virtualMachineInstance, opts)
1014 ret0, _ := ret[0].(*v121.VirtualMachineInstance)
1015 ret1, _ := ret[1].(error)
1016 return ret0, ret1
1017 }
1018
1019 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) Create(arg0, arg1, arg2 interface{}) *gomock.Call {
1020 return _mr.mock.ctrl.RecordCall(_mr.mock, "Create", arg0, arg1, arg2)
1021 }
1022
1023 func (_m *MockVirtualMachineInstanceInterface) Update(ctx context.Context, virtualMachineInstance *v121.VirtualMachineInstance, opts v12.UpdateOptions) (*v121.VirtualMachineInstance, error) {
1024 ret := _m.ctrl.Call(_m, "Update", ctx, virtualMachineInstance, opts)
1025 ret0, _ := ret[0].(*v121.VirtualMachineInstance)
1026 ret1, _ := ret[1].(error)
1027 return ret0, ret1
1028 }
1029
1030 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) Update(arg0, arg1, arg2 interface{}) *gomock.Call {
1031 return _mr.mock.ctrl.RecordCall(_mr.mock, "Update", arg0, arg1, arg2)
1032 }
1033
1034 func (_m *MockVirtualMachineInstanceInterface) UpdateStatus(ctx context.Context, virtualMachineInstance *v121.VirtualMachineInstance, opts v12.UpdateOptions) (*v121.VirtualMachineInstance, error) {
1035 ret := _m.ctrl.Call(_m, "UpdateStatus", ctx, virtualMachineInstance, opts)
1036 ret0, _ := ret[0].(*v121.VirtualMachineInstance)
1037 ret1, _ := ret[1].(error)
1038 return ret0, ret1
1039 }
1040
1041 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) UpdateStatus(arg0, arg1, arg2 interface{}) *gomock.Call {
1042 return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateStatus", arg0, arg1, arg2)
1043 }
1044
1045 func (_m *MockVirtualMachineInstanceInterface) Delete(ctx context.Context, name string, opts v12.DeleteOptions) error {
1046 ret := _m.ctrl.Call(_m, "Delete", ctx, name, opts)
1047 ret0, _ := ret[0].(error)
1048 return ret0
1049 }
1050
1051 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) Delete(arg0, arg1, arg2 interface{}) *gomock.Call {
1052 return _mr.mock.ctrl.RecordCall(_mr.mock, "Delete", arg0, arg1, arg2)
1053 }
1054
1055 func (_m *MockVirtualMachineInstanceInterface) DeleteCollection(ctx context.Context, opts v12.DeleteOptions, listOpts v12.ListOptions) error {
1056 ret := _m.ctrl.Call(_m, "DeleteCollection", ctx, opts, listOpts)
1057 ret0, _ := ret[0].(error)
1058 return ret0
1059 }
1060
1061 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) DeleteCollection(arg0, arg1, arg2 interface{}) *gomock.Call {
1062 return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteCollection", arg0, arg1, arg2)
1063 }
1064
1065 func (_m *MockVirtualMachineInstanceInterface) Get(ctx context.Context, name string, opts v12.GetOptions) (*v121.VirtualMachineInstance, error) {
1066 ret := _m.ctrl.Call(_m, "Get", ctx, name, opts)
1067 ret0, _ := ret[0].(*v121.VirtualMachineInstance)
1068 ret1, _ := ret[1].(error)
1069 return ret0, ret1
1070 }
1071
1072 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) Get(arg0, arg1, arg2 interface{}) *gomock.Call {
1073 return _mr.mock.ctrl.RecordCall(_mr.mock, "Get", arg0, arg1, arg2)
1074 }
1075
1076 func (_m *MockVirtualMachineInstanceInterface) List(ctx context.Context, opts v12.ListOptions) (*v121.VirtualMachineInstanceList, error) {
1077 ret := _m.ctrl.Call(_m, "List", ctx, opts)
1078 ret0, _ := ret[0].(*v121.VirtualMachineInstanceList)
1079 ret1, _ := ret[1].(error)
1080 return ret0, ret1
1081 }
1082
1083 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) List(arg0, arg1 interface{}) *gomock.Call {
1084 return _mr.mock.ctrl.RecordCall(_mr.mock, "List", arg0, arg1)
1085 }
1086
1087 func (_m *MockVirtualMachineInstanceInterface) Watch(ctx context.Context, opts v12.ListOptions) (watch.Interface, error) {
1088 ret := _m.ctrl.Call(_m, "Watch", ctx, opts)
1089 ret0, _ := ret[0].(watch.Interface)
1090 ret1, _ := ret[1].(error)
1091 return ret0, ret1
1092 }
1093
1094 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) Watch(arg0, arg1 interface{}) *gomock.Call {
1095 return _mr.mock.ctrl.RecordCall(_mr.mock, "Watch", arg0, arg1)
1096 }
1097
1098 func (_m *MockVirtualMachineInstanceInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v12.PatchOptions, subresources ...string) (*v121.VirtualMachineInstance, error) {
1099 _s := []interface{}{ctx, name, pt, data, opts}
1100 for _, _x := range subresources {
1101 _s = append(_s, _x)
1102 }
1103 ret := _m.ctrl.Call(_m, "Patch", _s...)
1104 ret0, _ := ret[0].(*v121.VirtualMachineInstance)
1105 ret1, _ := ret[1].(error)
1106 return ret0, ret1
1107 }
1108
1109 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) Patch(arg0, arg1, arg2, arg3, arg4 interface{}, arg5 ...interface{}) *gomock.Call {
1110 _s := append([]interface{}{arg0, arg1, arg2, arg3, arg4}, arg5...)
1111 return _mr.mock.ctrl.RecordCall(_mr.mock, "Patch", _s...)
1112 }
1113
1114 func (_m *MockVirtualMachineInstanceInterface) SerialConsole(name string, options *v122.SerialConsoleOptions) (v122.StreamInterface, error) {
1115 ret := _m.ctrl.Call(_m, "SerialConsole", name, options)
1116 ret0, _ := ret[0].(v122.StreamInterface)
1117 ret1, _ := ret[1].(error)
1118 return ret0, ret1
1119 }
1120
1121 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) SerialConsole(arg0, arg1 interface{}) *gomock.Call {
1122 return _mr.mock.ctrl.RecordCall(_mr.mock, "SerialConsole", arg0, arg1)
1123 }
1124
1125 func (_m *MockVirtualMachineInstanceInterface) USBRedir(vmiName string) (v122.StreamInterface, error) {
1126 ret := _m.ctrl.Call(_m, "USBRedir", vmiName)
1127 ret0, _ := ret[0].(v122.StreamInterface)
1128 ret1, _ := ret[1].(error)
1129 return ret0, ret1
1130 }
1131
1132 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) USBRedir(arg0 interface{}) *gomock.Call {
1133 return _mr.mock.ctrl.RecordCall(_mr.mock, "USBRedir", arg0)
1134 }
1135
1136 func (_m *MockVirtualMachineInstanceInterface) VNC(name string) (v122.StreamInterface, error) {
1137 ret := _m.ctrl.Call(_m, "VNC", name)
1138 ret0, _ := ret[0].(v122.StreamInterface)
1139 ret1, _ := ret[1].(error)
1140 return ret0, ret1
1141 }
1142
1143 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) VNC(arg0 interface{}) *gomock.Call {
1144 return _mr.mock.ctrl.RecordCall(_mr.mock, "VNC", arg0)
1145 }
1146
1147 func (_m *MockVirtualMachineInstanceInterface) Screenshot(ctx context.Context, name string, options *v121.ScreenshotOptions) ([]byte, error) {
1148 ret := _m.ctrl.Call(_m, "Screenshot", ctx, name, options)
1149 ret0, _ := ret[0].([]byte)
1150 ret1, _ := ret[1].(error)
1151 return ret0, ret1
1152 }
1153
1154 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) Screenshot(arg0, arg1, arg2 interface{}) *gomock.Call {
1155 return _mr.mock.ctrl.RecordCall(_mr.mock, "Screenshot", arg0, arg1, arg2)
1156 }
1157
1158 func (_m *MockVirtualMachineInstanceInterface) PortForward(name string, port int, protocol string) (v122.StreamInterface, error) {
1159 ret := _m.ctrl.Call(_m, "PortForward", name, port, protocol)
1160 ret0, _ := ret[0].(v122.StreamInterface)
1161 ret1, _ := ret[1].(error)
1162 return ret0, ret1
1163 }
1164
1165 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) PortForward(arg0, arg1, arg2 interface{}) *gomock.Call {
1166 return _mr.mock.ctrl.RecordCall(_mr.mock, "PortForward", arg0, arg1, arg2)
1167 }
1168
1169 func (_m *MockVirtualMachineInstanceInterface) Pause(ctx context.Context, name string, pauseOptions *v121.PauseOptions) error {
1170 ret := _m.ctrl.Call(_m, "Pause", ctx, name, pauseOptions)
1171 ret0, _ := ret[0].(error)
1172 return ret0
1173 }
1174
1175 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) Pause(arg0, arg1, arg2 interface{}) *gomock.Call {
1176 return _mr.mock.ctrl.RecordCall(_mr.mock, "Pause", arg0, arg1, arg2)
1177 }
1178
1179 func (_m *MockVirtualMachineInstanceInterface) Unpause(ctx context.Context, name string, unpauseOptions *v121.UnpauseOptions) error {
1180 ret := _m.ctrl.Call(_m, "Unpause", ctx, name, unpauseOptions)
1181 ret0, _ := ret[0].(error)
1182 return ret0
1183 }
1184
1185 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) Unpause(arg0, arg1, arg2 interface{}) *gomock.Call {
1186 return _mr.mock.ctrl.RecordCall(_mr.mock, "Unpause", arg0, arg1, arg2)
1187 }
1188
1189 func (_m *MockVirtualMachineInstanceInterface) Freeze(ctx context.Context, name string, unfreezeTimeout time.Duration) error {
1190 ret := _m.ctrl.Call(_m, "Freeze", ctx, name, unfreezeTimeout)
1191 ret0, _ := ret[0].(error)
1192 return ret0
1193 }
1194
1195 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) Freeze(arg0, arg1, arg2 interface{}) *gomock.Call {
1196 return _mr.mock.ctrl.RecordCall(_mr.mock, "Freeze", arg0, arg1, arg2)
1197 }
1198
1199 func (_m *MockVirtualMachineInstanceInterface) Unfreeze(ctx context.Context, name string) error {
1200 ret := _m.ctrl.Call(_m, "Unfreeze", ctx, name)
1201 ret0, _ := ret[0].(error)
1202 return ret0
1203 }
1204
1205 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) Unfreeze(arg0, arg1 interface{}) *gomock.Call {
1206 return _mr.mock.ctrl.RecordCall(_mr.mock, "Unfreeze", arg0, arg1)
1207 }
1208
1209 func (_m *MockVirtualMachineInstanceInterface) SoftReboot(ctx context.Context, name string) error {
1210 ret := _m.ctrl.Call(_m, "SoftReboot", ctx, name)
1211 ret0, _ := ret[0].(error)
1212 return ret0
1213 }
1214
1215 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) SoftReboot(arg0, arg1 interface{}) *gomock.Call {
1216 return _mr.mock.ctrl.RecordCall(_mr.mock, "SoftReboot", arg0, arg1)
1217 }
1218
1219 func (_m *MockVirtualMachineInstanceInterface) GuestOsInfo(ctx context.Context, name string) (v121.VirtualMachineInstanceGuestAgentInfo, error) {
1220 ret := _m.ctrl.Call(_m, "GuestOsInfo", ctx, name)
1221 ret0, _ := ret[0].(v121.VirtualMachineInstanceGuestAgentInfo)
1222 ret1, _ := ret[1].(error)
1223 return ret0, ret1
1224 }
1225
1226 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) GuestOsInfo(arg0, arg1 interface{}) *gomock.Call {
1227 return _mr.mock.ctrl.RecordCall(_mr.mock, "GuestOsInfo", arg0, arg1)
1228 }
1229
1230 func (_m *MockVirtualMachineInstanceInterface) UserList(ctx context.Context, name string) (v121.VirtualMachineInstanceGuestOSUserList, error) {
1231 ret := _m.ctrl.Call(_m, "UserList", ctx, name)
1232 ret0, _ := ret[0].(v121.VirtualMachineInstanceGuestOSUserList)
1233 ret1, _ := ret[1].(error)
1234 return ret0, ret1
1235 }
1236
1237 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) UserList(arg0, arg1 interface{}) *gomock.Call {
1238 return _mr.mock.ctrl.RecordCall(_mr.mock, "UserList", arg0, arg1)
1239 }
1240
1241 func (_m *MockVirtualMachineInstanceInterface) FilesystemList(ctx context.Context, name string) (v121.VirtualMachineInstanceFileSystemList, error) {
1242 ret := _m.ctrl.Call(_m, "FilesystemList", ctx, name)
1243 ret0, _ := ret[0].(v121.VirtualMachineInstanceFileSystemList)
1244 ret1, _ := ret[1].(error)
1245 return ret0, ret1
1246 }
1247
1248 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) FilesystemList(arg0, arg1 interface{}) *gomock.Call {
1249 return _mr.mock.ctrl.RecordCall(_mr.mock, "FilesystemList", arg0, arg1)
1250 }
1251
1252 func (_m *MockVirtualMachineInstanceInterface) AddVolume(ctx context.Context, name string, addVolumeOptions *v121.AddVolumeOptions) error {
1253 ret := _m.ctrl.Call(_m, "AddVolume", ctx, name, addVolumeOptions)
1254 ret0, _ := ret[0].(error)
1255 return ret0
1256 }
1257
1258 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) AddVolume(arg0, arg1, arg2 interface{}) *gomock.Call {
1259 return _mr.mock.ctrl.RecordCall(_mr.mock, "AddVolume", arg0, arg1, arg2)
1260 }
1261
1262 func (_m *MockVirtualMachineInstanceInterface) RemoveVolume(ctx context.Context, name string, removeVolumeOptions *v121.RemoveVolumeOptions) error {
1263 ret := _m.ctrl.Call(_m, "RemoveVolume", ctx, name, removeVolumeOptions)
1264 ret0, _ := ret[0].(error)
1265 return ret0
1266 }
1267
1268 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) RemoveVolume(arg0, arg1, arg2 interface{}) *gomock.Call {
1269 return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveVolume", arg0, arg1, arg2)
1270 }
1271
1272 func (_m *MockVirtualMachineInstanceInterface) VSOCK(name string, options *v121.VSOCKOptions) (v122.StreamInterface, error) {
1273 ret := _m.ctrl.Call(_m, "VSOCK", name, options)
1274 ret0, _ := ret[0].(v122.StreamInterface)
1275 ret1, _ := ret[1].(error)
1276 return ret0, ret1
1277 }
1278
1279 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) VSOCK(arg0, arg1 interface{}) *gomock.Call {
1280 return _mr.mock.ctrl.RecordCall(_mr.mock, "VSOCK", arg0, arg1)
1281 }
1282
1283 func (_m *MockVirtualMachineInstanceInterface) SEVFetchCertChain(ctx context.Context, name string) (v121.SEVPlatformInfo, error) {
1284 ret := _m.ctrl.Call(_m, "SEVFetchCertChain", ctx, name)
1285 ret0, _ := ret[0].(v121.SEVPlatformInfo)
1286 ret1, _ := ret[1].(error)
1287 return ret0, ret1
1288 }
1289
1290 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) SEVFetchCertChain(arg0, arg1 interface{}) *gomock.Call {
1291 return _mr.mock.ctrl.RecordCall(_mr.mock, "SEVFetchCertChain", arg0, arg1)
1292 }
1293
1294 func (_m *MockVirtualMachineInstanceInterface) SEVQueryLaunchMeasurement(ctx context.Context, name string) (v121.SEVMeasurementInfo, error) {
1295 ret := _m.ctrl.Call(_m, "SEVQueryLaunchMeasurement", ctx, name)
1296 ret0, _ := ret[0].(v121.SEVMeasurementInfo)
1297 ret1, _ := ret[1].(error)
1298 return ret0, ret1
1299 }
1300
1301 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) SEVQueryLaunchMeasurement(arg0, arg1 interface{}) *gomock.Call {
1302 return _mr.mock.ctrl.RecordCall(_mr.mock, "SEVQueryLaunchMeasurement", arg0, arg1)
1303 }
1304
1305 func (_m *MockVirtualMachineInstanceInterface) SEVSetupSession(ctx context.Context, name string, sevSessionOptions *v121.SEVSessionOptions) error {
1306 ret := _m.ctrl.Call(_m, "SEVSetupSession", ctx, name, sevSessionOptions)
1307 ret0, _ := ret[0].(error)
1308 return ret0
1309 }
1310
1311 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) SEVSetupSession(arg0, arg1, arg2 interface{}) *gomock.Call {
1312 return _mr.mock.ctrl.RecordCall(_mr.mock, "SEVSetupSession", arg0, arg1, arg2)
1313 }
1314
1315 func (_m *MockVirtualMachineInstanceInterface) SEVInjectLaunchSecret(ctx context.Context, name string, sevSecretOptions *v121.SEVSecretOptions) error {
1316 ret := _m.ctrl.Call(_m, "SEVInjectLaunchSecret", ctx, name, sevSecretOptions)
1317 ret0, _ := ret[0].(error)
1318 return ret0
1319 }
1320
1321 func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) SEVInjectLaunchSecret(arg0, arg1, arg2 interface{}) *gomock.Call {
1322 return _mr.mock.ctrl.RecordCall(_mr.mock, "SEVInjectLaunchSecret", arg0, arg1, arg2)
1323 }
1324
1325
1326 type MockReplicaSetInterface struct {
1327 ctrl *gomock.Controller
1328 recorder *_MockReplicaSetInterfaceRecorder
1329 }
1330
1331
1332 type _MockReplicaSetInterfaceRecorder struct {
1333 mock *MockReplicaSetInterface
1334 }
1335
1336 func NewMockReplicaSetInterface(ctrl *gomock.Controller) *MockReplicaSetInterface {
1337 mock := &MockReplicaSetInterface{ctrl: ctrl}
1338 mock.recorder = &_MockReplicaSetInterfaceRecorder{mock}
1339 return mock
1340 }
1341
1342 func (_m *MockReplicaSetInterface) EXPECT() *_MockReplicaSetInterfaceRecorder {
1343 return _m.recorder
1344 }
1345
1346 func (_m *MockReplicaSetInterface) Create(ctx context.Context, virtualMachineInstanceReplicaSet *v121.VirtualMachineInstanceReplicaSet, opts v12.CreateOptions) (*v121.VirtualMachineInstanceReplicaSet, error) {
1347 ret := _m.ctrl.Call(_m, "Create", ctx, virtualMachineInstanceReplicaSet, opts)
1348 ret0, _ := ret[0].(*v121.VirtualMachineInstanceReplicaSet)
1349 ret1, _ := ret[1].(error)
1350 return ret0, ret1
1351 }
1352
1353 func (_mr *_MockReplicaSetInterfaceRecorder) Create(arg0, arg1, arg2 interface{}) *gomock.Call {
1354 return _mr.mock.ctrl.RecordCall(_mr.mock, "Create", arg0, arg1, arg2)
1355 }
1356
1357 func (_m *MockReplicaSetInterface) Update(ctx context.Context, virtualMachineInstanceReplicaSet *v121.VirtualMachineInstanceReplicaSet, opts v12.UpdateOptions) (*v121.VirtualMachineInstanceReplicaSet, error) {
1358 ret := _m.ctrl.Call(_m, "Update", ctx, virtualMachineInstanceReplicaSet, opts)
1359 ret0, _ := ret[0].(*v121.VirtualMachineInstanceReplicaSet)
1360 ret1, _ := ret[1].(error)
1361 return ret0, ret1
1362 }
1363
1364 func (_mr *_MockReplicaSetInterfaceRecorder) Update(arg0, arg1, arg2 interface{}) *gomock.Call {
1365 return _mr.mock.ctrl.RecordCall(_mr.mock, "Update", arg0, arg1, arg2)
1366 }
1367
1368 func (_m *MockReplicaSetInterface) UpdateStatus(ctx context.Context, virtualMachineInstanceReplicaSet *v121.VirtualMachineInstanceReplicaSet, opts v12.UpdateOptions) (*v121.VirtualMachineInstanceReplicaSet, error) {
1369 ret := _m.ctrl.Call(_m, "UpdateStatus", ctx, virtualMachineInstanceReplicaSet, opts)
1370 ret0, _ := ret[0].(*v121.VirtualMachineInstanceReplicaSet)
1371 ret1, _ := ret[1].(error)
1372 return ret0, ret1
1373 }
1374
1375 func (_mr *_MockReplicaSetInterfaceRecorder) UpdateStatus(arg0, arg1, arg2 interface{}) *gomock.Call {
1376 return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateStatus", arg0, arg1, arg2)
1377 }
1378
1379 func (_m *MockReplicaSetInterface) Delete(ctx context.Context, name string, opts v12.DeleteOptions) error {
1380 ret := _m.ctrl.Call(_m, "Delete", ctx, name, opts)
1381 ret0, _ := ret[0].(error)
1382 return ret0
1383 }
1384
1385 func (_mr *_MockReplicaSetInterfaceRecorder) Delete(arg0, arg1, arg2 interface{}) *gomock.Call {
1386 return _mr.mock.ctrl.RecordCall(_mr.mock, "Delete", arg0, arg1, arg2)
1387 }
1388
1389 func (_m *MockReplicaSetInterface) DeleteCollection(ctx context.Context, opts v12.DeleteOptions, listOpts v12.ListOptions) error {
1390 ret := _m.ctrl.Call(_m, "DeleteCollection", ctx, opts, listOpts)
1391 ret0, _ := ret[0].(error)
1392 return ret0
1393 }
1394
1395 func (_mr *_MockReplicaSetInterfaceRecorder) DeleteCollection(arg0, arg1, arg2 interface{}) *gomock.Call {
1396 return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteCollection", arg0, arg1, arg2)
1397 }
1398
1399 func (_m *MockReplicaSetInterface) Get(ctx context.Context, name string, opts v12.GetOptions) (*v121.VirtualMachineInstanceReplicaSet, error) {
1400 ret := _m.ctrl.Call(_m, "Get", ctx, name, opts)
1401 ret0, _ := ret[0].(*v121.VirtualMachineInstanceReplicaSet)
1402 ret1, _ := ret[1].(error)
1403 return ret0, ret1
1404 }
1405
1406 func (_mr *_MockReplicaSetInterfaceRecorder) Get(arg0, arg1, arg2 interface{}) *gomock.Call {
1407 return _mr.mock.ctrl.RecordCall(_mr.mock, "Get", arg0, arg1, arg2)
1408 }
1409
1410 func (_m *MockReplicaSetInterface) List(ctx context.Context, opts v12.ListOptions) (*v121.VirtualMachineInstanceReplicaSetList, error) {
1411 ret := _m.ctrl.Call(_m, "List", ctx, opts)
1412 ret0, _ := ret[0].(*v121.VirtualMachineInstanceReplicaSetList)
1413 ret1, _ := ret[1].(error)
1414 return ret0, ret1
1415 }
1416
1417 func (_mr *_MockReplicaSetInterfaceRecorder) List(arg0, arg1 interface{}) *gomock.Call {
1418 return _mr.mock.ctrl.RecordCall(_mr.mock, "List", arg0, arg1)
1419 }
1420
1421 func (_m *MockReplicaSetInterface) Watch(ctx context.Context, opts v12.ListOptions) (watch.Interface, error) {
1422 ret := _m.ctrl.Call(_m, "Watch", ctx, opts)
1423 ret0, _ := ret[0].(watch.Interface)
1424 ret1, _ := ret[1].(error)
1425 return ret0, ret1
1426 }
1427
1428 func (_mr *_MockReplicaSetInterfaceRecorder) Watch(arg0, arg1 interface{}) *gomock.Call {
1429 return _mr.mock.ctrl.RecordCall(_mr.mock, "Watch", arg0, arg1)
1430 }
1431
1432 func (_m *MockReplicaSetInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v12.PatchOptions, subresources ...string) (*v121.VirtualMachineInstanceReplicaSet, error) {
1433 _s := []interface{}{ctx, name, pt, data, opts}
1434 for _, _x := range subresources {
1435 _s = append(_s, _x)
1436 }
1437 ret := _m.ctrl.Call(_m, "Patch", _s...)
1438 ret0, _ := ret[0].(*v121.VirtualMachineInstanceReplicaSet)
1439 ret1, _ := ret[1].(error)
1440 return ret0, ret1
1441 }
1442
1443 func (_mr *_MockReplicaSetInterfaceRecorder) Patch(arg0, arg1, arg2, arg3, arg4 interface{}, arg5 ...interface{}) *gomock.Call {
1444 _s := append([]interface{}{arg0, arg1, arg2, arg3, arg4}, arg5...)
1445 return _mr.mock.ctrl.RecordCall(_mr.mock, "Patch", _s...)
1446 }
1447
1448 func (_m *MockReplicaSetInterface) GetScale(ctx context.Context, replicaSetName string, options v12.GetOptions) (*v11.Scale, error) {
1449 ret := _m.ctrl.Call(_m, "GetScale", ctx, replicaSetName, options)
1450 ret0, _ := ret[0].(*v11.Scale)
1451 ret1, _ := ret[1].(error)
1452 return ret0, ret1
1453 }
1454
1455 func (_mr *_MockReplicaSetInterfaceRecorder) GetScale(arg0, arg1, arg2 interface{}) *gomock.Call {
1456 return _mr.mock.ctrl.RecordCall(_mr.mock, "GetScale", arg0, arg1, arg2)
1457 }
1458
1459 func (_m *MockReplicaSetInterface) UpdateScale(ctx context.Context, replicaSetName string, scale *v11.Scale) (*v11.Scale, error) {
1460 ret := _m.ctrl.Call(_m, "UpdateScale", ctx, replicaSetName, scale)
1461 ret0, _ := ret[0].(*v11.Scale)
1462 ret1, _ := ret[1].(error)
1463 return ret0, ret1
1464 }
1465
1466 func (_mr *_MockReplicaSetInterfaceRecorder) UpdateScale(arg0, arg1, arg2 interface{}) *gomock.Call {
1467 return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateScale", arg0, arg1, arg2)
1468 }
1469
1470 func (_m *MockReplicaSetInterface) PatchStatus(ctx context.Context, name string, pt types.PatchType, data []byte, opts v12.PatchOptions) (*v121.VirtualMachineInstanceReplicaSet, error) {
1471 ret := _m.ctrl.Call(_m, "PatchStatus", ctx, name, pt, data, opts)
1472 ret0, _ := ret[0].(*v121.VirtualMachineInstanceReplicaSet)
1473 ret1, _ := ret[1].(error)
1474 return ret0, ret1
1475 }
1476
1477 func (_mr *_MockReplicaSetInterfaceRecorder) PatchStatus(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
1478 return _mr.mock.ctrl.RecordCall(_mr.mock, "PatchStatus", arg0, arg1, arg2, arg3, arg4)
1479 }
1480
1481
1482 type MockVirtualMachineInstancePresetInterface struct {
1483 ctrl *gomock.Controller
1484 recorder *_MockVirtualMachineInstancePresetInterfaceRecorder
1485 }
1486
1487
1488 type _MockVirtualMachineInstancePresetInterfaceRecorder struct {
1489 mock *MockVirtualMachineInstancePresetInterface
1490 }
1491
1492 func NewMockVirtualMachineInstancePresetInterface(ctrl *gomock.Controller) *MockVirtualMachineInstancePresetInterface {
1493 mock := &MockVirtualMachineInstancePresetInterface{ctrl: ctrl}
1494 mock.recorder = &_MockVirtualMachineInstancePresetInterfaceRecorder{mock}
1495 return mock
1496 }
1497
1498 func (_m *MockVirtualMachineInstancePresetInterface) EXPECT() *_MockVirtualMachineInstancePresetInterfaceRecorder {
1499 return _m.recorder
1500 }
1501
1502 func (_m *MockVirtualMachineInstancePresetInterface) Create(ctx context.Context, virtualMachineInstancePreset *v121.VirtualMachineInstancePreset, opts v12.CreateOptions) (*v121.VirtualMachineInstancePreset, error) {
1503 ret := _m.ctrl.Call(_m, "Create", ctx, virtualMachineInstancePreset, opts)
1504 ret0, _ := ret[0].(*v121.VirtualMachineInstancePreset)
1505 ret1, _ := ret[1].(error)
1506 return ret0, ret1
1507 }
1508
1509 func (_mr *_MockVirtualMachineInstancePresetInterfaceRecorder) Create(arg0, arg1, arg2 interface{}) *gomock.Call {
1510 return _mr.mock.ctrl.RecordCall(_mr.mock, "Create", arg0, arg1, arg2)
1511 }
1512
1513 func (_m *MockVirtualMachineInstancePresetInterface) Update(ctx context.Context, virtualMachineInstancePreset *v121.VirtualMachineInstancePreset, opts v12.UpdateOptions) (*v121.VirtualMachineInstancePreset, error) {
1514 ret := _m.ctrl.Call(_m, "Update", ctx, virtualMachineInstancePreset, opts)
1515 ret0, _ := ret[0].(*v121.VirtualMachineInstancePreset)
1516 ret1, _ := ret[1].(error)
1517 return ret0, ret1
1518 }
1519
1520 func (_mr *_MockVirtualMachineInstancePresetInterfaceRecorder) Update(arg0, arg1, arg2 interface{}) *gomock.Call {
1521 return _mr.mock.ctrl.RecordCall(_mr.mock, "Update", arg0, arg1, arg2)
1522 }
1523
1524 func (_m *MockVirtualMachineInstancePresetInterface) Delete(ctx context.Context, name string, opts v12.DeleteOptions) error {
1525 ret := _m.ctrl.Call(_m, "Delete", ctx, name, opts)
1526 ret0, _ := ret[0].(error)
1527 return ret0
1528 }
1529
1530 func (_mr *_MockVirtualMachineInstancePresetInterfaceRecorder) Delete(arg0, arg1, arg2 interface{}) *gomock.Call {
1531 return _mr.mock.ctrl.RecordCall(_mr.mock, "Delete", arg0, arg1, arg2)
1532 }
1533
1534 func (_m *MockVirtualMachineInstancePresetInterface) DeleteCollection(ctx context.Context, opts v12.DeleteOptions, listOpts v12.ListOptions) error {
1535 ret := _m.ctrl.Call(_m, "DeleteCollection", ctx, opts, listOpts)
1536 ret0, _ := ret[0].(error)
1537 return ret0
1538 }
1539
1540 func (_mr *_MockVirtualMachineInstancePresetInterfaceRecorder) DeleteCollection(arg0, arg1, arg2 interface{}) *gomock.Call {
1541 return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteCollection", arg0, arg1, arg2)
1542 }
1543
1544 func (_m *MockVirtualMachineInstancePresetInterface) Get(ctx context.Context, name string, opts v12.GetOptions) (*v121.VirtualMachineInstancePreset, error) {
1545 ret := _m.ctrl.Call(_m, "Get", ctx, name, opts)
1546 ret0, _ := ret[0].(*v121.VirtualMachineInstancePreset)
1547 ret1, _ := ret[1].(error)
1548 return ret0, ret1
1549 }
1550
1551 func (_mr *_MockVirtualMachineInstancePresetInterfaceRecorder) Get(arg0, arg1, arg2 interface{}) *gomock.Call {
1552 return _mr.mock.ctrl.RecordCall(_mr.mock, "Get", arg0, arg1, arg2)
1553 }
1554
1555 func (_m *MockVirtualMachineInstancePresetInterface) List(ctx context.Context, opts v12.ListOptions) (*v121.VirtualMachineInstancePresetList, error) {
1556 ret := _m.ctrl.Call(_m, "List", ctx, opts)
1557 ret0, _ := ret[0].(*v121.VirtualMachineInstancePresetList)
1558 ret1, _ := ret[1].(error)
1559 return ret0, ret1
1560 }
1561
1562 func (_mr *_MockVirtualMachineInstancePresetInterfaceRecorder) List(arg0, arg1 interface{}) *gomock.Call {
1563 return _mr.mock.ctrl.RecordCall(_mr.mock, "List", arg0, arg1)
1564 }
1565
1566 func (_m *MockVirtualMachineInstancePresetInterface) Watch(ctx context.Context, opts v12.ListOptions) (watch.Interface, error) {
1567 ret := _m.ctrl.Call(_m, "Watch", ctx, opts)
1568 ret0, _ := ret[0].(watch.Interface)
1569 ret1, _ := ret[1].(error)
1570 return ret0, ret1
1571 }
1572
1573 func (_mr *_MockVirtualMachineInstancePresetInterfaceRecorder) Watch(arg0, arg1 interface{}) *gomock.Call {
1574 return _mr.mock.ctrl.RecordCall(_mr.mock, "Watch", arg0, arg1)
1575 }
1576
1577 func (_m *MockVirtualMachineInstancePresetInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v12.PatchOptions, subresources ...string) (*v121.VirtualMachineInstancePreset, error) {
1578 _s := []interface{}{ctx, name, pt, data, opts}
1579 for _, _x := range subresources {
1580 _s = append(_s, _x)
1581 }
1582 ret := _m.ctrl.Call(_m, "Patch", _s...)
1583 ret0, _ := ret[0].(*v121.VirtualMachineInstancePreset)
1584 ret1, _ := ret[1].(error)
1585 return ret0, ret1
1586 }
1587
1588 func (_mr *_MockVirtualMachineInstancePresetInterfaceRecorder) Patch(arg0, arg1, arg2, arg3, arg4 interface{}, arg5 ...interface{}) *gomock.Call {
1589 _s := append([]interface{}{arg0, arg1, arg2, arg3, arg4}, arg5...)
1590 return _mr.mock.ctrl.RecordCall(_mr.mock, "Patch", _s...)
1591 }
1592
1593
1594 type MockVirtualMachineInterface struct {
1595 ctrl *gomock.Controller
1596 recorder *_MockVirtualMachineInterfaceRecorder
1597 }
1598
1599
1600 type _MockVirtualMachineInterfaceRecorder struct {
1601 mock *MockVirtualMachineInterface
1602 }
1603
1604 func NewMockVirtualMachineInterface(ctrl *gomock.Controller) *MockVirtualMachineInterface {
1605 mock := &MockVirtualMachineInterface{ctrl: ctrl}
1606 mock.recorder = &_MockVirtualMachineInterfaceRecorder{mock}
1607 return mock
1608 }
1609
1610 func (_m *MockVirtualMachineInterface) EXPECT() *_MockVirtualMachineInterfaceRecorder {
1611 return _m.recorder
1612 }
1613
1614 func (_m *MockVirtualMachineInterface) Create(ctx context.Context, virtualMachine *v121.VirtualMachine, opts v12.CreateOptions) (*v121.VirtualMachine, error) {
1615 ret := _m.ctrl.Call(_m, "Create", ctx, virtualMachine, opts)
1616 ret0, _ := ret[0].(*v121.VirtualMachine)
1617 ret1, _ := ret[1].(error)
1618 return ret0, ret1
1619 }
1620
1621 func (_mr *_MockVirtualMachineInterfaceRecorder) Create(arg0, arg1, arg2 interface{}) *gomock.Call {
1622 return _mr.mock.ctrl.RecordCall(_mr.mock, "Create", arg0, arg1, arg2)
1623 }
1624
1625 func (_m *MockVirtualMachineInterface) Update(ctx context.Context, virtualMachine *v121.VirtualMachine, opts v12.UpdateOptions) (*v121.VirtualMachine, error) {
1626 ret := _m.ctrl.Call(_m, "Update", ctx, virtualMachine, opts)
1627 ret0, _ := ret[0].(*v121.VirtualMachine)
1628 ret1, _ := ret[1].(error)
1629 return ret0, ret1
1630 }
1631
1632 func (_mr *_MockVirtualMachineInterfaceRecorder) Update(arg0, arg1, arg2 interface{}) *gomock.Call {
1633 return _mr.mock.ctrl.RecordCall(_mr.mock, "Update", arg0, arg1, arg2)
1634 }
1635
1636 func (_m *MockVirtualMachineInterface) UpdateStatus(ctx context.Context, virtualMachine *v121.VirtualMachine, opts v12.UpdateOptions) (*v121.VirtualMachine, error) {
1637 ret := _m.ctrl.Call(_m, "UpdateStatus", ctx, virtualMachine, opts)
1638 ret0, _ := ret[0].(*v121.VirtualMachine)
1639 ret1, _ := ret[1].(error)
1640 return ret0, ret1
1641 }
1642
1643 func (_mr *_MockVirtualMachineInterfaceRecorder) UpdateStatus(arg0, arg1, arg2 interface{}) *gomock.Call {
1644 return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateStatus", arg0, arg1, arg2)
1645 }
1646
1647 func (_m *MockVirtualMachineInterface) Delete(ctx context.Context, name string, opts v12.DeleteOptions) error {
1648 ret := _m.ctrl.Call(_m, "Delete", ctx, name, opts)
1649 ret0, _ := ret[0].(error)
1650 return ret0
1651 }
1652
1653 func (_mr *_MockVirtualMachineInterfaceRecorder) Delete(arg0, arg1, arg2 interface{}) *gomock.Call {
1654 return _mr.mock.ctrl.RecordCall(_mr.mock, "Delete", arg0, arg1, arg2)
1655 }
1656
1657 func (_m *MockVirtualMachineInterface) DeleteCollection(ctx context.Context, opts v12.DeleteOptions, listOpts v12.ListOptions) error {
1658 ret := _m.ctrl.Call(_m, "DeleteCollection", ctx, opts, listOpts)
1659 ret0, _ := ret[0].(error)
1660 return ret0
1661 }
1662
1663 func (_mr *_MockVirtualMachineInterfaceRecorder) DeleteCollection(arg0, arg1, arg2 interface{}) *gomock.Call {
1664 return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteCollection", arg0, arg1, arg2)
1665 }
1666
1667 func (_m *MockVirtualMachineInterface) Get(ctx context.Context, name string, opts v12.GetOptions) (*v121.VirtualMachine, error) {
1668 ret := _m.ctrl.Call(_m, "Get", ctx, name, opts)
1669 ret0, _ := ret[0].(*v121.VirtualMachine)
1670 ret1, _ := ret[1].(error)
1671 return ret0, ret1
1672 }
1673
1674 func (_mr *_MockVirtualMachineInterfaceRecorder) Get(arg0, arg1, arg2 interface{}) *gomock.Call {
1675 return _mr.mock.ctrl.RecordCall(_mr.mock, "Get", arg0, arg1, arg2)
1676 }
1677
1678 func (_m *MockVirtualMachineInterface) List(ctx context.Context, opts v12.ListOptions) (*v121.VirtualMachineList, error) {
1679 ret := _m.ctrl.Call(_m, "List", ctx, opts)
1680 ret0, _ := ret[0].(*v121.VirtualMachineList)
1681 ret1, _ := ret[1].(error)
1682 return ret0, ret1
1683 }
1684
1685 func (_mr *_MockVirtualMachineInterfaceRecorder) List(arg0, arg1 interface{}) *gomock.Call {
1686 return _mr.mock.ctrl.RecordCall(_mr.mock, "List", arg0, arg1)
1687 }
1688
1689 func (_m *MockVirtualMachineInterface) Watch(ctx context.Context, opts v12.ListOptions) (watch.Interface, error) {
1690 ret := _m.ctrl.Call(_m, "Watch", ctx, opts)
1691 ret0, _ := ret[0].(watch.Interface)
1692 ret1, _ := ret[1].(error)
1693 return ret0, ret1
1694 }
1695
1696 func (_mr *_MockVirtualMachineInterfaceRecorder) Watch(arg0, arg1 interface{}) *gomock.Call {
1697 return _mr.mock.ctrl.RecordCall(_mr.mock, "Watch", arg0, arg1)
1698 }
1699
1700 func (_m *MockVirtualMachineInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v12.PatchOptions, subresources ...string) (*v121.VirtualMachine, error) {
1701 _s := []interface{}{ctx, name, pt, data, opts}
1702 for _, _x := range subresources {
1703 _s = append(_s, _x)
1704 }
1705 ret := _m.ctrl.Call(_m, "Patch", _s...)
1706 ret0, _ := ret[0].(*v121.VirtualMachine)
1707 ret1, _ := ret[1].(error)
1708 return ret0, ret1
1709 }
1710
1711 func (_mr *_MockVirtualMachineInterfaceRecorder) Patch(arg0, arg1, arg2, arg3, arg4 interface{}, arg5 ...interface{}) *gomock.Call {
1712 _s := append([]interface{}{arg0, arg1, arg2, arg3, arg4}, arg5...)
1713 return _mr.mock.ctrl.RecordCall(_mr.mock, "Patch", _s...)
1714 }
1715
1716 func (_m *MockVirtualMachineInterface) GetWithExpandedSpec(ctx context.Context, name string) (*v121.VirtualMachine, error) {
1717 ret := _m.ctrl.Call(_m, "GetWithExpandedSpec", ctx, name)
1718 ret0, _ := ret[0].(*v121.VirtualMachine)
1719 ret1, _ := ret[1].(error)
1720 return ret0, ret1
1721 }
1722
1723 func (_mr *_MockVirtualMachineInterfaceRecorder) GetWithExpandedSpec(arg0, arg1 interface{}) *gomock.Call {
1724 return _mr.mock.ctrl.RecordCall(_mr.mock, "GetWithExpandedSpec", arg0, arg1)
1725 }
1726
1727 func (_m *MockVirtualMachineInterface) PatchStatus(ctx context.Context, name string, pt types.PatchType, data []byte, patchOptions v12.PatchOptions) (*v121.VirtualMachine, error) {
1728 ret := _m.ctrl.Call(_m, "PatchStatus", ctx, name, pt, data, patchOptions)
1729 ret0, _ := ret[0].(*v121.VirtualMachine)
1730 ret1, _ := ret[1].(error)
1731 return ret0, ret1
1732 }
1733
1734 func (_mr *_MockVirtualMachineInterfaceRecorder) PatchStatus(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
1735 return _mr.mock.ctrl.RecordCall(_mr.mock, "PatchStatus", arg0, arg1, arg2, arg3, arg4)
1736 }
1737
1738 func (_m *MockVirtualMachineInterface) Restart(ctx context.Context, name string, restartOptions *v121.RestartOptions) error {
1739 ret := _m.ctrl.Call(_m, "Restart", ctx, name, restartOptions)
1740 ret0, _ := ret[0].(error)
1741 return ret0
1742 }
1743
1744 func (_mr *_MockVirtualMachineInterfaceRecorder) Restart(arg0, arg1, arg2 interface{}) *gomock.Call {
1745 return _mr.mock.ctrl.RecordCall(_mr.mock, "Restart", arg0, arg1, arg2)
1746 }
1747
1748 func (_m *MockVirtualMachineInterface) ForceRestart(ctx context.Context, name string, restartOptions *v121.RestartOptions) error {
1749 ret := _m.ctrl.Call(_m, "ForceRestart", ctx, name, restartOptions)
1750 ret0, _ := ret[0].(error)
1751 return ret0
1752 }
1753
1754 func (_mr *_MockVirtualMachineInterfaceRecorder) ForceRestart(arg0, arg1, arg2 interface{}) *gomock.Call {
1755 return _mr.mock.ctrl.RecordCall(_mr.mock, "ForceRestart", arg0, arg1, arg2)
1756 }
1757
1758 func (_m *MockVirtualMachineInterface) Start(ctx context.Context, name string, startOptions *v121.StartOptions) error {
1759 ret := _m.ctrl.Call(_m, "Start", ctx, name, startOptions)
1760 ret0, _ := ret[0].(error)
1761 return ret0
1762 }
1763
1764 func (_mr *_MockVirtualMachineInterfaceRecorder) Start(arg0, arg1, arg2 interface{}) *gomock.Call {
1765 return _mr.mock.ctrl.RecordCall(_mr.mock, "Start", arg0, arg1, arg2)
1766 }
1767
1768 func (_m *MockVirtualMachineInterface) Stop(ctx context.Context, name string, stopOptions *v121.StopOptions) error {
1769 ret := _m.ctrl.Call(_m, "Stop", ctx, name, stopOptions)
1770 ret0, _ := ret[0].(error)
1771 return ret0
1772 }
1773
1774 func (_mr *_MockVirtualMachineInterfaceRecorder) Stop(arg0, arg1, arg2 interface{}) *gomock.Call {
1775 return _mr.mock.ctrl.RecordCall(_mr.mock, "Stop", arg0, arg1, arg2)
1776 }
1777
1778 func (_m *MockVirtualMachineInterface) ForceStop(ctx context.Context, name string, stopOptions *v121.StopOptions) error {
1779 ret := _m.ctrl.Call(_m, "ForceStop", ctx, name, stopOptions)
1780 ret0, _ := ret[0].(error)
1781 return ret0
1782 }
1783
1784 func (_mr *_MockVirtualMachineInterfaceRecorder) ForceStop(arg0, arg1, arg2 interface{}) *gomock.Call {
1785 return _mr.mock.ctrl.RecordCall(_mr.mock, "ForceStop", arg0, arg1, arg2)
1786 }
1787
1788 func (_m *MockVirtualMachineInterface) Migrate(ctx context.Context, name string, migrateOptions *v121.MigrateOptions) error {
1789 ret := _m.ctrl.Call(_m, "Migrate", ctx, name, migrateOptions)
1790 ret0, _ := ret[0].(error)
1791 return ret0
1792 }
1793
1794 func (_mr *_MockVirtualMachineInterfaceRecorder) Migrate(arg0, arg1, arg2 interface{}) *gomock.Call {
1795 return _mr.mock.ctrl.RecordCall(_mr.mock, "Migrate", arg0, arg1, arg2)
1796 }
1797
1798 func (_m *MockVirtualMachineInterface) AddVolume(ctx context.Context, name string, addVolumeOptions *v121.AddVolumeOptions) error {
1799 ret := _m.ctrl.Call(_m, "AddVolume", ctx, name, addVolumeOptions)
1800 ret0, _ := ret[0].(error)
1801 return ret0
1802 }
1803
1804 func (_mr *_MockVirtualMachineInterfaceRecorder) AddVolume(arg0, arg1, arg2 interface{}) *gomock.Call {
1805 return _mr.mock.ctrl.RecordCall(_mr.mock, "AddVolume", arg0, arg1, arg2)
1806 }
1807
1808 func (_m *MockVirtualMachineInterface) RemoveVolume(ctx context.Context, name string, removeVolumeOptions *v121.RemoveVolumeOptions) error {
1809 ret := _m.ctrl.Call(_m, "RemoveVolume", ctx, name, removeVolumeOptions)
1810 ret0, _ := ret[0].(error)
1811 return ret0
1812 }
1813
1814 func (_mr *_MockVirtualMachineInterfaceRecorder) RemoveVolume(arg0, arg1, arg2 interface{}) *gomock.Call {
1815 return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveVolume", arg0, arg1, arg2)
1816 }
1817
1818 func (_m *MockVirtualMachineInterface) PortForward(name string, port int, protocol string) (v122.StreamInterface, error) {
1819 ret := _m.ctrl.Call(_m, "PortForward", name, port, protocol)
1820 ret0, _ := ret[0].(v122.StreamInterface)
1821 ret1, _ := ret[1].(error)
1822 return ret0, ret1
1823 }
1824
1825 func (_mr *_MockVirtualMachineInterfaceRecorder) PortForward(arg0, arg1, arg2 interface{}) *gomock.Call {
1826 return _mr.mock.ctrl.RecordCall(_mr.mock, "PortForward", arg0, arg1, arg2)
1827 }
1828
1829 func (_m *MockVirtualMachineInterface) MemoryDump(ctx context.Context, name string, memoryDumpRequest *v121.VirtualMachineMemoryDumpRequest) error {
1830 ret := _m.ctrl.Call(_m, "MemoryDump", ctx, name, memoryDumpRequest)
1831 ret0, _ := ret[0].(error)
1832 return ret0
1833 }
1834
1835 func (_mr *_MockVirtualMachineInterfaceRecorder) MemoryDump(arg0, arg1, arg2 interface{}) *gomock.Call {
1836 return _mr.mock.ctrl.RecordCall(_mr.mock, "MemoryDump", arg0, arg1, arg2)
1837 }
1838
1839 func (_m *MockVirtualMachineInterface) RemoveMemoryDump(ctx context.Context, name string) error {
1840 ret := _m.ctrl.Call(_m, "RemoveMemoryDump", ctx, name)
1841 ret0, _ := ret[0].(error)
1842 return ret0
1843 }
1844
1845 func (_mr *_MockVirtualMachineInterfaceRecorder) RemoveMemoryDump(arg0, arg1 interface{}) *gomock.Call {
1846 return _mr.mock.ctrl.RecordCall(_mr.mock, "RemoveMemoryDump", arg0, arg1)
1847 }
1848
1849
1850 type MockVirtualMachineInstanceMigrationInterface struct {
1851 ctrl *gomock.Controller
1852 recorder *_MockVirtualMachineInstanceMigrationInterfaceRecorder
1853 }
1854
1855
1856 type _MockVirtualMachineInstanceMigrationInterfaceRecorder struct {
1857 mock *MockVirtualMachineInstanceMigrationInterface
1858 }
1859
1860 func NewMockVirtualMachineInstanceMigrationInterface(ctrl *gomock.Controller) *MockVirtualMachineInstanceMigrationInterface {
1861 mock := &MockVirtualMachineInstanceMigrationInterface{ctrl: ctrl}
1862 mock.recorder = &_MockVirtualMachineInstanceMigrationInterfaceRecorder{mock}
1863 return mock
1864 }
1865
1866 func (_m *MockVirtualMachineInstanceMigrationInterface) EXPECT() *_MockVirtualMachineInstanceMigrationInterfaceRecorder {
1867 return _m.recorder
1868 }
1869
1870 func (_m *MockVirtualMachineInstanceMigrationInterface) Create(ctx context.Context, virtualMachineInstanceMigration *v121.VirtualMachineInstanceMigration, opts v12.CreateOptions) (*v121.VirtualMachineInstanceMigration, error) {
1871 ret := _m.ctrl.Call(_m, "Create", ctx, virtualMachineInstanceMigration, opts)
1872 ret0, _ := ret[0].(*v121.VirtualMachineInstanceMigration)
1873 ret1, _ := ret[1].(error)
1874 return ret0, ret1
1875 }
1876
1877 func (_mr *_MockVirtualMachineInstanceMigrationInterfaceRecorder) Create(arg0, arg1, arg2 interface{}) *gomock.Call {
1878 return _mr.mock.ctrl.RecordCall(_mr.mock, "Create", arg0, arg1, arg2)
1879 }
1880
1881 func (_m *MockVirtualMachineInstanceMigrationInterface) Update(ctx context.Context, virtualMachineInstanceMigration *v121.VirtualMachineInstanceMigration, opts v12.UpdateOptions) (*v121.VirtualMachineInstanceMigration, error) {
1882 ret := _m.ctrl.Call(_m, "Update", ctx, virtualMachineInstanceMigration, opts)
1883 ret0, _ := ret[0].(*v121.VirtualMachineInstanceMigration)
1884 ret1, _ := ret[1].(error)
1885 return ret0, ret1
1886 }
1887
1888 func (_mr *_MockVirtualMachineInstanceMigrationInterfaceRecorder) Update(arg0, arg1, arg2 interface{}) *gomock.Call {
1889 return _mr.mock.ctrl.RecordCall(_mr.mock, "Update", arg0, arg1, arg2)
1890 }
1891
1892 func (_m *MockVirtualMachineInstanceMigrationInterface) UpdateStatus(ctx context.Context, virtualMachineInstanceMigration *v121.VirtualMachineInstanceMigration, opts v12.UpdateOptions) (*v121.VirtualMachineInstanceMigration, error) {
1893 ret := _m.ctrl.Call(_m, "UpdateStatus", ctx, virtualMachineInstanceMigration, opts)
1894 ret0, _ := ret[0].(*v121.VirtualMachineInstanceMigration)
1895 ret1, _ := ret[1].(error)
1896 return ret0, ret1
1897 }
1898
1899 func (_mr *_MockVirtualMachineInstanceMigrationInterfaceRecorder) UpdateStatus(arg0, arg1, arg2 interface{}) *gomock.Call {
1900 return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateStatus", arg0, arg1, arg2)
1901 }
1902
1903 func (_m *MockVirtualMachineInstanceMigrationInterface) Delete(ctx context.Context, name string, opts v12.DeleteOptions) error {
1904 ret := _m.ctrl.Call(_m, "Delete", ctx, name, opts)
1905 ret0, _ := ret[0].(error)
1906 return ret0
1907 }
1908
1909 func (_mr *_MockVirtualMachineInstanceMigrationInterfaceRecorder) Delete(arg0, arg1, arg2 interface{}) *gomock.Call {
1910 return _mr.mock.ctrl.RecordCall(_mr.mock, "Delete", arg0, arg1, arg2)
1911 }
1912
1913 func (_m *MockVirtualMachineInstanceMigrationInterface) DeleteCollection(ctx context.Context, opts v12.DeleteOptions, listOpts v12.ListOptions) error {
1914 ret := _m.ctrl.Call(_m, "DeleteCollection", ctx, opts, listOpts)
1915 ret0, _ := ret[0].(error)
1916 return ret0
1917 }
1918
1919 func (_mr *_MockVirtualMachineInstanceMigrationInterfaceRecorder) DeleteCollection(arg0, arg1, arg2 interface{}) *gomock.Call {
1920 return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteCollection", arg0, arg1, arg2)
1921 }
1922
1923 func (_m *MockVirtualMachineInstanceMigrationInterface) Get(ctx context.Context, name string, opts v12.GetOptions) (*v121.VirtualMachineInstanceMigration, error) {
1924 ret := _m.ctrl.Call(_m, "Get", ctx, name, opts)
1925 ret0, _ := ret[0].(*v121.VirtualMachineInstanceMigration)
1926 ret1, _ := ret[1].(error)
1927 return ret0, ret1
1928 }
1929
1930 func (_mr *_MockVirtualMachineInstanceMigrationInterfaceRecorder) Get(arg0, arg1, arg2 interface{}) *gomock.Call {
1931 return _mr.mock.ctrl.RecordCall(_mr.mock, "Get", arg0, arg1, arg2)
1932 }
1933
1934 func (_m *MockVirtualMachineInstanceMigrationInterface) List(ctx context.Context, opts v12.ListOptions) (*v121.VirtualMachineInstanceMigrationList, error) {
1935 ret := _m.ctrl.Call(_m, "List", ctx, opts)
1936 ret0, _ := ret[0].(*v121.VirtualMachineInstanceMigrationList)
1937 ret1, _ := ret[1].(error)
1938 return ret0, ret1
1939 }
1940
1941 func (_mr *_MockVirtualMachineInstanceMigrationInterfaceRecorder) List(arg0, arg1 interface{}) *gomock.Call {
1942 return _mr.mock.ctrl.RecordCall(_mr.mock, "List", arg0, arg1)
1943 }
1944
1945 func (_m *MockVirtualMachineInstanceMigrationInterface) Watch(ctx context.Context, opts v12.ListOptions) (watch.Interface, error) {
1946 ret := _m.ctrl.Call(_m, "Watch", ctx, opts)
1947 ret0, _ := ret[0].(watch.Interface)
1948 ret1, _ := ret[1].(error)
1949 return ret0, ret1
1950 }
1951
1952 func (_mr *_MockVirtualMachineInstanceMigrationInterfaceRecorder) Watch(arg0, arg1 interface{}) *gomock.Call {
1953 return _mr.mock.ctrl.RecordCall(_mr.mock, "Watch", arg0, arg1)
1954 }
1955
1956 func (_m *MockVirtualMachineInstanceMigrationInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v12.PatchOptions, subresources ...string) (*v121.VirtualMachineInstanceMigration, error) {
1957 _s := []interface{}{ctx, name, pt, data, opts}
1958 for _, _x := range subresources {
1959 _s = append(_s, _x)
1960 }
1961 ret := _m.ctrl.Call(_m, "Patch", _s...)
1962 ret0, _ := ret[0].(*v121.VirtualMachineInstanceMigration)
1963 ret1, _ := ret[1].(error)
1964 return ret0, ret1
1965 }
1966
1967 func (_mr *_MockVirtualMachineInstanceMigrationInterfaceRecorder) Patch(arg0, arg1, arg2, arg3, arg4 interface{}, arg5 ...interface{}) *gomock.Call {
1968 _s := append([]interface{}{arg0, arg1, arg2, arg3, arg4}, arg5...)
1969 return _mr.mock.ctrl.RecordCall(_mr.mock, "Patch", _s...)
1970 }
1971
1972 func (_m *MockVirtualMachineInstanceMigrationInterface) PatchStatus(ctx context.Context, name string, pt types.PatchType, data []byte, opts v12.PatchOptions) (*v121.VirtualMachineInstanceMigration, error) {
1973 ret := _m.ctrl.Call(_m, "PatchStatus", ctx, name, pt, data, opts)
1974 ret0, _ := ret[0].(*v121.VirtualMachineInstanceMigration)
1975 ret1, _ := ret[1].(error)
1976 return ret0, ret1
1977 }
1978
1979 func (_mr *_MockVirtualMachineInstanceMigrationInterfaceRecorder) PatchStatus(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
1980 return _mr.mock.ctrl.RecordCall(_mr.mock, "PatchStatus", arg0, arg1, arg2, arg3, arg4)
1981 }
1982
1983
1984 type MockKubeVirtInterface struct {
1985 ctrl *gomock.Controller
1986 recorder *_MockKubeVirtInterfaceRecorder
1987 }
1988
1989
1990 type _MockKubeVirtInterfaceRecorder struct {
1991 mock *MockKubeVirtInterface
1992 }
1993
1994 func NewMockKubeVirtInterface(ctrl *gomock.Controller) *MockKubeVirtInterface {
1995 mock := &MockKubeVirtInterface{ctrl: ctrl}
1996 mock.recorder = &_MockKubeVirtInterfaceRecorder{mock}
1997 return mock
1998 }
1999
2000 func (_m *MockKubeVirtInterface) EXPECT() *_MockKubeVirtInterfaceRecorder {
2001 return _m.recorder
2002 }
2003
2004 func (_m *MockKubeVirtInterface) Create(ctx context.Context, kubeVirt *v121.KubeVirt, opts v12.CreateOptions) (*v121.KubeVirt, error) {
2005 ret := _m.ctrl.Call(_m, "Create", ctx, kubeVirt, opts)
2006 ret0, _ := ret[0].(*v121.KubeVirt)
2007 ret1, _ := ret[1].(error)
2008 return ret0, ret1
2009 }
2010
2011 func (_mr *_MockKubeVirtInterfaceRecorder) Create(arg0, arg1, arg2 interface{}) *gomock.Call {
2012 return _mr.mock.ctrl.RecordCall(_mr.mock, "Create", arg0, arg1, arg2)
2013 }
2014
2015 func (_m *MockKubeVirtInterface) Update(ctx context.Context, kubeVirt *v121.KubeVirt, opts v12.UpdateOptions) (*v121.KubeVirt, error) {
2016 ret := _m.ctrl.Call(_m, "Update", ctx, kubeVirt, opts)
2017 ret0, _ := ret[0].(*v121.KubeVirt)
2018 ret1, _ := ret[1].(error)
2019 return ret0, ret1
2020 }
2021
2022 func (_mr *_MockKubeVirtInterfaceRecorder) Update(arg0, arg1, arg2 interface{}) *gomock.Call {
2023 return _mr.mock.ctrl.RecordCall(_mr.mock, "Update", arg0, arg1, arg2)
2024 }
2025
2026 func (_m *MockKubeVirtInterface) UpdateStatus(ctx context.Context, kubeVirt *v121.KubeVirt, opts v12.UpdateOptions) (*v121.KubeVirt, error) {
2027 ret := _m.ctrl.Call(_m, "UpdateStatus", ctx, kubeVirt, opts)
2028 ret0, _ := ret[0].(*v121.KubeVirt)
2029 ret1, _ := ret[1].(error)
2030 return ret0, ret1
2031 }
2032
2033 func (_mr *_MockKubeVirtInterfaceRecorder) UpdateStatus(arg0, arg1, arg2 interface{}) *gomock.Call {
2034 return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateStatus", arg0, arg1, arg2)
2035 }
2036
2037 func (_m *MockKubeVirtInterface) Delete(ctx context.Context, name string, opts v12.DeleteOptions) error {
2038 ret := _m.ctrl.Call(_m, "Delete", ctx, name, opts)
2039 ret0, _ := ret[0].(error)
2040 return ret0
2041 }
2042
2043 func (_mr *_MockKubeVirtInterfaceRecorder) Delete(arg0, arg1, arg2 interface{}) *gomock.Call {
2044 return _mr.mock.ctrl.RecordCall(_mr.mock, "Delete", arg0, arg1, arg2)
2045 }
2046
2047 func (_m *MockKubeVirtInterface) DeleteCollection(ctx context.Context, opts v12.DeleteOptions, listOpts v12.ListOptions) error {
2048 ret := _m.ctrl.Call(_m, "DeleteCollection", ctx, opts, listOpts)
2049 ret0, _ := ret[0].(error)
2050 return ret0
2051 }
2052
2053 func (_mr *_MockKubeVirtInterfaceRecorder) DeleteCollection(arg0, arg1, arg2 interface{}) *gomock.Call {
2054 return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteCollection", arg0, arg1, arg2)
2055 }
2056
2057 func (_m *MockKubeVirtInterface) Get(ctx context.Context, name string, opts v12.GetOptions) (*v121.KubeVirt, error) {
2058 ret := _m.ctrl.Call(_m, "Get", ctx, name, opts)
2059 ret0, _ := ret[0].(*v121.KubeVirt)
2060 ret1, _ := ret[1].(error)
2061 return ret0, ret1
2062 }
2063
2064 func (_mr *_MockKubeVirtInterfaceRecorder) Get(arg0, arg1, arg2 interface{}) *gomock.Call {
2065 return _mr.mock.ctrl.RecordCall(_mr.mock, "Get", arg0, arg1, arg2)
2066 }
2067
2068 func (_m *MockKubeVirtInterface) List(ctx context.Context, opts v12.ListOptions) (*v121.KubeVirtList, error) {
2069 ret := _m.ctrl.Call(_m, "List", ctx, opts)
2070 ret0, _ := ret[0].(*v121.KubeVirtList)
2071 ret1, _ := ret[1].(error)
2072 return ret0, ret1
2073 }
2074
2075 func (_mr *_MockKubeVirtInterfaceRecorder) List(arg0, arg1 interface{}) *gomock.Call {
2076 return _mr.mock.ctrl.RecordCall(_mr.mock, "List", arg0, arg1)
2077 }
2078
2079 func (_m *MockKubeVirtInterface) Watch(ctx context.Context, opts v12.ListOptions) (watch.Interface, error) {
2080 ret := _m.ctrl.Call(_m, "Watch", ctx, opts)
2081 ret0, _ := ret[0].(watch.Interface)
2082 ret1, _ := ret[1].(error)
2083 return ret0, ret1
2084 }
2085
2086 func (_mr *_MockKubeVirtInterfaceRecorder) Watch(arg0, arg1 interface{}) *gomock.Call {
2087 return _mr.mock.ctrl.RecordCall(_mr.mock, "Watch", arg0, arg1)
2088 }
2089
2090 func (_m *MockKubeVirtInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v12.PatchOptions, subresources ...string) (*v121.KubeVirt, error) {
2091 _s := []interface{}{ctx, name, pt, data, opts}
2092 for _, _x := range subresources {
2093 _s = append(_s, _x)
2094 }
2095 ret := _m.ctrl.Call(_m, "Patch", _s...)
2096 ret0, _ := ret[0].(*v121.KubeVirt)
2097 ret1, _ := ret[1].(error)
2098 return ret0, ret1
2099 }
2100
2101 func (_mr *_MockKubeVirtInterfaceRecorder) Patch(arg0, arg1, arg2, arg3, arg4 interface{}, arg5 ...interface{}) *gomock.Call {
2102 _s := append([]interface{}{arg0, arg1, arg2, arg3, arg4}, arg5...)
2103 return _mr.mock.ctrl.RecordCall(_mr.mock, "Patch", _s...)
2104 }
2105
2106 func (_m *MockKubeVirtInterface) PatchStatus(ctx context.Context, name string, pt types.PatchType, data []byte, patchOptions v12.PatchOptions) (*v121.KubeVirt, error) {
2107 ret := _m.ctrl.Call(_m, "PatchStatus", ctx, name, pt, data, patchOptions)
2108 ret0, _ := ret[0].(*v121.KubeVirt)
2109 ret1, _ := ret[1].(error)
2110 return ret0, ret1
2111 }
2112
2113 func (_mr *_MockKubeVirtInterfaceRecorder) PatchStatus(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
2114 return _mr.mock.ctrl.RecordCall(_mr.mock, "PatchStatus", arg0, arg1, arg2, arg3, arg4)
2115 }
2116
2117
2118 type MockServerVersionInterface struct {
2119 ctrl *gomock.Controller
2120 recorder *_MockServerVersionInterfaceRecorder
2121 }
2122
2123
2124 type _MockServerVersionInterfaceRecorder struct {
2125 mock *MockServerVersionInterface
2126 }
2127
2128 func NewMockServerVersionInterface(ctrl *gomock.Controller) *MockServerVersionInterface {
2129 mock := &MockServerVersionInterface{ctrl: ctrl}
2130 mock.recorder = &_MockServerVersionInterfaceRecorder{mock}
2131 return mock
2132 }
2133
2134 func (_m *MockServerVersionInterface) EXPECT() *_MockServerVersionInterfaceRecorder {
2135 return _m.recorder
2136 }
2137
2138 func (_m *MockServerVersionInterface) Get() (*version.Info, error) {
2139 ret := _m.ctrl.Call(_m, "Get")
2140 ret0, _ := ret[0].(*version.Info)
2141 ret1, _ := ret[1].(error)
2142 return ret0, ret1
2143 }
2144
2145 func (_mr *_MockServerVersionInterfaceRecorder) Get() *gomock.Call {
2146 return _mr.mock.ctrl.RecordCall(_mr.mock, "Get")
2147 }
2148
2149
2150 type MockExpandSpecInterface struct {
2151 ctrl *gomock.Controller
2152 recorder *_MockExpandSpecInterfaceRecorder
2153 }
2154
2155
2156 type _MockExpandSpecInterfaceRecorder struct {
2157 mock *MockExpandSpecInterface
2158 }
2159
2160 func NewMockExpandSpecInterface(ctrl *gomock.Controller) *MockExpandSpecInterface {
2161 mock := &MockExpandSpecInterface{ctrl: ctrl}
2162 mock.recorder = &_MockExpandSpecInterfaceRecorder{mock}
2163 return mock
2164 }
2165
2166 func (_m *MockExpandSpecInterface) EXPECT() *_MockExpandSpecInterfaceRecorder {
2167 return _m.recorder
2168 }
2169
2170 func (_m *MockExpandSpecInterface) ForVirtualMachine(vm *v121.VirtualMachine) (*v121.VirtualMachine, error) {
2171 ret := _m.ctrl.Call(_m, "ForVirtualMachine", vm)
2172 ret0, _ := ret[0].(*v121.VirtualMachine)
2173 ret1, _ := ret[1].(error)
2174 return ret0, ret1
2175 }
2176
2177 func (_mr *_MockExpandSpecInterfaceRecorder) ForVirtualMachine(arg0 interface{}) *gomock.Call {
2178 return _mr.mock.ctrl.RecordCall(_mr.mock, "ForVirtualMachine", arg0)
2179 }
2180
View as plain text