1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package mocks
6
7import (
8 "context"
9 "gordon/internal/domain"
10 "io"
11
12 mock "github.com/stretchr/testify/mock"
13)
14
15// NewMockContainerRuntime creates a new instance of MockContainerRuntime. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
16// The first argument is typically a *testing.T value.
17func NewMockContainerRuntime(t interface {
18 mock.TestingT
19 Cleanup(func())
20}) *MockContainerRuntime {
21 mock := &MockContainerRuntime{}
22 mock.Mock.Test(t)
23
24 t.Cleanup(func() { mock.AssertExpectations(t) })
25
26 return mock
27}
28
29// MockContainerRuntime is an autogenerated mock type for the ContainerRuntime type
30type MockContainerRuntime struct {
31 mock.Mock
32}
33
34type MockContainerRuntime_Expecter struct {
35 mock *mock.Mock
36}
37
38func (_m *MockContainerRuntime) EXPECT() *MockContainerRuntime_Expecter {
39 return &MockContainerRuntime_Expecter{mock: &_m.Mock}
40}
41
42// ConnectContainerToNetwork provides a mock function for the type MockContainerRuntime
43func (_mock *MockContainerRuntime) ConnectContainerToNetwork(ctx context.Context, containerName string, networkName string) error {
44 ret := _mock.Called(ctx, containerName, networkName)
45
46 if len(ret) == 0 {
47 panic("no return value specified for ConnectContainerToNetwork")
48 }
49
50 var r0 error
51 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
52 r0 = returnFunc(ctx, containerName, networkName)
53 } else {
54 r0 = ret.Error(0)
55 }
56 return r0
57}
58
59// MockContainerRuntime_ConnectContainerToNetwork_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectContainerToNetwork'
60type MockContainerRuntime_ConnectContainerToNetwork_Call struct {
61 *mock.Call
62}
63
64// ConnectContainerToNetwork is a helper method to define mock.On call
65// - ctx context.Context
66// - containerName string
67// - networkName string
68func (_e *MockContainerRuntime_Expecter) ConnectContainerToNetwork(ctx interface{}, containerName interface{}, networkName interface{}) *MockContainerRuntime_ConnectContainerToNetwork_Call {
69 return &MockContainerRuntime_ConnectContainerToNetwork_Call{Call: _e.mock.On("ConnectContainerToNetwork", ctx, containerName, networkName)}
70}
71
72func (_c *MockContainerRuntime_ConnectContainerToNetwork_Call) Run(run func(ctx context.Context, containerName string, networkName string)) *MockContainerRuntime_ConnectContainerToNetwork_Call {
73 _c.Call.Run(func(args mock.Arguments) {
74 var arg0 context.Context
75 if args[0] != nil {
76 arg0 = args[0].(context.Context)
77 }
78 var arg1 string
79 if args[1] != nil {
80 arg1 = args[1].(string)
81 }
82 var arg2 string
83 if args[2] != nil {
84 arg2 = args[2].(string)
85 }
86 run(
87 arg0,
88 arg1,
89 arg2,
90 )
91 })
92 return _c
93}
94
95func (_c *MockContainerRuntime_ConnectContainerToNetwork_Call) Return(err error) *MockContainerRuntime_ConnectContainerToNetwork_Call {
96 _c.Call.Return(err)
97 return _c
98}
99
100func (_c *MockContainerRuntime_ConnectContainerToNetwork_Call) RunAndReturn(run func(ctx context.Context, containerName string, networkName string) error) *MockContainerRuntime_ConnectContainerToNetwork_Call {
101 _c.Call.Return(run)
102 return _c
103}
104
105// CreateContainer provides a mock function for the type MockContainerRuntime
106func (_mock *MockContainerRuntime) CreateContainer(ctx context.Context, config *domain.ContainerConfig) (*domain.Container, error) {
107 ret := _mock.Called(ctx, config)
108
109 if len(ret) == 0 {
110 panic("no return value specified for CreateContainer")
111 }
112
113 var r0 *domain.Container
114 var r1 error
115 if returnFunc, ok := ret.Get(0).(func(context.Context, *domain.ContainerConfig) (*domain.Container, error)); ok {
116 return returnFunc(ctx, config)
117 }
118 if returnFunc, ok := ret.Get(0).(func(context.Context, *domain.ContainerConfig) *domain.Container); ok {
119 r0 = returnFunc(ctx, config)
120 } else {
121 if ret.Get(0) != nil {
122 r0 = ret.Get(0).(*domain.Container)
123 }
124 }
125 if returnFunc, ok := ret.Get(1).(func(context.Context, *domain.ContainerConfig) error); ok {
126 r1 = returnFunc(ctx, config)
127 } else {
128 r1 = ret.Error(1)
129 }
130 return r0, r1
131}
132
133// MockContainerRuntime_CreateContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateContainer'
134type MockContainerRuntime_CreateContainer_Call struct {
135 *mock.Call
136}
137
138// CreateContainer is a helper method to define mock.On call
139// - ctx context.Context
140// - config *domain.ContainerConfig
141func (_e *MockContainerRuntime_Expecter) CreateContainer(ctx interface{}, config interface{}) *MockContainerRuntime_CreateContainer_Call {
142 return &MockContainerRuntime_CreateContainer_Call{Call: _e.mock.On("CreateContainer", ctx, config)}
143}
144
145func (_c *MockContainerRuntime_CreateContainer_Call) Run(run func(ctx context.Context, config *domain.ContainerConfig)) *MockContainerRuntime_CreateContainer_Call {
146 _c.Call.Run(func(args mock.Arguments) {
147 var arg0 context.Context
148 if args[0] != nil {
149 arg0 = args[0].(context.Context)
150 }
151 var arg1 *domain.ContainerConfig
152 if args[1] != nil {
153 arg1 = args[1].(*domain.ContainerConfig)
154 }
155 run(
156 arg0,
157 arg1,
158 )
159 })
160 return _c
161}
162
163func (_c *MockContainerRuntime_CreateContainer_Call) Return(container *domain.Container, err error) *MockContainerRuntime_CreateContainer_Call {
164 _c.Call.Return(container, err)
165 return _c
166}
167
168func (_c *MockContainerRuntime_CreateContainer_Call) RunAndReturn(run func(ctx context.Context, config *domain.ContainerConfig) (*domain.Container, error)) *MockContainerRuntime_CreateContainer_Call {
169 _c.Call.Return(run)
170 return _c
171}
172
173// CreateNetwork provides a mock function for the type MockContainerRuntime
174func (_mock *MockContainerRuntime) CreateNetwork(ctx context.Context, name string, options map[string]string) error {
175 ret := _mock.Called(ctx, name, options)
176
177 if len(ret) == 0 {
178 panic("no return value specified for CreateNetwork")
179 }
180
181 var r0 error
182 if returnFunc, ok := ret.Get(0).(func(context.Context, string, map[string]string) error); ok {
183 r0 = returnFunc(ctx, name, options)
184 } else {
185 r0 = ret.Error(0)
186 }
187 return r0
188}
189
190// MockContainerRuntime_CreateNetwork_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateNetwork'
191type MockContainerRuntime_CreateNetwork_Call struct {
192 *mock.Call
193}
194
195// CreateNetwork is a helper method to define mock.On call
196// - ctx context.Context
197// - name string
198// - options map[string]string
199func (_e *MockContainerRuntime_Expecter) CreateNetwork(ctx interface{}, name interface{}, options interface{}) *MockContainerRuntime_CreateNetwork_Call {
200 return &MockContainerRuntime_CreateNetwork_Call{Call: _e.mock.On("CreateNetwork", ctx, name, options)}
201}
202
203func (_c *MockContainerRuntime_CreateNetwork_Call) Run(run func(ctx context.Context, name string, options map[string]string)) *MockContainerRuntime_CreateNetwork_Call {
204 _c.Call.Run(func(args mock.Arguments) {
205 var arg0 context.Context
206 if args[0] != nil {
207 arg0 = args[0].(context.Context)
208 }
209 var arg1 string
210 if args[1] != nil {
211 arg1 = args[1].(string)
212 }
213 var arg2 map[string]string
214 if args[2] != nil {
215 arg2 = args[2].(map[string]string)
216 }
217 run(
218 arg0,
219 arg1,
220 arg2,
221 )
222 })
223 return _c
224}
225
226func (_c *MockContainerRuntime_CreateNetwork_Call) Return(err error) *MockContainerRuntime_CreateNetwork_Call {
227 _c.Call.Return(err)
228 return _c
229}
230
231func (_c *MockContainerRuntime_CreateNetwork_Call) RunAndReturn(run func(ctx context.Context, name string, options map[string]string) error) *MockContainerRuntime_CreateNetwork_Call {
232 _c.Call.Return(run)
233 return _c
234}
235
236// CreateVolume provides a mock function for the type MockContainerRuntime
237func (_mock *MockContainerRuntime) CreateVolume(ctx context.Context, volumeName string) error {
238 ret := _mock.Called(ctx, volumeName)
239
240 if len(ret) == 0 {
241 panic("no return value specified for CreateVolume")
242 }
243
244 var r0 error
245 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
246 r0 = returnFunc(ctx, volumeName)
247 } else {
248 r0 = ret.Error(0)
249 }
250 return r0
251}
252
253// MockContainerRuntime_CreateVolume_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateVolume'
254type MockContainerRuntime_CreateVolume_Call struct {
255 *mock.Call
256}
257
258// CreateVolume is a helper method to define mock.On call
259// - ctx context.Context
260// - volumeName string
261func (_e *MockContainerRuntime_Expecter) CreateVolume(ctx interface{}, volumeName interface{}) *MockContainerRuntime_CreateVolume_Call {
262 return &MockContainerRuntime_CreateVolume_Call{Call: _e.mock.On("CreateVolume", ctx, volumeName)}
263}
264
265func (_c *MockContainerRuntime_CreateVolume_Call) Run(run func(ctx context.Context, volumeName string)) *MockContainerRuntime_CreateVolume_Call {
266 _c.Call.Run(func(args mock.Arguments) {
267 var arg0 context.Context
268 if args[0] != nil {
269 arg0 = args[0].(context.Context)
270 }
271 var arg1 string
272 if args[1] != nil {
273 arg1 = args[1].(string)
274 }
275 run(
276 arg0,
277 arg1,
278 )
279 })
280 return _c
281}
282
283func (_c *MockContainerRuntime_CreateVolume_Call) Return(err error) *MockContainerRuntime_CreateVolume_Call {
284 _c.Call.Return(err)
285 return _c
286}
287
288func (_c *MockContainerRuntime_CreateVolume_Call) RunAndReturn(run func(ctx context.Context, volumeName string) error) *MockContainerRuntime_CreateVolume_Call {
289 _c.Call.Return(run)
290 return _c
291}
292
293// DisconnectContainerFromNetwork provides a mock function for the type MockContainerRuntime
294func (_mock *MockContainerRuntime) DisconnectContainerFromNetwork(ctx context.Context, containerName string, networkName string) error {
295 ret := _mock.Called(ctx, containerName, networkName)
296
297 if len(ret) == 0 {
298 panic("no return value specified for DisconnectContainerFromNetwork")
299 }
300
301 var r0 error
302 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
303 r0 = returnFunc(ctx, containerName, networkName)
304 } else {
305 r0 = ret.Error(0)
306 }
307 return r0
308}
309
310// MockContainerRuntime_DisconnectContainerFromNetwork_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisconnectContainerFromNetwork'
311type MockContainerRuntime_DisconnectContainerFromNetwork_Call struct {
312 *mock.Call
313}
314
315// DisconnectContainerFromNetwork is a helper method to define mock.On call
316// - ctx context.Context
317// - containerName string
318// - networkName string
319func (_e *MockContainerRuntime_Expecter) DisconnectContainerFromNetwork(ctx interface{}, containerName interface{}, networkName interface{}) *MockContainerRuntime_DisconnectContainerFromNetwork_Call {
320 return &MockContainerRuntime_DisconnectContainerFromNetwork_Call{Call: _e.mock.On("DisconnectContainerFromNetwork", ctx, containerName, networkName)}
321}
322
323func (_c *MockContainerRuntime_DisconnectContainerFromNetwork_Call) Run(run func(ctx context.Context, containerName string, networkName string)) *MockContainerRuntime_DisconnectContainerFromNetwork_Call {
324 _c.Call.Run(func(args mock.Arguments) {
325 var arg0 context.Context
326 if args[0] != nil {
327 arg0 = args[0].(context.Context)
328 }
329 var arg1 string
330 if args[1] != nil {
331 arg1 = args[1].(string)
332 }
333 var arg2 string
334 if args[2] != nil {
335 arg2 = args[2].(string)
336 }
337 run(
338 arg0,
339 arg1,
340 arg2,
341 )
342 })
343 return _c
344}
345
346func (_c *MockContainerRuntime_DisconnectContainerFromNetwork_Call) Return(err error) *MockContainerRuntime_DisconnectContainerFromNetwork_Call {
347 _c.Call.Return(err)
348 return _c
349}
350
351func (_c *MockContainerRuntime_DisconnectContainerFromNetwork_Call) RunAndReturn(run func(ctx context.Context, containerName string, networkName string) error) *MockContainerRuntime_DisconnectContainerFromNetwork_Call {
352 _c.Call.Return(run)
353 return _c
354}
355
356// GetContainerExposedPorts provides a mock function for the type MockContainerRuntime
357func (_mock *MockContainerRuntime) GetContainerExposedPorts(ctx context.Context, containerID string) ([]int, error) {
358 ret := _mock.Called(ctx, containerID)
359
360 if len(ret) == 0 {
361 panic("no return value specified for GetContainerExposedPorts")
362 }
363
364 var r0 []int
365 var r1 error
366 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]int, error)); ok {
367 return returnFunc(ctx, containerID)
368 }
369 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []int); ok {
370 r0 = returnFunc(ctx, containerID)
371 } else {
372 if ret.Get(0) != nil {
373 r0 = ret.Get(0).([]int)
374 }
375 }
376 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
377 r1 = returnFunc(ctx, containerID)
378 } else {
379 r1 = ret.Error(1)
380 }
381 return r0, r1
382}
383
384// MockContainerRuntime_GetContainerExposedPorts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetContainerExposedPorts'
385type MockContainerRuntime_GetContainerExposedPorts_Call struct {
386 *mock.Call
387}
388
389// GetContainerExposedPorts is a helper method to define mock.On call
390// - ctx context.Context
391// - containerID string
392func (_e *MockContainerRuntime_Expecter) GetContainerExposedPorts(ctx interface{}, containerID interface{}) *MockContainerRuntime_GetContainerExposedPorts_Call {
393 return &MockContainerRuntime_GetContainerExposedPorts_Call{Call: _e.mock.On("GetContainerExposedPorts", ctx, containerID)}
394}
395
396func (_c *MockContainerRuntime_GetContainerExposedPorts_Call) Run(run func(ctx context.Context, containerID string)) *MockContainerRuntime_GetContainerExposedPorts_Call {
397 _c.Call.Run(func(args mock.Arguments) {
398 var arg0 context.Context
399 if args[0] != nil {
400 arg0 = args[0].(context.Context)
401 }
402 var arg1 string
403 if args[1] != nil {
404 arg1 = args[1].(string)
405 }
406 run(
407 arg0,
408 arg1,
409 )
410 })
411 return _c
412}
413
414func (_c *MockContainerRuntime_GetContainerExposedPorts_Call) Return(ints []int, err error) *MockContainerRuntime_GetContainerExposedPorts_Call {
415 _c.Call.Return(ints, err)
416 return _c
417}
418
419func (_c *MockContainerRuntime_GetContainerExposedPorts_Call) RunAndReturn(run func(ctx context.Context, containerID string) ([]int, error)) *MockContainerRuntime_GetContainerExposedPorts_Call {
420 _c.Call.Return(run)
421 return _c
422}
423
424// GetContainerLogs provides a mock function for the type MockContainerRuntime
425func (_mock *MockContainerRuntime) GetContainerLogs(ctx context.Context, containerID string, follow bool) (io.ReadCloser, error) {
426 ret := _mock.Called(ctx, containerID, follow)
427
428 if len(ret) == 0 {
429 panic("no return value specified for GetContainerLogs")
430 }
431
432 var r0 io.ReadCloser
433 var r1 error
434 if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) (io.ReadCloser, error)); ok {
435 return returnFunc(ctx, containerID, follow)
436 }
437 if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) io.ReadCloser); ok {
438 r0 = returnFunc(ctx, containerID, follow)
439 } else {
440 if ret.Get(0) != nil {
441 r0 = ret.Get(0).(io.ReadCloser)
442 }
443 }
444 if returnFunc, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
445 r1 = returnFunc(ctx, containerID, follow)
446 } else {
447 r1 = ret.Error(1)
448 }
449 return r0, r1
450}
451
452// MockContainerRuntime_GetContainerLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetContainerLogs'
453type MockContainerRuntime_GetContainerLogs_Call struct {
454 *mock.Call
455}
456
457// GetContainerLogs is a helper method to define mock.On call
458// - ctx context.Context
459// - containerID string
460// - follow bool
461func (_e *MockContainerRuntime_Expecter) GetContainerLogs(ctx interface{}, containerID interface{}, follow interface{}) *MockContainerRuntime_GetContainerLogs_Call {
462 return &MockContainerRuntime_GetContainerLogs_Call{Call: _e.mock.On("GetContainerLogs", ctx, containerID, follow)}
463}
464
465func (_c *MockContainerRuntime_GetContainerLogs_Call) Run(run func(ctx context.Context, containerID string, follow bool)) *MockContainerRuntime_GetContainerLogs_Call {
466 _c.Call.Run(func(args mock.Arguments) {
467 var arg0 context.Context
468 if args[0] != nil {
469 arg0 = args[0].(context.Context)
470 }
471 var arg1 string
472 if args[1] != nil {
473 arg1 = args[1].(string)
474 }
475 var arg2 bool
476 if args[2] != nil {
477 arg2 = args[2].(bool)
478 }
479 run(
480 arg0,
481 arg1,
482 arg2,
483 )
484 })
485 return _c
486}
487
488func (_c *MockContainerRuntime_GetContainerLogs_Call) Return(readCloser io.ReadCloser, err error) *MockContainerRuntime_GetContainerLogs_Call {
489 _c.Call.Return(readCloser, err)
490 return _c
491}
492
493func (_c *MockContainerRuntime_GetContainerLogs_Call) RunAndReturn(run func(ctx context.Context, containerID string, follow bool) (io.ReadCloser, error)) *MockContainerRuntime_GetContainerLogs_Call {
494 _c.Call.Return(run)
495 return _c
496}
497
498// GetContainerNetworkInfo provides a mock function for the type MockContainerRuntime
499func (_mock *MockContainerRuntime) GetContainerNetworkInfo(ctx context.Context, containerID string) (string, int, error) {
500 ret := _mock.Called(ctx, containerID)
501
502 if len(ret) == 0 {
503 panic("no return value specified for GetContainerNetworkInfo")
504 }
505
506 var r0 string
507 var r1 int
508 var r2 error
509 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (string, int, error)); ok {
510 return returnFunc(ctx, containerID)
511 }
512 if returnFunc, ok := ret.Get(0).(func(context.Context, string) string); ok {
513 r0 = returnFunc(ctx, containerID)
514 } else {
515 r0 = ret.Get(0).(string)
516 }
517 if returnFunc, ok := ret.Get(1).(func(context.Context, string) int); ok {
518 r1 = returnFunc(ctx, containerID)
519 } else {
520 r1 = ret.Get(1).(int)
521 }
522 if returnFunc, ok := ret.Get(2).(func(context.Context, string) error); ok {
523 r2 = returnFunc(ctx, containerID)
524 } else {
525 r2 = ret.Error(2)
526 }
527 return r0, r1, r2
528}
529
530// MockContainerRuntime_GetContainerNetworkInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetContainerNetworkInfo'
531type MockContainerRuntime_GetContainerNetworkInfo_Call struct {
532 *mock.Call
533}
534
535// GetContainerNetworkInfo is a helper method to define mock.On call
536// - ctx context.Context
537// - containerID string
538func (_e *MockContainerRuntime_Expecter) GetContainerNetworkInfo(ctx interface{}, containerID interface{}) *MockContainerRuntime_GetContainerNetworkInfo_Call {
539 return &MockContainerRuntime_GetContainerNetworkInfo_Call{Call: _e.mock.On("GetContainerNetworkInfo", ctx, containerID)}
540}
541
542func (_c *MockContainerRuntime_GetContainerNetworkInfo_Call) Run(run func(ctx context.Context, containerID string)) *MockContainerRuntime_GetContainerNetworkInfo_Call {
543 _c.Call.Run(func(args mock.Arguments) {
544 var arg0 context.Context
545 if args[0] != nil {
546 arg0 = args[0].(context.Context)
547 }
548 var arg1 string
549 if args[1] != nil {
550 arg1 = args[1].(string)
551 }
552 run(
553 arg0,
554 arg1,
555 )
556 })
557 return _c
558}
559
560func (_c *MockContainerRuntime_GetContainerNetworkInfo_Call) Return(s string, n int, err error) *MockContainerRuntime_GetContainerNetworkInfo_Call {
561 _c.Call.Return(s, n, err)
562 return _c
563}
564
565func (_c *MockContainerRuntime_GetContainerNetworkInfo_Call) RunAndReturn(run func(ctx context.Context, containerID string) (string, int, error)) *MockContainerRuntime_GetContainerNetworkInfo_Call {
566 _c.Call.Return(run)
567 return _c
568}
569
570// GetContainerPort provides a mock function for the type MockContainerRuntime
571func (_mock *MockContainerRuntime) GetContainerPort(ctx context.Context, containerID string, internalPort int) (int, error) {
572 ret := _mock.Called(ctx, containerID, internalPort)
573
574 if len(ret) == 0 {
575 panic("no return value specified for GetContainerPort")
576 }
577
578 var r0 int
579 var r1 error
580 if returnFunc, ok := ret.Get(0).(func(context.Context, string, int) (int, error)); ok {
581 return returnFunc(ctx, containerID, internalPort)
582 }
583 if returnFunc, ok := ret.Get(0).(func(context.Context, string, int) int); ok {
584 r0 = returnFunc(ctx, containerID, internalPort)
585 } else {
586 r0 = ret.Get(0).(int)
587 }
588 if returnFunc, ok := ret.Get(1).(func(context.Context, string, int) error); ok {
589 r1 = returnFunc(ctx, containerID, internalPort)
590 } else {
591 r1 = ret.Error(1)
592 }
593 return r0, r1
594}
595
596// MockContainerRuntime_GetContainerPort_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetContainerPort'
597type MockContainerRuntime_GetContainerPort_Call struct {
598 *mock.Call
599}
600
601// GetContainerPort is a helper method to define mock.On call
602// - ctx context.Context
603// - containerID string
604// - internalPort int
605func (_e *MockContainerRuntime_Expecter) GetContainerPort(ctx interface{}, containerID interface{}, internalPort interface{}) *MockContainerRuntime_GetContainerPort_Call {
606 return &MockContainerRuntime_GetContainerPort_Call{Call: _e.mock.On("GetContainerPort", ctx, containerID, internalPort)}
607}
608
609func (_c *MockContainerRuntime_GetContainerPort_Call) Run(run func(ctx context.Context, containerID string, internalPort int)) *MockContainerRuntime_GetContainerPort_Call {
610 _c.Call.Run(func(args mock.Arguments) {
611 var arg0 context.Context
612 if args[0] != nil {
613 arg0 = args[0].(context.Context)
614 }
615 var arg1 string
616 if args[1] != nil {
617 arg1 = args[1].(string)
618 }
619 var arg2 int
620 if args[2] != nil {
621 arg2 = args[2].(int)
622 }
623 run(
624 arg0,
625 arg1,
626 arg2,
627 )
628 })
629 return _c
630}
631
632func (_c *MockContainerRuntime_GetContainerPort_Call) Return(n int, err error) *MockContainerRuntime_GetContainerPort_Call {
633 _c.Call.Return(n, err)
634 return _c
635}
636
637func (_c *MockContainerRuntime_GetContainerPort_Call) RunAndReturn(run func(ctx context.Context, containerID string, internalPort int) (int, error)) *MockContainerRuntime_GetContainerPort_Call {
638 _c.Call.Return(run)
639 return _c
640}
641
642// GetImageExposedPorts provides a mock function for the type MockContainerRuntime
643func (_mock *MockContainerRuntime) GetImageExposedPorts(ctx context.Context, imageRef string) ([]int, error) {
644 ret := _mock.Called(ctx, imageRef)
645
646 if len(ret) == 0 {
647 panic("no return value specified for GetImageExposedPorts")
648 }
649
650 var r0 []int
651 var r1 error
652 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]int, error)); ok {
653 return returnFunc(ctx, imageRef)
654 }
655 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []int); ok {
656 r0 = returnFunc(ctx, imageRef)
657 } else {
658 if ret.Get(0) != nil {
659 r0 = ret.Get(0).([]int)
660 }
661 }
662 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
663 r1 = returnFunc(ctx, imageRef)
664 } else {
665 r1 = ret.Error(1)
666 }
667 return r0, r1
668}
669
670// MockContainerRuntime_GetImageExposedPorts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetImageExposedPorts'
671type MockContainerRuntime_GetImageExposedPorts_Call struct {
672 *mock.Call
673}
674
675// GetImageExposedPorts is a helper method to define mock.On call
676// - ctx context.Context
677// - imageRef string
678func (_e *MockContainerRuntime_Expecter) GetImageExposedPorts(ctx interface{}, imageRef interface{}) *MockContainerRuntime_GetImageExposedPorts_Call {
679 return &MockContainerRuntime_GetImageExposedPorts_Call{Call: _e.mock.On("GetImageExposedPorts", ctx, imageRef)}
680}
681
682func (_c *MockContainerRuntime_GetImageExposedPorts_Call) Run(run func(ctx context.Context, imageRef string)) *MockContainerRuntime_GetImageExposedPorts_Call {
683 _c.Call.Run(func(args mock.Arguments) {
684 var arg0 context.Context
685 if args[0] != nil {
686 arg0 = args[0].(context.Context)
687 }
688 var arg1 string
689 if args[1] != nil {
690 arg1 = args[1].(string)
691 }
692 run(
693 arg0,
694 arg1,
695 )
696 })
697 return _c
698}
699
700func (_c *MockContainerRuntime_GetImageExposedPorts_Call) Return(ints []int, err error) *MockContainerRuntime_GetImageExposedPorts_Call {
701 _c.Call.Return(ints, err)
702 return _c
703}
704
705func (_c *MockContainerRuntime_GetImageExposedPorts_Call) RunAndReturn(run func(ctx context.Context, imageRef string) ([]int, error)) *MockContainerRuntime_GetImageExposedPorts_Call {
706 _c.Call.Return(run)
707 return _c
708}
709
710// GetImageLabels provides a mock function for the type MockContainerRuntime
711func (_mock *MockContainerRuntime) GetImageLabels(ctx context.Context, imageRef string) (map[string]string, error) {
712 ret := _mock.Called(ctx, imageRef)
713
714 if len(ret) == 0 {
715 panic("no return value specified for GetImageLabels")
716 }
717
718 var r0 map[string]string
719 var r1 error
720 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (map[string]string, error)); ok {
721 return returnFunc(ctx, imageRef)
722 }
723 if returnFunc, ok := ret.Get(0).(func(context.Context, string) map[string]string); ok {
724 r0 = returnFunc(ctx, imageRef)
725 } else {
726 if ret.Get(0) != nil {
727 r0 = ret.Get(0).(map[string]string)
728 }
729 }
730 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
731 r1 = returnFunc(ctx, imageRef)
732 } else {
733 r1 = ret.Error(1)
734 }
735 return r0, r1
736}
737
738// MockContainerRuntime_GetImageLabels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetImageLabels'
739type MockContainerRuntime_GetImageLabels_Call struct {
740 *mock.Call
741}
742
743// GetImageLabels is a helper method to define mock.On call
744// - ctx context.Context
745// - imageRef string
746func (_e *MockContainerRuntime_Expecter) GetImageLabels(ctx interface{}, imageRef interface{}) *MockContainerRuntime_GetImageLabels_Call {
747 return &MockContainerRuntime_GetImageLabels_Call{Call: _e.mock.On("GetImageLabels", ctx, imageRef)}
748}
749
750func (_c *MockContainerRuntime_GetImageLabels_Call) Run(run func(ctx context.Context, imageRef string)) *MockContainerRuntime_GetImageLabels_Call {
751 _c.Call.Run(func(args mock.Arguments) {
752 var arg0 context.Context
753 if args[0] != nil {
754 arg0 = args[0].(context.Context)
755 }
756 var arg1 string
757 if args[1] != nil {
758 arg1 = args[1].(string)
759 }
760 run(
761 arg0,
762 arg1,
763 )
764 })
765 return _c
766}
767
768func (_c *MockContainerRuntime_GetImageLabels_Call) Return(stringToString map[string]string, err error) *MockContainerRuntime_GetImageLabels_Call {
769 _c.Call.Return(stringToString, err)
770 return _c
771}
772
773func (_c *MockContainerRuntime_GetImageLabels_Call) RunAndReturn(run func(ctx context.Context, imageRef string) (map[string]string, error)) *MockContainerRuntime_GetImageLabels_Call {
774 _c.Call.Return(run)
775 return _c
776}
777
778// InspectContainer provides a mock function for the type MockContainerRuntime
779func (_mock *MockContainerRuntime) InspectContainer(ctx context.Context, containerID string) (*domain.Container, error) {
780 ret := _mock.Called(ctx, containerID)
781
782 if len(ret) == 0 {
783 panic("no return value specified for InspectContainer")
784 }
785
786 var r0 *domain.Container
787 var r1 error
788 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*domain.Container, error)); ok {
789 return returnFunc(ctx, containerID)
790 }
791 if returnFunc, ok := ret.Get(0).(func(context.Context, string) *domain.Container); ok {
792 r0 = returnFunc(ctx, containerID)
793 } else {
794 if ret.Get(0) != nil {
795 r0 = ret.Get(0).(*domain.Container)
796 }
797 }
798 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
799 r1 = returnFunc(ctx, containerID)
800 } else {
801 r1 = ret.Error(1)
802 }
803 return r0, r1
804}
805
806// MockContainerRuntime_InspectContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InspectContainer'
807type MockContainerRuntime_InspectContainer_Call struct {
808 *mock.Call
809}
810
811// InspectContainer is a helper method to define mock.On call
812// - ctx context.Context
813// - containerID string
814func (_e *MockContainerRuntime_Expecter) InspectContainer(ctx interface{}, containerID interface{}) *MockContainerRuntime_InspectContainer_Call {
815 return &MockContainerRuntime_InspectContainer_Call{Call: _e.mock.On("InspectContainer", ctx, containerID)}
816}
817
818func (_c *MockContainerRuntime_InspectContainer_Call) Run(run func(ctx context.Context, containerID string)) *MockContainerRuntime_InspectContainer_Call {
819 _c.Call.Run(func(args mock.Arguments) {
820 var arg0 context.Context
821 if args[0] != nil {
822 arg0 = args[0].(context.Context)
823 }
824 var arg1 string
825 if args[1] != nil {
826 arg1 = args[1].(string)
827 }
828 run(
829 arg0,
830 arg1,
831 )
832 })
833 return _c
834}
835
836func (_c *MockContainerRuntime_InspectContainer_Call) Return(container *domain.Container, err error) *MockContainerRuntime_InspectContainer_Call {
837 _c.Call.Return(container, err)
838 return _c
839}
840
841func (_c *MockContainerRuntime_InspectContainer_Call) RunAndReturn(run func(ctx context.Context, containerID string) (*domain.Container, error)) *MockContainerRuntime_InspectContainer_Call {
842 _c.Call.Return(run)
843 return _c
844}
845
846// InspectImageEnv provides a mock function for the type MockContainerRuntime
847func (_mock *MockContainerRuntime) InspectImageEnv(ctx context.Context, imageRef string) ([]string, error) {
848 ret := _mock.Called(ctx, imageRef)
849
850 if len(ret) == 0 {
851 panic("no return value specified for InspectImageEnv")
852 }
853
854 var r0 []string
855 var r1 error
856 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]string, error)); ok {
857 return returnFunc(ctx, imageRef)
858 }
859 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []string); ok {
860 r0 = returnFunc(ctx, imageRef)
861 } else {
862 if ret.Get(0) != nil {
863 r0 = ret.Get(0).([]string)
864 }
865 }
866 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
867 r1 = returnFunc(ctx, imageRef)
868 } else {
869 r1 = ret.Error(1)
870 }
871 return r0, r1
872}
873
874// MockContainerRuntime_InspectImageEnv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InspectImageEnv'
875type MockContainerRuntime_InspectImageEnv_Call struct {
876 *mock.Call
877}
878
879// InspectImageEnv is a helper method to define mock.On call
880// - ctx context.Context
881// - imageRef string
882func (_e *MockContainerRuntime_Expecter) InspectImageEnv(ctx interface{}, imageRef interface{}) *MockContainerRuntime_InspectImageEnv_Call {
883 return &MockContainerRuntime_InspectImageEnv_Call{Call: _e.mock.On("InspectImageEnv", ctx, imageRef)}
884}
885
886func (_c *MockContainerRuntime_InspectImageEnv_Call) Run(run func(ctx context.Context, imageRef string)) *MockContainerRuntime_InspectImageEnv_Call {
887 _c.Call.Run(func(args mock.Arguments) {
888 var arg0 context.Context
889 if args[0] != nil {
890 arg0 = args[0].(context.Context)
891 }
892 var arg1 string
893 if args[1] != nil {
894 arg1 = args[1].(string)
895 }
896 run(
897 arg0,
898 arg1,
899 )
900 })
901 return _c
902}
903
904func (_c *MockContainerRuntime_InspectImageEnv_Call) Return(strings []string, err error) *MockContainerRuntime_InspectImageEnv_Call {
905 _c.Call.Return(strings, err)
906 return _c
907}
908
909func (_c *MockContainerRuntime_InspectImageEnv_Call) RunAndReturn(run func(ctx context.Context, imageRef string) ([]string, error)) *MockContainerRuntime_InspectImageEnv_Call {
910 _c.Call.Return(run)
911 return _c
912}
913
914// InspectImageVolumes provides a mock function for the type MockContainerRuntime
915func (_mock *MockContainerRuntime) InspectImageVolumes(ctx context.Context, imageRef string) ([]string, error) {
916 ret := _mock.Called(ctx, imageRef)
917
918 if len(ret) == 0 {
919 panic("no return value specified for InspectImageVolumes")
920 }
921
922 var r0 []string
923 var r1 error
924 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]string, error)); ok {
925 return returnFunc(ctx, imageRef)
926 }
927 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []string); ok {
928 r0 = returnFunc(ctx, imageRef)
929 } else {
930 if ret.Get(0) != nil {
931 r0 = ret.Get(0).([]string)
932 }
933 }
934 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
935 r1 = returnFunc(ctx, imageRef)
936 } else {
937 r1 = ret.Error(1)
938 }
939 return r0, r1
940}
941
942// MockContainerRuntime_InspectImageVolumes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InspectImageVolumes'
943type MockContainerRuntime_InspectImageVolumes_Call struct {
944 *mock.Call
945}
946
947// InspectImageVolumes is a helper method to define mock.On call
948// - ctx context.Context
949// - imageRef string
950func (_e *MockContainerRuntime_Expecter) InspectImageVolumes(ctx interface{}, imageRef interface{}) *MockContainerRuntime_InspectImageVolumes_Call {
951 return &MockContainerRuntime_InspectImageVolumes_Call{Call: _e.mock.On("InspectImageVolumes", ctx, imageRef)}
952}
953
954func (_c *MockContainerRuntime_InspectImageVolumes_Call) Run(run func(ctx context.Context, imageRef string)) *MockContainerRuntime_InspectImageVolumes_Call {
955 _c.Call.Run(func(args mock.Arguments) {
956 var arg0 context.Context
957 if args[0] != nil {
958 arg0 = args[0].(context.Context)
959 }
960 var arg1 string
961 if args[1] != nil {
962 arg1 = args[1].(string)
963 }
964 run(
965 arg0,
966 arg1,
967 )
968 })
969 return _c
970}
971
972func (_c *MockContainerRuntime_InspectImageVolumes_Call) Return(strings []string, err error) *MockContainerRuntime_InspectImageVolumes_Call {
973 _c.Call.Return(strings, err)
974 return _c
975}
976
977func (_c *MockContainerRuntime_InspectImageVolumes_Call) RunAndReturn(run func(ctx context.Context, imageRef string) ([]string, error)) *MockContainerRuntime_InspectImageVolumes_Call {
978 _c.Call.Return(run)
979 return _c
980}
981
982// IsContainerRunning provides a mock function for the type MockContainerRuntime
983func (_mock *MockContainerRuntime) IsContainerRunning(ctx context.Context, containerID string) (bool, error) {
984 ret := _mock.Called(ctx, containerID)
985
986 if len(ret) == 0 {
987 panic("no return value specified for IsContainerRunning")
988 }
989
990 var r0 bool
991 var r1 error
992 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (bool, error)); ok {
993 return returnFunc(ctx, containerID)
994 }
995 if returnFunc, ok := ret.Get(0).(func(context.Context, string) bool); ok {
996 r0 = returnFunc(ctx, containerID)
997 } else {
998 r0 = ret.Get(0).(bool)
999 }
1000 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
1001 r1 = returnFunc(ctx, containerID)
1002 } else {
1003 r1 = ret.Error(1)
1004 }
1005 return r0, r1
1006}
1007
1008// MockContainerRuntime_IsContainerRunning_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsContainerRunning'
1009type MockContainerRuntime_IsContainerRunning_Call struct {
1010 *mock.Call
1011}
1012
1013// IsContainerRunning is a helper method to define mock.On call
1014// - ctx context.Context
1015// - containerID string
1016func (_e *MockContainerRuntime_Expecter) IsContainerRunning(ctx interface{}, containerID interface{}) *MockContainerRuntime_IsContainerRunning_Call {
1017 return &MockContainerRuntime_IsContainerRunning_Call{Call: _e.mock.On("IsContainerRunning", ctx, containerID)}
1018}
1019
1020func (_c *MockContainerRuntime_IsContainerRunning_Call) Run(run func(ctx context.Context, containerID string)) *MockContainerRuntime_IsContainerRunning_Call {
1021 _c.Call.Run(func(args mock.Arguments) {
1022 var arg0 context.Context
1023 if args[0] != nil {
1024 arg0 = args[0].(context.Context)
1025 }
1026 var arg1 string
1027 if args[1] != nil {
1028 arg1 = args[1].(string)
1029 }
1030 run(
1031 arg0,
1032 arg1,
1033 )
1034 })
1035 return _c
1036}
1037
1038func (_c *MockContainerRuntime_IsContainerRunning_Call) Return(b bool, err error) *MockContainerRuntime_IsContainerRunning_Call {
1039 _c.Call.Return(b, err)
1040 return _c
1041}
1042
1043func (_c *MockContainerRuntime_IsContainerRunning_Call) RunAndReturn(run func(ctx context.Context, containerID string) (bool, error)) *MockContainerRuntime_IsContainerRunning_Call {
1044 _c.Call.Return(run)
1045 return _c
1046}
1047
1048// ListContainers provides a mock function for the type MockContainerRuntime
1049func (_mock *MockContainerRuntime) ListContainers(ctx context.Context, all bool) ([]*domain.Container, error) {
1050 ret := _mock.Called(ctx, all)
1051
1052 if len(ret) == 0 {
1053 panic("no return value specified for ListContainers")
1054 }
1055
1056 var r0 []*domain.Container
1057 var r1 error
1058 if returnFunc, ok := ret.Get(0).(func(context.Context, bool) ([]*domain.Container, error)); ok {
1059 return returnFunc(ctx, all)
1060 }
1061 if returnFunc, ok := ret.Get(0).(func(context.Context, bool) []*domain.Container); ok {
1062 r0 = returnFunc(ctx, all)
1063 } else {
1064 if ret.Get(0) != nil {
1065 r0 = ret.Get(0).([]*domain.Container)
1066 }
1067 }
1068 if returnFunc, ok := ret.Get(1).(func(context.Context, bool) error); ok {
1069 r1 = returnFunc(ctx, all)
1070 } else {
1071 r1 = ret.Error(1)
1072 }
1073 return r0, r1
1074}
1075
1076// MockContainerRuntime_ListContainers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListContainers'
1077type MockContainerRuntime_ListContainers_Call struct {
1078 *mock.Call
1079}
1080
1081// ListContainers is a helper method to define mock.On call
1082// - ctx context.Context
1083// - all bool
1084func (_e *MockContainerRuntime_Expecter) ListContainers(ctx interface{}, all interface{}) *MockContainerRuntime_ListContainers_Call {
1085 return &MockContainerRuntime_ListContainers_Call{Call: _e.mock.On("ListContainers", ctx, all)}
1086}
1087
1088func (_c *MockContainerRuntime_ListContainers_Call) Run(run func(ctx context.Context, all bool)) *MockContainerRuntime_ListContainers_Call {
1089 _c.Call.Run(func(args mock.Arguments) {
1090 var arg0 context.Context
1091 if args[0] != nil {
1092 arg0 = args[0].(context.Context)
1093 }
1094 var arg1 bool
1095 if args[1] != nil {
1096 arg1 = args[1].(bool)
1097 }
1098 run(
1099 arg0,
1100 arg1,
1101 )
1102 })
1103 return _c
1104}
1105
1106func (_c *MockContainerRuntime_ListContainers_Call) Return(containers []*domain.Container, err error) *MockContainerRuntime_ListContainers_Call {
1107 _c.Call.Return(containers, err)
1108 return _c
1109}
1110
1111func (_c *MockContainerRuntime_ListContainers_Call) RunAndReturn(run func(ctx context.Context, all bool) ([]*domain.Container, error)) *MockContainerRuntime_ListContainers_Call {
1112 _c.Call.Return(run)
1113 return _c
1114}
1115
1116// ListImages provides a mock function for the type MockContainerRuntime
1117func (_mock *MockContainerRuntime) ListImages(ctx context.Context) ([]string, error) {
1118 ret := _mock.Called(ctx)
1119
1120 if len(ret) == 0 {
1121 panic("no return value specified for ListImages")
1122 }
1123
1124 var r0 []string
1125 var r1 error
1126 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]string, error)); ok {
1127 return returnFunc(ctx)
1128 }
1129 if returnFunc, ok := ret.Get(0).(func(context.Context) []string); ok {
1130 r0 = returnFunc(ctx)
1131 } else {
1132 if ret.Get(0) != nil {
1133 r0 = ret.Get(0).([]string)
1134 }
1135 }
1136 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1137 r1 = returnFunc(ctx)
1138 } else {
1139 r1 = ret.Error(1)
1140 }
1141 return r0, r1
1142}
1143
1144// MockContainerRuntime_ListImages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListImages'
1145type MockContainerRuntime_ListImages_Call struct {
1146 *mock.Call
1147}
1148
1149// ListImages is a helper method to define mock.On call
1150// - ctx context.Context
1151func (_e *MockContainerRuntime_Expecter) ListImages(ctx interface{}) *MockContainerRuntime_ListImages_Call {
1152 return &MockContainerRuntime_ListImages_Call{Call: _e.mock.On("ListImages", ctx)}
1153}
1154
1155func (_c *MockContainerRuntime_ListImages_Call) Run(run func(ctx context.Context)) *MockContainerRuntime_ListImages_Call {
1156 _c.Call.Run(func(args mock.Arguments) {
1157 var arg0 context.Context
1158 if args[0] != nil {
1159 arg0 = args[0].(context.Context)
1160 }
1161 run(
1162 arg0,
1163 )
1164 })
1165 return _c
1166}
1167
1168func (_c *MockContainerRuntime_ListImages_Call) Return(strings []string, err error) *MockContainerRuntime_ListImages_Call {
1169 _c.Call.Return(strings, err)
1170 return _c
1171}
1172
1173func (_c *MockContainerRuntime_ListImages_Call) RunAndReturn(run func(ctx context.Context) ([]string, error)) *MockContainerRuntime_ListImages_Call {
1174 _c.Call.Return(run)
1175 return _c
1176}
1177
1178// ListNetworks provides a mock function for the type MockContainerRuntime
1179func (_mock *MockContainerRuntime) ListNetworks(ctx context.Context) ([]*domain.NetworkInfo, error) {
1180 ret := _mock.Called(ctx)
1181
1182 if len(ret) == 0 {
1183 panic("no return value specified for ListNetworks")
1184 }
1185
1186 var r0 []*domain.NetworkInfo
1187 var r1 error
1188 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*domain.NetworkInfo, error)); ok {
1189 return returnFunc(ctx)
1190 }
1191 if returnFunc, ok := ret.Get(0).(func(context.Context) []*domain.NetworkInfo); ok {
1192 r0 = returnFunc(ctx)
1193 } else {
1194 if ret.Get(0) != nil {
1195 r0 = ret.Get(0).([]*domain.NetworkInfo)
1196 }
1197 }
1198 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1199 r1 = returnFunc(ctx)
1200 } else {
1201 r1 = ret.Error(1)
1202 }
1203 return r0, r1
1204}
1205
1206// MockContainerRuntime_ListNetworks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListNetworks'
1207type MockContainerRuntime_ListNetworks_Call struct {
1208 *mock.Call
1209}
1210
1211// ListNetworks is a helper method to define mock.On call
1212// - ctx context.Context
1213func (_e *MockContainerRuntime_Expecter) ListNetworks(ctx interface{}) *MockContainerRuntime_ListNetworks_Call {
1214 return &MockContainerRuntime_ListNetworks_Call{Call: _e.mock.On("ListNetworks", ctx)}
1215}
1216
1217func (_c *MockContainerRuntime_ListNetworks_Call) Run(run func(ctx context.Context)) *MockContainerRuntime_ListNetworks_Call {
1218 _c.Call.Run(func(args mock.Arguments) {
1219 var arg0 context.Context
1220 if args[0] != nil {
1221 arg0 = args[0].(context.Context)
1222 }
1223 run(
1224 arg0,
1225 )
1226 })
1227 return _c
1228}
1229
1230func (_c *MockContainerRuntime_ListNetworks_Call) Return(networkInfos []*domain.NetworkInfo, err error) *MockContainerRuntime_ListNetworks_Call {
1231 _c.Call.Return(networkInfos, err)
1232 return _c
1233}
1234
1235func (_c *MockContainerRuntime_ListNetworks_Call) RunAndReturn(run func(ctx context.Context) ([]*domain.NetworkInfo, error)) *MockContainerRuntime_ListNetworks_Call {
1236 _c.Call.Return(run)
1237 return _c
1238}
1239
1240// NetworkExists provides a mock function for the type MockContainerRuntime
1241func (_mock *MockContainerRuntime) NetworkExists(ctx context.Context, name string) (bool, error) {
1242 ret := _mock.Called(ctx, name)
1243
1244 if len(ret) == 0 {
1245 panic("no return value specified for NetworkExists")
1246 }
1247
1248 var r0 bool
1249 var r1 error
1250 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (bool, error)); ok {
1251 return returnFunc(ctx, name)
1252 }
1253 if returnFunc, ok := ret.Get(0).(func(context.Context, string) bool); ok {
1254 r0 = returnFunc(ctx, name)
1255 } else {
1256 r0 = ret.Get(0).(bool)
1257 }
1258 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
1259 r1 = returnFunc(ctx, name)
1260 } else {
1261 r1 = ret.Error(1)
1262 }
1263 return r0, r1
1264}
1265
1266// MockContainerRuntime_NetworkExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NetworkExists'
1267type MockContainerRuntime_NetworkExists_Call struct {
1268 *mock.Call
1269}
1270
1271// NetworkExists is a helper method to define mock.On call
1272// - ctx context.Context
1273// - name string
1274func (_e *MockContainerRuntime_Expecter) NetworkExists(ctx interface{}, name interface{}) *MockContainerRuntime_NetworkExists_Call {
1275 return &MockContainerRuntime_NetworkExists_Call{Call: _e.mock.On("NetworkExists", ctx, name)}
1276}
1277
1278func (_c *MockContainerRuntime_NetworkExists_Call) Run(run func(ctx context.Context, name string)) *MockContainerRuntime_NetworkExists_Call {
1279 _c.Call.Run(func(args mock.Arguments) {
1280 var arg0 context.Context
1281 if args[0] != nil {
1282 arg0 = args[0].(context.Context)
1283 }
1284 var arg1 string
1285 if args[1] != nil {
1286 arg1 = args[1].(string)
1287 }
1288 run(
1289 arg0,
1290 arg1,
1291 )
1292 })
1293 return _c
1294}
1295
1296func (_c *MockContainerRuntime_NetworkExists_Call) Return(b bool, err error) *MockContainerRuntime_NetworkExists_Call {
1297 _c.Call.Return(b, err)
1298 return _c
1299}
1300
1301func (_c *MockContainerRuntime_NetworkExists_Call) RunAndReturn(run func(ctx context.Context, name string) (bool, error)) *MockContainerRuntime_NetworkExists_Call {
1302 _c.Call.Return(run)
1303 return _c
1304}
1305
1306// Ping provides a mock function for the type MockContainerRuntime
1307func (_mock *MockContainerRuntime) Ping(ctx context.Context) error {
1308 ret := _mock.Called(ctx)
1309
1310 if len(ret) == 0 {
1311 panic("no return value specified for Ping")
1312 }
1313
1314 var r0 error
1315 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1316 r0 = returnFunc(ctx)
1317 } else {
1318 r0 = ret.Error(0)
1319 }
1320 return r0
1321}
1322
1323// MockContainerRuntime_Ping_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Ping'
1324type MockContainerRuntime_Ping_Call struct {
1325 *mock.Call
1326}
1327
1328// Ping is a helper method to define mock.On call
1329// - ctx context.Context
1330func (_e *MockContainerRuntime_Expecter) Ping(ctx interface{}) *MockContainerRuntime_Ping_Call {
1331 return &MockContainerRuntime_Ping_Call{Call: _e.mock.On("Ping", ctx)}
1332}
1333
1334func (_c *MockContainerRuntime_Ping_Call) Run(run func(ctx context.Context)) *MockContainerRuntime_Ping_Call {
1335 _c.Call.Run(func(args mock.Arguments) {
1336 var arg0 context.Context
1337 if args[0] != nil {
1338 arg0 = args[0].(context.Context)
1339 }
1340 run(
1341 arg0,
1342 )
1343 })
1344 return _c
1345}
1346
1347func (_c *MockContainerRuntime_Ping_Call) Return(err error) *MockContainerRuntime_Ping_Call {
1348 _c.Call.Return(err)
1349 return _c
1350}
1351
1352func (_c *MockContainerRuntime_Ping_Call) RunAndReturn(run func(ctx context.Context) error) *MockContainerRuntime_Ping_Call {
1353 _c.Call.Return(run)
1354 return _c
1355}
1356
1357// PullImage provides a mock function for the type MockContainerRuntime
1358func (_mock *MockContainerRuntime) PullImage(ctx context.Context, image string) error {
1359 ret := _mock.Called(ctx, image)
1360
1361 if len(ret) == 0 {
1362 panic("no return value specified for PullImage")
1363 }
1364
1365 var r0 error
1366 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
1367 r0 = returnFunc(ctx, image)
1368 } else {
1369 r0 = ret.Error(0)
1370 }
1371 return r0
1372}
1373
1374// MockContainerRuntime_PullImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PullImage'
1375type MockContainerRuntime_PullImage_Call struct {
1376 *mock.Call
1377}
1378
1379// PullImage is a helper method to define mock.On call
1380// - ctx context.Context
1381// - image string
1382func (_e *MockContainerRuntime_Expecter) PullImage(ctx interface{}, image interface{}) *MockContainerRuntime_PullImage_Call {
1383 return &MockContainerRuntime_PullImage_Call{Call: _e.mock.On("PullImage", ctx, image)}
1384}
1385
1386func (_c *MockContainerRuntime_PullImage_Call) Run(run func(ctx context.Context, image string)) *MockContainerRuntime_PullImage_Call {
1387 _c.Call.Run(func(args mock.Arguments) {
1388 var arg0 context.Context
1389 if args[0] != nil {
1390 arg0 = args[0].(context.Context)
1391 }
1392 var arg1 string
1393 if args[1] != nil {
1394 arg1 = args[1].(string)
1395 }
1396 run(
1397 arg0,
1398 arg1,
1399 )
1400 })
1401 return _c
1402}
1403
1404func (_c *MockContainerRuntime_PullImage_Call) Return(err error) *MockContainerRuntime_PullImage_Call {
1405 _c.Call.Return(err)
1406 return _c
1407}
1408
1409func (_c *MockContainerRuntime_PullImage_Call) RunAndReturn(run func(ctx context.Context, image string) error) *MockContainerRuntime_PullImage_Call {
1410 _c.Call.Return(run)
1411 return _c
1412}
1413
1414// PullImageWithAuth provides a mock function for the type MockContainerRuntime
1415func (_mock *MockContainerRuntime) PullImageWithAuth(ctx context.Context, image string, username string, password string) error {
1416 ret := _mock.Called(ctx, image, username, password)
1417
1418 if len(ret) == 0 {
1419 panic("no return value specified for PullImageWithAuth")
1420 }
1421
1422 var r0 error
1423 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
1424 r0 = returnFunc(ctx, image, username, password)
1425 } else {
1426 r0 = ret.Error(0)
1427 }
1428 return r0
1429}
1430
1431// MockContainerRuntime_PullImageWithAuth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PullImageWithAuth'
1432type MockContainerRuntime_PullImageWithAuth_Call struct {
1433 *mock.Call
1434}
1435
1436// PullImageWithAuth is a helper method to define mock.On call
1437// - ctx context.Context
1438// - image string
1439// - username string
1440// - password string
1441func (_e *MockContainerRuntime_Expecter) PullImageWithAuth(ctx interface{}, image interface{}, username interface{}, password interface{}) *MockContainerRuntime_PullImageWithAuth_Call {
1442 return &MockContainerRuntime_PullImageWithAuth_Call{Call: _e.mock.On("PullImageWithAuth", ctx, image, username, password)}
1443}
1444
1445func (_c *MockContainerRuntime_PullImageWithAuth_Call) Run(run func(ctx context.Context, image string, username string, password string)) *MockContainerRuntime_PullImageWithAuth_Call {
1446 _c.Call.Run(func(args mock.Arguments) {
1447 var arg0 context.Context
1448 if args[0] != nil {
1449 arg0 = args[0].(context.Context)
1450 }
1451 var arg1 string
1452 if args[1] != nil {
1453 arg1 = args[1].(string)
1454 }
1455 var arg2 string
1456 if args[2] != nil {
1457 arg2 = args[2].(string)
1458 }
1459 var arg3 string
1460 if args[3] != nil {
1461 arg3 = args[3].(string)
1462 }
1463 run(
1464 arg0,
1465 arg1,
1466 arg2,
1467 arg3,
1468 )
1469 })
1470 return _c
1471}
1472
1473func (_c *MockContainerRuntime_PullImageWithAuth_Call) Return(err error) *MockContainerRuntime_PullImageWithAuth_Call {
1474 _c.Call.Return(err)
1475 return _c
1476}
1477
1478func (_c *MockContainerRuntime_PullImageWithAuth_Call) RunAndReturn(run func(ctx context.Context, image string, username string, password string) error) *MockContainerRuntime_PullImageWithAuth_Call {
1479 _c.Call.Return(run)
1480 return _c
1481}
1482
1483// RemoveContainer provides a mock function for the type MockContainerRuntime
1484func (_mock *MockContainerRuntime) RemoveContainer(ctx context.Context, containerID string, force bool) error {
1485 ret := _mock.Called(ctx, containerID, force)
1486
1487 if len(ret) == 0 {
1488 panic("no return value specified for RemoveContainer")
1489 }
1490
1491 var r0 error
1492 if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) error); ok {
1493 r0 = returnFunc(ctx, containerID, force)
1494 } else {
1495 r0 = ret.Error(0)
1496 }
1497 return r0
1498}
1499
1500// MockContainerRuntime_RemoveContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveContainer'
1501type MockContainerRuntime_RemoveContainer_Call struct {
1502 *mock.Call
1503}
1504
1505// RemoveContainer is a helper method to define mock.On call
1506// - ctx context.Context
1507// - containerID string
1508// - force bool
1509func (_e *MockContainerRuntime_Expecter) RemoveContainer(ctx interface{}, containerID interface{}, force interface{}) *MockContainerRuntime_RemoveContainer_Call {
1510 return &MockContainerRuntime_RemoveContainer_Call{Call: _e.mock.On("RemoveContainer", ctx, containerID, force)}
1511}
1512
1513func (_c *MockContainerRuntime_RemoveContainer_Call) Run(run func(ctx context.Context, containerID string, force bool)) *MockContainerRuntime_RemoveContainer_Call {
1514 _c.Call.Run(func(args mock.Arguments) {
1515 var arg0 context.Context
1516 if args[0] != nil {
1517 arg0 = args[0].(context.Context)
1518 }
1519 var arg1 string
1520 if args[1] != nil {
1521 arg1 = args[1].(string)
1522 }
1523 var arg2 bool
1524 if args[2] != nil {
1525 arg2 = args[2].(bool)
1526 }
1527 run(
1528 arg0,
1529 arg1,
1530 arg2,
1531 )
1532 })
1533 return _c
1534}
1535
1536func (_c *MockContainerRuntime_RemoveContainer_Call) Return(err error) *MockContainerRuntime_RemoveContainer_Call {
1537 _c.Call.Return(err)
1538 return _c
1539}
1540
1541func (_c *MockContainerRuntime_RemoveContainer_Call) RunAndReturn(run func(ctx context.Context, containerID string, force bool) error) *MockContainerRuntime_RemoveContainer_Call {
1542 _c.Call.Return(run)
1543 return _c
1544}
1545
1546// RemoveImage provides a mock function for the type MockContainerRuntime
1547func (_mock *MockContainerRuntime) RemoveImage(ctx context.Context, image string, force bool) error {
1548 ret := _mock.Called(ctx, image, force)
1549
1550 if len(ret) == 0 {
1551 panic("no return value specified for RemoveImage")
1552 }
1553
1554 var r0 error
1555 if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) error); ok {
1556 r0 = returnFunc(ctx, image, force)
1557 } else {
1558 r0 = ret.Error(0)
1559 }
1560 return r0
1561}
1562
1563// MockContainerRuntime_RemoveImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveImage'
1564type MockContainerRuntime_RemoveImage_Call struct {
1565 *mock.Call
1566}
1567
1568// RemoveImage is a helper method to define mock.On call
1569// - ctx context.Context
1570// - image string
1571// - force bool
1572func (_e *MockContainerRuntime_Expecter) RemoveImage(ctx interface{}, image interface{}, force interface{}) *MockContainerRuntime_RemoveImage_Call {
1573 return &MockContainerRuntime_RemoveImage_Call{Call: _e.mock.On("RemoveImage", ctx, image, force)}
1574}
1575
1576func (_c *MockContainerRuntime_RemoveImage_Call) Run(run func(ctx context.Context, image string, force bool)) *MockContainerRuntime_RemoveImage_Call {
1577 _c.Call.Run(func(args mock.Arguments) {
1578 var arg0 context.Context
1579 if args[0] != nil {
1580 arg0 = args[0].(context.Context)
1581 }
1582 var arg1 string
1583 if args[1] != nil {
1584 arg1 = args[1].(string)
1585 }
1586 var arg2 bool
1587 if args[2] != nil {
1588 arg2 = args[2].(bool)
1589 }
1590 run(
1591 arg0,
1592 arg1,
1593 arg2,
1594 )
1595 })
1596 return _c
1597}
1598
1599func (_c *MockContainerRuntime_RemoveImage_Call) Return(err error) *MockContainerRuntime_RemoveImage_Call {
1600 _c.Call.Return(err)
1601 return _c
1602}
1603
1604func (_c *MockContainerRuntime_RemoveImage_Call) RunAndReturn(run func(ctx context.Context, image string, force bool) error) *MockContainerRuntime_RemoveImage_Call {
1605 _c.Call.Return(run)
1606 return _c
1607}
1608
1609// RemoveNetwork provides a mock function for the type MockContainerRuntime
1610func (_mock *MockContainerRuntime) RemoveNetwork(ctx context.Context, name string) error {
1611 ret := _mock.Called(ctx, name)
1612
1613 if len(ret) == 0 {
1614 panic("no return value specified for RemoveNetwork")
1615 }
1616
1617 var r0 error
1618 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
1619 r0 = returnFunc(ctx, name)
1620 } else {
1621 r0 = ret.Error(0)
1622 }
1623 return r0
1624}
1625
1626// MockContainerRuntime_RemoveNetwork_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveNetwork'
1627type MockContainerRuntime_RemoveNetwork_Call struct {
1628 *mock.Call
1629}
1630
1631// RemoveNetwork is a helper method to define mock.On call
1632// - ctx context.Context
1633// - name string
1634func (_e *MockContainerRuntime_Expecter) RemoveNetwork(ctx interface{}, name interface{}) *MockContainerRuntime_RemoveNetwork_Call {
1635 return &MockContainerRuntime_RemoveNetwork_Call{Call: _e.mock.On("RemoveNetwork", ctx, name)}
1636}
1637
1638func (_c *MockContainerRuntime_RemoveNetwork_Call) Run(run func(ctx context.Context, name string)) *MockContainerRuntime_RemoveNetwork_Call {
1639 _c.Call.Run(func(args mock.Arguments) {
1640 var arg0 context.Context
1641 if args[0] != nil {
1642 arg0 = args[0].(context.Context)
1643 }
1644 var arg1 string
1645 if args[1] != nil {
1646 arg1 = args[1].(string)
1647 }
1648 run(
1649 arg0,
1650 arg1,
1651 )
1652 })
1653 return _c
1654}
1655
1656func (_c *MockContainerRuntime_RemoveNetwork_Call) Return(err error) *MockContainerRuntime_RemoveNetwork_Call {
1657 _c.Call.Return(err)
1658 return _c
1659}
1660
1661func (_c *MockContainerRuntime_RemoveNetwork_Call) RunAndReturn(run func(ctx context.Context, name string) error) *MockContainerRuntime_RemoveNetwork_Call {
1662 _c.Call.Return(run)
1663 return _c
1664}
1665
1666// RemoveVolume provides a mock function for the type MockContainerRuntime
1667func (_mock *MockContainerRuntime) RemoveVolume(ctx context.Context, volumeName string, force bool) error {
1668 ret := _mock.Called(ctx, volumeName, force)
1669
1670 if len(ret) == 0 {
1671 panic("no return value specified for RemoveVolume")
1672 }
1673
1674 var r0 error
1675 if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) error); ok {
1676 r0 = returnFunc(ctx, volumeName, force)
1677 } else {
1678 r0 = ret.Error(0)
1679 }
1680 return r0
1681}
1682
1683// MockContainerRuntime_RemoveVolume_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveVolume'
1684type MockContainerRuntime_RemoveVolume_Call struct {
1685 *mock.Call
1686}
1687
1688// RemoveVolume is a helper method to define mock.On call
1689// - ctx context.Context
1690// - volumeName string
1691// - force bool
1692func (_e *MockContainerRuntime_Expecter) RemoveVolume(ctx interface{}, volumeName interface{}, force interface{}) *MockContainerRuntime_RemoveVolume_Call {
1693 return &MockContainerRuntime_RemoveVolume_Call{Call: _e.mock.On("RemoveVolume", ctx, volumeName, force)}
1694}
1695
1696func (_c *MockContainerRuntime_RemoveVolume_Call) Run(run func(ctx context.Context, volumeName string, force bool)) *MockContainerRuntime_RemoveVolume_Call {
1697 _c.Call.Run(func(args mock.Arguments) {
1698 var arg0 context.Context
1699 if args[0] != nil {
1700 arg0 = args[0].(context.Context)
1701 }
1702 var arg1 string
1703 if args[1] != nil {
1704 arg1 = args[1].(string)
1705 }
1706 var arg2 bool
1707 if args[2] != nil {
1708 arg2 = args[2].(bool)
1709 }
1710 run(
1711 arg0,
1712 arg1,
1713 arg2,
1714 )
1715 })
1716 return _c
1717}
1718
1719func (_c *MockContainerRuntime_RemoveVolume_Call) Return(err error) *MockContainerRuntime_RemoveVolume_Call {
1720 _c.Call.Return(err)
1721 return _c
1722}
1723
1724func (_c *MockContainerRuntime_RemoveVolume_Call) RunAndReturn(run func(ctx context.Context, volumeName string, force bool) error) *MockContainerRuntime_RemoveVolume_Call {
1725 _c.Call.Return(run)
1726 return _c
1727}
1728
1729// RenameContainer provides a mock function for the type MockContainerRuntime
1730func (_mock *MockContainerRuntime) RenameContainer(ctx context.Context, containerID string, newName string) error {
1731 ret := _mock.Called(ctx, containerID, newName)
1732
1733 if len(ret) == 0 {
1734 panic("no return value specified for RenameContainer")
1735 }
1736
1737 var r0 error
1738 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
1739 r0 = returnFunc(ctx, containerID, newName)
1740 } else {
1741 r0 = ret.Error(0)
1742 }
1743 return r0
1744}
1745
1746// MockContainerRuntime_RenameContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenameContainer'
1747type MockContainerRuntime_RenameContainer_Call struct {
1748 *mock.Call
1749}
1750
1751// RenameContainer is a helper method to define mock.On call
1752// - ctx context.Context
1753// - containerID string
1754// - newName string
1755func (_e *MockContainerRuntime_Expecter) RenameContainer(ctx interface{}, containerID interface{}, newName interface{}) *MockContainerRuntime_RenameContainer_Call {
1756 return &MockContainerRuntime_RenameContainer_Call{Call: _e.mock.On("RenameContainer", ctx, containerID, newName)}
1757}
1758
1759func (_c *MockContainerRuntime_RenameContainer_Call) Run(run func(ctx context.Context, containerID string, newName string)) *MockContainerRuntime_RenameContainer_Call {
1760 _c.Call.Run(func(args mock.Arguments) {
1761 var arg0 context.Context
1762 if args[0] != nil {
1763 arg0 = args[0].(context.Context)
1764 }
1765 var arg1 string
1766 if args[1] != nil {
1767 arg1 = args[1].(string)
1768 }
1769 var arg2 string
1770 if args[2] != nil {
1771 arg2 = args[2].(string)
1772 }
1773 run(
1774 arg0,
1775 arg1,
1776 arg2,
1777 )
1778 })
1779 return _c
1780}
1781
1782func (_c *MockContainerRuntime_RenameContainer_Call) Return(err error) *MockContainerRuntime_RenameContainer_Call {
1783 _c.Call.Return(err)
1784 return _c
1785}
1786
1787func (_c *MockContainerRuntime_RenameContainer_Call) RunAndReturn(run func(ctx context.Context, containerID string, newName string) error) *MockContainerRuntime_RenameContainer_Call {
1788 _c.Call.Return(run)
1789 return _c
1790}
1791
1792// RestartContainer provides a mock function for the type MockContainerRuntime
1793func (_mock *MockContainerRuntime) RestartContainer(ctx context.Context, containerID string) error {
1794 ret := _mock.Called(ctx, containerID)
1795
1796 if len(ret) == 0 {
1797 panic("no return value specified for RestartContainer")
1798 }
1799
1800 var r0 error
1801 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
1802 r0 = returnFunc(ctx, containerID)
1803 } else {
1804 r0 = ret.Error(0)
1805 }
1806 return r0
1807}
1808
1809// MockContainerRuntime_RestartContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestartContainer'
1810type MockContainerRuntime_RestartContainer_Call struct {
1811 *mock.Call
1812}
1813
1814// RestartContainer is a helper method to define mock.On call
1815// - ctx context.Context
1816// - containerID string
1817func (_e *MockContainerRuntime_Expecter) RestartContainer(ctx interface{}, containerID interface{}) *MockContainerRuntime_RestartContainer_Call {
1818 return &MockContainerRuntime_RestartContainer_Call{Call: _e.mock.On("RestartContainer", ctx, containerID)}
1819}
1820
1821func (_c *MockContainerRuntime_RestartContainer_Call) Run(run func(ctx context.Context, containerID string)) *MockContainerRuntime_RestartContainer_Call {
1822 _c.Call.Run(func(args mock.Arguments) {
1823 var arg0 context.Context
1824 if args[0] != nil {
1825 arg0 = args[0].(context.Context)
1826 }
1827 var arg1 string
1828 if args[1] != nil {
1829 arg1 = args[1].(string)
1830 }
1831 run(
1832 arg0,
1833 arg1,
1834 )
1835 })
1836 return _c
1837}
1838
1839func (_c *MockContainerRuntime_RestartContainer_Call) Return(err error) *MockContainerRuntime_RestartContainer_Call {
1840 _c.Call.Return(err)
1841 return _c
1842}
1843
1844func (_c *MockContainerRuntime_RestartContainer_Call) RunAndReturn(run func(ctx context.Context, containerID string) error) *MockContainerRuntime_RestartContainer_Call {
1845 _c.Call.Return(run)
1846 return _c
1847}
1848
1849// StartContainer provides a mock function for the type MockContainerRuntime
1850func (_mock *MockContainerRuntime) StartContainer(ctx context.Context, containerID string) error {
1851 ret := _mock.Called(ctx, containerID)
1852
1853 if len(ret) == 0 {
1854 panic("no return value specified for StartContainer")
1855 }
1856
1857 var r0 error
1858 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
1859 r0 = returnFunc(ctx, containerID)
1860 } else {
1861 r0 = ret.Error(0)
1862 }
1863 return r0
1864}
1865
1866// MockContainerRuntime_StartContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartContainer'
1867type MockContainerRuntime_StartContainer_Call struct {
1868 *mock.Call
1869}
1870
1871// StartContainer is a helper method to define mock.On call
1872// - ctx context.Context
1873// - containerID string
1874func (_e *MockContainerRuntime_Expecter) StartContainer(ctx interface{}, containerID interface{}) *MockContainerRuntime_StartContainer_Call {
1875 return &MockContainerRuntime_StartContainer_Call{Call: _e.mock.On("StartContainer", ctx, containerID)}
1876}
1877
1878func (_c *MockContainerRuntime_StartContainer_Call) Run(run func(ctx context.Context, containerID string)) *MockContainerRuntime_StartContainer_Call {
1879 _c.Call.Run(func(args mock.Arguments) {
1880 var arg0 context.Context
1881 if args[0] != nil {
1882 arg0 = args[0].(context.Context)
1883 }
1884 var arg1 string
1885 if args[1] != nil {
1886 arg1 = args[1].(string)
1887 }
1888 run(
1889 arg0,
1890 arg1,
1891 )
1892 })
1893 return _c
1894}
1895
1896func (_c *MockContainerRuntime_StartContainer_Call) Return(err error) *MockContainerRuntime_StartContainer_Call {
1897 _c.Call.Return(err)
1898 return _c
1899}
1900
1901func (_c *MockContainerRuntime_StartContainer_Call) RunAndReturn(run func(ctx context.Context, containerID string) error) *MockContainerRuntime_StartContainer_Call {
1902 _c.Call.Return(run)
1903 return _c
1904}
1905
1906// StopContainer provides a mock function for the type MockContainerRuntime
1907func (_mock *MockContainerRuntime) StopContainer(ctx context.Context, containerID string) error {
1908 ret := _mock.Called(ctx, containerID)
1909
1910 if len(ret) == 0 {
1911 panic("no return value specified for StopContainer")
1912 }
1913
1914 var r0 error
1915 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
1916 r0 = returnFunc(ctx, containerID)
1917 } else {
1918 r0 = ret.Error(0)
1919 }
1920 return r0
1921}
1922
1923// MockContainerRuntime_StopContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StopContainer'
1924type MockContainerRuntime_StopContainer_Call struct {
1925 *mock.Call
1926}
1927
1928// StopContainer is a helper method to define mock.On call
1929// - ctx context.Context
1930// - containerID string
1931func (_e *MockContainerRuntime_Expecter) StopContainer(ctx interface{}, containerID interface{}) *MockContainerRuntime_StopContainer_Call {
1932 return &MockContainerRuntime_StopContainer_Call{Call: _e.mock.On("StopContainer", ctx, containerID)}
1933}
1934
1935func (_c *MockContainerRuntime_StopContainer_Call) Run(run func(ctx context.Context, containerID string)) *MockContainerRuntime_StopContainer_Call {
1936 _c.Call.Run(func(args mock.Arguments) {
1937 var arg0 context.Context
1938 if args[0] != nil {
1939 arg0 = args[0].(context.Context)
1940 }
1941 var arg1 string
1942 if args[1] != nil {
1943 arg1 = args[1].(string)
1944 }
1945 run(
1946 arg0,
1947 arg1,
1948 )
1949 })
1950 return _c
1951}
1952
1953func (_c *MockContainerRuntime_StopContainer_Call) Return(err error) *MockContainerRuntime_StopContainer_Call {
1954 _c.Call.Return(err)
1955 return _c
1956}
1957
1958func (_c *MockContainerRuntime_StopContainer_Call) RunAndReturn(run func(ctx context.Context, containerID string) error) *MockContainerRuntime_StopContainer_Call {
1959 _c.Call.Return(run)
1960 return _c
1961}
1962
1963// TagImage provides a mock function for the type MockContainerRuntime
1964func (_mock *MockContainerRuntime) TagImage(ctx context.Context, sourceRef string, targetRef string) error {
1965 ret := _mock.Called(ctx, sourceRef, targetRef)
1966
1967 if len(ret) == 0 {
1968 panic("no return value specified for TagImage")
1969 }
1970
1971 var r0 error
1972 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
1973 r0 = returnFunc(ctx, sourceRef, targetRef)
1974 } else {
1975 r0 = ret.Error(0)
1976 }
1977 return r0
1978}
1979
1980// MockContainerRuntime_TagImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TagImage'
1981type MockContainerRuntime_TagImage_Call struct {
1982 *mock.Call
1983}
1984
1985// TagImage is a helper method to define mock.On call
1986// - ctx context.Context
1987// - sourceRef string
1988// - targetRef string
1989func (_e *MockContainerRuntime_Expecter) TagImage(ctx interface{}, sourceRef interface{}, targetRef interface{}) *MockContainerRuntime_TagImage_Call {
1990 return &MockContainerRuntime_TagImage_Call{Call: _e.mock.On("TagImage", ctx, sourceRef, targetRef)}
1991}
1992
1993func (_c *MockContainerRuntime_TagImage_Call) Run(run func(ctx context.Context, sourceRef string, targetRef string)) *MockContainerRuntime_TagImage_Call {
1994 _c.Call.Run(func(args mock.Arguments) {
1995 var arg0 context.Context
1996 if args[0] != nil {
1997 arg0 = args[0].(context.Context)
1998 }
1999 var arg1 string
2000 if args[1] != nil {
2001 arg1 = args[1].(string)
2002 }
2003 var arg2 string
2004 if args[2] != nil {
2005 arg2 = args[2].(string)
2006 }
2007 run(
2008 arg0,
2009 arg1,
2010 arg2,
2011 )
2012 })
2013 return _c
2014}
2015
2016func (_c *MockContainerRuntime_TagImage_Call) Return(err error) *MockContainerRuntime_TagImage_Call {
2017 _c.Call.Return(err)
2018 return _c
2019}
2020
2021func (_c *MockContainerRuntime_TagImage_Call) RunAndReturn(run func(ctx context.Context, sourceRef string, targetRef string) error) *MockContainerRuntime_TagImage_Call {
2022 _c.Call.Return(run)
2023 return _c
2024}
2025
2026// UntagImage provides a mock function for the type MockContainerRuntime
2027func (_mock *MockContainerRuntime) UntagImage(ctx context.Context, imageRef string) error {
2028 ret := _mock.Called(ctx, imageRef)
2029
2030 if len(ret) == 0 {
2031 panic("no return value specified for UntagImage")
2032 }
2033
2034 var r0 error
2035 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
2036 r0 = returnFunc(ctx, imageRef)
2037 } else {
2038 r0 = ret.Error(0)
2039 }
2040 return r0
2041}
2042
2043// MockContainerRuntime_UntagImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UntagImage'
2044type MockContainerRuntime_UntagImage_Call struct {
2045 *mock.Call
2046}
2047
2048// UntagImage is a helper method to define mock.On call
2049// - ctx context.Context
2050// - imageRef string
2051func (_e *MockContainerRuntime_Expecter) UntagImage(ctx interface{}, imageRef interface{}) *MockContainerRuntime_UntagImage_Call {
2052 return &MockContainerRuntime_UntagImage_Call{Call: _e.mock.On("UntagImage", ctx, imageRef)}
2053}
2054
2055func (_c *MockContainerRuntime_UntagImage_Call) Run(run func(ctx context.Context, imageRef string)) *MockContainerRuntime_UntagImage_Call {
2056 _c.Call.Run(func(args mock.Arguments) {
2057 var arg0 context.Context
2058 if args[0] != nil {
2059 arg0 = args[0].(context.Context)
2060 }
2061 var arg1 string
2062 if args[1] != nil {
2063 arg1 = args[1].(string)
2064 }
2065 run(
2066 arg0,
2067 arg1,
2068 )
2069 })
2070 return _c
2071}
2072
2073func (_c *MockContainerRuntime_UntagImage_Call) Return(err error) *MockContainerRuntime_UntagImage_Call {
2074 _c.Call.Return(err)
2075 return _c
2076}
2077
2078func (_c *MockContainerRuntime_UntagImage_Call) RunAndReturn(run func(ctx context.Context, imageRef string) error) *MockContainerRuntime_UntagImage_Call {
2079 _c.Call.Return(run)
2080 return _c
2081}
2082
2083// Version provides a mock function for the type MockContainerRuntime
2084func (_mock *MockContainerRuntime) Version(ctx context.Context) (string, error) {
2085 ret := _mock.Called(ctx)
2086
2087 if len(ret) == 0 {
2088 panic("no return value specified for Version")
2089 }
2090
2091 var r0 string
2092 var r1 error
2093 if returnFunc, ok := ret.Get(0).(func(context.Context) (string, error)); ok {
2094 return returnFunc(ctx)
2095 }
2096 if returnFunc, ok := ret.Get(0).(func(context.Context) string); ok {
2097 r0 = returnFunc(ctx)
2098 } else {
2099 r0 = ret.Get(0).(string)
2100 }
2101 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
2102 r1 = returnFunc(ctx)
2103 } else {
2104 r1 = ret.Error(1)
2105 }
2106 return r0, r1
2107}
2108
2109// MockContainerRuntime_Version_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Version'
2110type MockContainerRuntime_Version_Call struct {
2111 *mock.Call
2112}
2113
2114// Version is a helper method to define mock.On call
2115// - ctx context.Context
2116func (_e *MockContainerRuntime_Expecter) Version(ctx interface{}) *MockContainerRuntime_Version_Call {
2117 return &MockContainerRuntime_Version_Call{Call: _e.mock.On("Version", ctx)}
2118}
2119
2120func (_c *MockContainerRuntime_Version_Call) Run(run func(ctx context.Context)) *MockContainerRuntime_Version_Call {
2121 _c.Call.Run(func(args mock.Arguments) {
2122 var arg0 context.Context
2123 if args[0] != nil {
2124 arg0 = args[0].(context.Context)
2125 }
2126 run(
2127 arg0,
2128 )
2129 })
2130 return _c
2131}
2132
2133func (_c *MockContainerRuntime_Version_Call) Return(s string, err error) *MockContainerRuntime_Version_Call {
2134 _c.Call.Return(s, err)
2135 return _c
2136}
2137
2138func (_c *MockContainerRuntime_Version_Call) RunAndReturn(run func(ctx context.Context) (string, error)) *MockContainerRuntime_Version_Call {
2139 _c.Call.Return(run)
2140 return _c
2141}
2142
2143// VolumeExists provides a mock function for the type MockContainerRuntime
2144func (_mock *MockContainerRuntime) VolumeExists(ctx context.Context, volumeName string) (bool, error) {
2145 ret := _mock.Called(ctx, volumeName)
2146
2147 if len(ret) == 0 {
2148 panic("no return value specified for VolumeExists")
2149 }
2150
2151 var r0 bool
2152 var r1 error
2153 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (bool, error)); ok {
2154 return returnFunc(ctx, volumeName)
2155 }
2156 if returnFunc, ok := ret.Get(0).(func(context.Context, string) bool); ok {
2157 r0 = returnFunc(ctx, volumeName)
2158 } else {
2159 r0 = ret.Get(0).(bool)
2160 }
2161 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
2162 r1 = returnFunc(ctx, volumeName)
2163 } else {
2164 r1 = ret.Error(1)
2165 }
2166 return r0, r1
2167}
2168
2169// MockContainerRuntime_VolumeExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VolumeExists'
2170type MockContainerRuntime_VolumeExists_Call struct {
2171 *mock.Call
2172}
2173
2174// VolumeExists is a helper method to define mock.On call
2175// - ctx context.Context
2176// - volumeName string
2177func (_e *MockContainerRuntime_Expecter) VolumeExists(ctx interface{}, volumeName interface{}) *MockContainerRuntime_VolumeExists_Call {
2178 return &MockContainerRuntime_VolumeExists_Call{Call: _e.mock.On("VolumeExists", ctx, volumeName)}
2179}
2180
2181func (_c *MockContainerRuntime_VolumeExists_Call) Run(run func(ctx context.Context, volumeName string)) *MockContainerRuntime_VolumeExists_Call {
2182 _c.Call.Run(func(args mock.Arguments) {
2183 var arg0 context.Context
2184 if args[0] != nil {
2185 arg0 = args[0].(context.Context)
2186 }
2187 var arg1 string
2188 if args[1] != nil {
2189 arg1 = args[1].(string)
2190 }
2191 run(
2192 arg0,
2193 arg1,
2194 )
2195 })
2196 return _c
2197}
2198
2199func (_c *MockContainerRuntime_VolumeExists_Call) Return(b bool, err error) *MockContainerRuntime_VolumeExists_Call {
2200 _c.Call.Return(b, err)
2201 return _c
2202}
2203
2204func (_c *MockContainerRuntime_VolumeExists_Call) RunAndReturn(run func(ctx context.Context, volumeName string) (bool, error)) *MockContainerRuntime_VolumeExists_Call {
2205 _c.Call.Return(run)
2206 return _c
2207}