1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package mocks
6
7import (
8 "context"
9 "io"
10
11 "github.com/bnema/gordon/internal/domain"
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// GetContainerNetwork provides a mock function for the type MockContainerRuntime
499func (_mock *MockContainerRuntime) GetContainerNetwork(ctx context.Context, containerID string) (string, error) {
500 ret := _mock.Called(ctx, containerID)
501
502 if len(ret) == 0 {
503 panic("no return value specified for GetContainerNetwork")
504 }
505
506 var r0 string
507 var r1 error
508 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (string, error)); ok {
509 return returnFunc(ctx, containerID)
510 }
511 if returnFunc, ok := ret.Get(0).(func(context.Context, string) string); ok {
512 r0 = returnFunc(ctx, containerID)
513 } else {
514 r0 = ret.Get(0).(string)
515 }
516 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
517 r1 = returnFunc(ctx, containerID)
518 } else {
519 r1 = ret.Error(1)
520 }
521 return r0, r1
522}
523
524// MockContainerRuntime_GetContainerNetwork_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetContainerNetwork'
525type MockContainerRuntime_GetContainerNetwork_Call struct {
526 *mock.Call
527}
528
529// GetContainerNetwork is a helper method to define mock.On call
530// - ctx context.Context
531// - containerID string
532func (_e *MockContainerRuntime_Expecter) GetContainerNetwork(ctx interface{}, containerID interface{}) *MockContainerRuntime_GetContainerNetwork_Call {
533 return &MockContainerRuntime_GetContainerNetwork_Call{Call: _e.mock.On("GetContainerNetwork", ctx, containerID)}
534}
535
536func (_c *MockContainerRuntime_GetContainerNetwork_Call) Run(run func(ctx context.Context, containerID string)) *MockContainerRuntime_GetContainerNetwork_Call {
537 _c.Call.Run(func(args mock.Arguments) {
538 var arg0 context.Context
539 if args[0] != nil {
540 arg0 = args[0].(context.Context)
541 }
542 var arg1 string
543 if args[1] != nil {
544 arg1 = args[1].(string)
545 }
546 run(
547 arg0,
548 arg1,
549 )
550 })
551 return _c
552}
553
554func (_c *MockContainerRuntime_GetContainerNetwork_Call) Return(s string, err error) *MockContainerRuntime_GetContainerNetwork_Call {
555 _c.Call.Return(s, err)
556 return _c
557}
558
559func (_c *MockContainerRuntime_GetContainerNetwork_Call) RunAndReturn(run func(ctx context.Context, containerID string) (string, error)) *MockContainerRuntime_GetContainerNetwork_Call {
560 _c.Call.Return(run)
561 return _c
562}
563
564// GetContainerNetworkInfo provides a mock function for the type MockContainerRuntime
565func (_mock *MockContainerRuntime) GetContainerNetworkInfo(ctx context.Context, containerID string) (string, int, error) {
566 ret := _mock.Called(ctx, containerID)
567
568 if len(ret) == 0 {
569 panic("no return value specified for GetContainerNetworkInfo")
570 }
571
572 var r0 string
573 var r1 int
574 var r2 error
575 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (string, int, error)); ok {
576 return returnFunc(ctx, containerID)
577 }
578 if returnFunc, ok := ret.Get(0).(func(context.Context, string) string); ok {
579 r0 = returnFunc(ctx, containerID)
580 } else {
581 r0 = ret.Get(0).(string)
582 }
583 if returnFunc, ok := ret.Get(1).(func(context.Context, string) int); ok {
584 r1 = returnFunc(ctx, containerID)
585 } else {
586 r1 = ret.Get(1).(int)
587 }
588 if returnFunc, ok := ret.Get(2).(func(context.Context, string) error); ok {
589 r2 = returnFunc(ctx, containerID)
590 } else {
591 r2 = ret.Error(2)
592 }
593 return r0, r1, r2
594}
595
596// MockContainerRuntime_GetContainerNetworkInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetContainerNetworkInfo'
597type MockContainerRuntime_GetContainerNetworkInfo_Call struct {
598 *mock.Call
599}
600
601// GetContainerNetworkInfo is a helper method to define mock.On call
602// - ctx context.Context
603// - containerID string
604func (_e *MockContainerRuntime_Expecter) GetContainerNetworkInfo(ctx interface{}, containerID interface{}) *MockContainerRuntime_GetContainerNetworkInfo_Call {
605 return &MockContainerRuntime_GetContainerNetworkInfo_Call{Call: _e.mock.On("GetContainerNetworkInfo", ctx, containerID)}
606}
607
608func (_c *MockContainerRuntime_GetContainerNetworkInfo_Call) Run(run func(ctx context.Context, containerID string)) *MockContainerRuntime_GetContainerNetworkInfo_Call {
609 _c.Call.Run(func(args mock.Arguments) {
610 var arg0 context.Context
611 if args[0] != nil {
612 arg0 = args[0].(context.Context)
613 }
614 var arg1 string
615 if args[1] != nil {
616 arg1 = args[1].(string)
617 }
618 run(
619 arg0,
620 arg1,
621 )
622 })
623 return _c
624}
625
626func (_c *MockContainerRuntime_GetContainerNetworkInfo_Call) Return(s string, n int, err error) *MockContainerRuntime_GetContainerNetworkInfo_Call {
627 _c.Call.Return(s, n, err)
628 return _c
629}
630
631func (_c *MockContainerRuntime_GetContainerNetworkInfo_Call) RunAndReturn(run func(ctx context.Context, containerID string) (string, int, error)) *MockContainerRuntime_GetContainerNetworkInfo_Call {
632 _c.Call.Return(run)
633 return _c
634}
635
636// GetContainerPort provides a mock function for the type MockContainerRuntime
637func (_mock *MockContainerRuntime) GetContainerPort(ctx context.Context, containerID string, internalPort int) (int, error) {
638 ret := _mock.Called(ctx, containerID, internalPort)
639
640 if len(ret) == 0 {
641 panic("no return value specified for GetContainerPort")
642 }
643
644 var r0 int
645 var r1 error
646 if returnFunc, ok := ret.Get(0).(func(context.Context, string, int) (int, error)); ok {
647 return returnFunc(ctx, containerID, internalPort)
648 }
649 if returnFunc, ok := ret.Get(0).(func(context.Context, string, int) int); ok {
650 r0 = returnFunc(ctx, containerID, internalPort)
651 } else {
652 r0 = ret.Get(0).(int)
653 }
654 if returnFunc, ok := ret.Get(1).(func(context.Context, string, int) error); ok {
655 r1 = returnFunc(ctx, containerID, internalPort)
656 } else {
657 r1 = ret.Error(1)
658 }
659 return r0, r1
660}
661
662// MockContainerRuntime_GetContainerPort_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetContainerPort'
663type MockContainerRuntime_GetContainerPort_Call struct {
664 *mock.Call
665}
666
667// GetContainerPort is a helper method to define mock.On call
668// - ctx context.Context
669// - containerID string
670// - internalPort int
671func (_e *MockContainerRuntime_Expecter) GetContainerPort(ctx interface{}, containerID interface{}, internalPort interface{}) *MockContainerRuntime_GetContainerPort_Call {
672 return &MockContainerRuntime_GetContainerPort_Call{Call: _e.mock.On("GetContainerPort", ctx, containerID, internalPort)}
673}
674
675func (_c *MockContainerRuntime_GetContainerPort_Call) Run(run func(ctx context.Context, containerID string, internalPort int)) *MockContainerRuntime_GetContainerPort_Call {
676 _c.Call.Run(func(args mock.Arguments) {
677 var arg0 context.Context
678 if args[0] != nil {
679 arg0 = args[0].(context.Context)
680 }
681 var arg1 string
682 if args[1] != nil {
683 arg1 = args[1].(string)
684 }
685 var arg2 int
686 if args[2] != nil {
687 arg2 = args[2].(int)
688 }
689 run(
690 arg0,
691 arg1,
692 arg2,
693 )
694 })
695 return _c
696}
697
698func (_c *MockContainerRuntime_GetContainerPort_Call) Return(n int, err error) *MockContainerRuntime_GetContainerPort_Call {
699 _c.Call.Return(n, err)
700 return _c
701}
702
703func (_c *MockContainerRuntime_GetContainerPort_Call) RunAndReturn(run func(ctx context.Context, containerID string, internalPort int) (int, error)) *MockContainerRuntime_GetContainerPort_Call {
704 _c.Call.Return(run)
705 return _c
706}
707
708// GetImageExposedPorts provides a mock function for the type MockContainerRuntime
709func (_mock *MockContainerRuntime) GetImageExposedPorts(ctx context.Context, imageRef string) ([]int, error) {
710 ret := _mock.Called(ctx, imageRef)
711
712 if len(ret) == 0 {
713 panic("no return value specified for GetImageExposedPorts")
714 }
715
716 var r0 []int
717 var r1 error
718 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]int, error)); ok {
719 return returnFunc(ctx, imageRef)
720 }
721 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []int); ok {
722 r0 = returnFunc(ctx, imageRef)
723 } else {
724 if ret.Get(0) != nil {
725 r0 = ret.Get(0).([]int)
726 }
727 }
728 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
729 r1 = returnFunc(ctx, imageRef)
730 } else {
731 r1 = ret.Error(1)
732 }
733 return r0, r1
734}
735
736// MockContainerRuntime_GetImageExposedPorts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetImageExposedPorts'
737type MockContainerRuntime_GetImageExposedPorts_Call struct {
738 *mock.Call
739}
740
741// GetImageExposedPorts is a helper method to define mock.On call
742// - ctx context.Context
743// - imageRef string
744func (_e *MockContainerRuntime_Expecter) GetImageExposedPorts(ctx interface{}, imageRef interface{}) *MockContainerRuntime_GetImageExposedPorts_Call {
745 return &MockContainerRuntime_GetImageExposedPorts_Call{Call: _e.mock.On("GetImageExposedPorts", ctx, imageRef)}
746}
747
748func (_c *MockContainerRuntime_GetImageExposedPorts_Call) Run(run func(ctx context.Context, imageRef string)) *MockContainerRuntime_GetImageExposedPorts_Call {
749 _c.Call.Run(func(args mock.Arguments) {
750 var arg0 context.Context
751 if args[0] != nil {
752 arg0 = args[0].(context.Context)
753 }
754 var arg1 string
755 if args[1] != nil {
756 arg1 = args[1].(string)
757 }
758 run(
759 arg0,
760 arg1,
761 )
762 })
763 return _c
764}
765
766func (_c *MockContainerRuntime_GetImageExposedPorts_Call) Return(ints []int, err error) *MockContainerRuntime_GetImageExposedPorts_Call {
767 _c.Call.Return(ints, err)
768 return _c
769}
770
771func (_c *MockContainerRuntime_GetImageExposedPorts_Call) RunAndReturn(run func(ctx context.Context, imageRef string) ([]int, error)) *MockContainerRuntime_GetImageExposedPorts_Call {
772 _c.Call.Return(run)
773 return _c
774}
775
776// GetImageLabels provides a mock function for the type MockContainerRuntime
777func (_mock *MockContainerRuntime) GetImageLabels(ctx context.Context, imageRef string) (map[string]string, error) {
778 ret := _mock.Called(ctx, imageRef)
779
780 if len(ret) == 0 {
781 panic("no return value specified for GetImageLabels")
782 }
783
784 var r0 map[string]string
785 var r1 error
786 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (map[string]string, error)); ok {
787 return returnFunc(ctx, imageRef)
788 }
789 if returnFunc, ok := ret.Get(0).(func(context.Context, string) map[string]string); ok {
790 r0 = returnFunc(ctx, imageRef)
791 } else {
792 if ret.Get(0) != nil {
793 r0 = ret.Get(0).(map[string]string)
794 }
795 }
796 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
797 r1 = returnFunc(ctx, imageRef)
798 } else {
799 r1 = ret.Error(1)
800 }
801 return r0, r1
802}
803
804// MockContainerRuntime_GetImageLabels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetImageLabels'
805type MockContainerRuntime_GetImageLabels_Call struct {
806 *mock.Call
807}
808
809// GetImageLabels is a helper method to define mock.On call
810// - ctx context.Context
811// - imageRef string
812func (_e *MockContainerRuntime_Expecter) GetImageLabels(ctx interface{}, imageRef interface{}) *MockContainerRuntime_GetImageLabels_Call {
813 return &MockContainerRuntime_GetImageLabels_Call{Call: _e.mock.On("GetImageLabels", ctx, imageRef)}
814}
815
816func (_c *MockContainerRuntime_GetImageLabels_Call) Run(run func(ctx context.Context, imageRef string)) *MockContainerRuntime_GetImageLabels_Call {
817 _c.Call.Run(func(args mock.Arguments) {
818 var arg0 context.Context
819 if args[0] != nil {
820 arg0 = args[0].(context.Context)
821 }
822 var arg1 string
823 if args[1] != nil {
824 arg1 = args[1].(string)
825 }
826 run(
827 arg0,
828 arg1,
829 )
830 })
831 return _c
832}
833
834func (_c *MockContainerRuntime_GetImageLabels_Call) Return(stringToString map[string]string, err error) *MockContainerRuntime_GetImageLabels_Call {
835 _c.Call.Return(stringToString, err)
836 return _c
837}
838
839func (_c *MockContainerRuntime_GetImageLabels_Call) RunAndReturn(run func(ctx context.Context, imageRef string) (map[string]string, error)) *MockContainerRuntime_GetImageLabels_Call {
840 _c.Call.Return(run)
841 return _c
842}
843
844// InspectContainer provides a mock function for the type MockContainerRuntime
845func (_mock *MockContainerRuntime) InspectContainer(ctx context.Context, containerID string) (*domain.Container, error) {
846 ret := _mock.Called(ctx, containerID)
847
848 if len(ret) == 0 {
849 panic("no return value specified for InspectContainer")
850 }
851
852 var r0 *domain.Container
853 var r1 error
854 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*domain.Container, error)); ok {
855 return returnFunc(ctx, containerID)
856 }
857 if returnFunc, ok := ret.Get(0).(func(context.Context, string) *domain.Container); ok {
858 r0 = returnFunc(ctx, containerID)
859 } else {
860 if ret.Get(0) != nil {
861 r0 = ret.Get(0).(*domain.Container)
862 }
863 }
864 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
865 r1 = returnFunc(ctx, containerID)
866 } else {
867 r1 = ret.Error(1)
868 }
869 return r0, r1
870}
871
872// MockContainerRuntime_InspectContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InspectContainer'
873type MockContainerRuntime_InspectContainer_Call struct {
874 *mock.Call
875}
876
877// InspectContainer is a helper method to define mock.On call
878// - ctx context.Context
879// - containerID string
880func (_e *MockContainerRuntime_Expecter) InspectContainer(ctx interface{}, containerID interface{}) *MockContainerRuntime_InspectContainer_Call {
881 return &MockContainerRuntime_InspectContainer_Call{Call: _e.mock.On("InspectContainer", ctx, containerID)}
882}
883
884func (_c *MockContainerRuntime_InspectContainer_Call) Run(run func(ctx context.Context, containerID string)) *MockContainerRuntime_InspectContainer_Call {
885 _c.Call.Run(func(args mock.Arguments) {
886 var arg0 context.Context
887 if args[0] != nil {
888 arg0 = args[0].(context.Context)
889 }
890 var arg1 string
891 if args[1] != nil {
892 arg1 = args[1].(string)
893 }
894 run(
895 arg0,
896 arg1,
897 )
898 })
899 return _c
900}
901
902func (_c *MockContainerRuntime_InspectContainer_Call) Return(container *domain.Container, err error) *MockContainerRuntime_InspectContainer_Call {
903 _c.Call.Return(container, err)
904 return _c
905}
906
907func (_c *MockContainerRuntime_InspectContainer_Call) RunAndReturn(run func(ctx context.Context, containerID string) (*domain.Container, error)) *MockContainerRuntime_InspectContainer_Call {
908 _c.Call.Return(run)
909 return _c
910}
911
912// InspectImageEnv provides a mock function for the type MockContainerRuntime
913func (_mock *MockContainerRuntime) InspectImageEnv(ctx context.Context, imageRef string) ([]string, error) {
914 ret := _mock.Called(ctx, imageRef)
915
916 if len(ret) == 0 {
917 panic("no return value specified for InspectImageEnv")
918 }
919
920 var r0 []string
921 var r1 error
922 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]string, error)); ok {
923 return returnFunc(ctx, imageRef)
924 }
925 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []string); ok {
926 r0 = returnFunc(ctx, imageRef)
927 } else {
928 if ret.Get(0) != nil {
929 r0 = ret.Get(0).([]string)
930 }
931 }
932 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
933 r1 = returnFunc(ctx, imageRef)
934 } else {
935 r1 = ret.Error(1)
936 }
937 return r0, r1
938}
939
940// MockContainerRuntime_InspectImageEnv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InspectImageEnv'
941type MockContainerRuntime_InspectImageEnv_Call struct {
942 *mock.Call
943}
944
945// InspectImageEnv is a helper method to define mock.On call
946// - ctx context.Context
947// - imageRef string
948func (_e *MockContainerRuntime_Expecter) InspectImageEnv(ctx interface{}, imageRef interface{}) *MockContainerRuntime_InspectImageEnv_Call {
949 return &MockContainerRuntime_InspectImageEnv_Call{Call: _e.mock.On("InspectImageEnv", ctx, imageRef)}
950}
951
952func (_c *MockContainerRuntime_InspectImageEnv_Call) Run(run func(ctx context.Context, imageRef string)) *MockContainerRuntime_InspectImageEnv_Call {
953 _c.Call.Run(func(args mock.Arguments) {
954 var arg0 context.Context
955 if args[0] != nil {
956 arg0 = args[0].(context.Context)
957 }
958 var arg1 string
959 if args[1] != nil {
960 arg1 = args[1].(string)
961 }
962 run(
963 arg0,
964 arg1,
965 )
966 })
967 return _c
968}
969
970func (_c *MockContainerRuntime_InspectImageEnv_Call) Return(strings []string, err error) *MockContainerRuntime_InspectImageEnv_Call {
971 _c.Call.Return(strings, err)
972 return _c
973}
974
975func (_c *MockContainerRuntime_InspectImageEnv_Call) RunAndReturn(run func(ctx context.Context, imageRef string) ([]string, error)) *MockContainerRuntime_InspectImageEnv_Call {
976 _c.Call.Return(run)
977 return _c
978}
979
980// InspectImageVolumes provides a mock function for the type MockContainerRuntime
981func (_mock *MockContainerRuntime) InspectImageVolumes(ctx context.Context, imageRef string) ([]string, error) {
982 ret := _mock.Called(ctx, imageRef)
983
984 if len(ret) == 0 {
985 panic("no return value specified for InspectImageVolumes")
986 }
987
988 var r0 []string
989 var r1 error
990 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]string, error)); ok {
991 return returnFunc(ctx, imageRef)
992 }
993 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []string); ok {
994 r0 = returnFunc(ctx, imageRef)
995 } else {
996 if ret.Get(0) != nil {
997 r0 = ret.Get(0).([]string)
998 }
999 }
1000 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
1001 r1 = returnFunc(ctx, imageRef)
1002 } else {
1003 r1 = ret.Error(1)
1004 }
1005 return r0, r1
1006}
1007
1008// MockContainerRuntime_InspectImageVolumes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InspectImageVolumes'
1009type MockContainerRuntime_InspectImageVolumes_Call struct {
1010 *mock.Call
1011}
1012
1013// InspectImageVolumes is a helper method to define mock.On call
1014// - ctx context.Context
1015// - imageRef string
1016func (_e *MockContainerRuntime_Expecter) InspectImageVolumes(ctx interface{}, imageRef interface{}) *MockContainerRuntime_InspectImageVolumes_Call {
1017 return &MockContainerRuntime_InspectImageVolumes_Call{Call: _e.mock.On("InspectImageVolumes", ctx, imageRef)}
1018}
1019
1020func (_c *MockContainerRuntime_InspectImageVolumes_Call) Run(run func(ctx context.Context, imageRef string)) *MockContainerRuntime_InspectImageVolumes_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_InspectImageVolumes_Call) Return(strings []string, err error) *MockContainerRuntime_InspectImageVolumes_Call {
1039 _c.Call.Return(strings, err)
1040 return _c
1041}
1042
1043func (_c *MockContainerRuntime_InspectImageVolumes_Call) RunAndReturn(run func(ctx context.Context, imageRef string) ([]string, error)) *MockContainerRuntime_InspectImageVolumes_Call {
1044 _c.Call.Return(run)
1045 return _c
1046}
1047
1048// IsContainerRunning provides a mock function for the type MockContainerRuntime
1049func (_mock *MockContainerRuntime) IsContainerRunning(ctx context.Context, containerID string) (bool, error) {
1050 ret := _mock.Called(ctx, containerID)
1051
1052 if len(ret) == 0 {
1053 panic("no return value specified for IsContainerRunning")
1054 }
1055
1056 var r0 bool
1057 var r1 error
1058 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (bool, error)); ok {
1059 return returnFunc(ctx, containerID)
1060 }
1061 if returnFunc, ok := ret.Get(0).(func(context.Context, string) bool); ok {
1062 r0 = returnFunc(ctx, containerID)
1063 } else {
1064 r0 = ret.Get(0).(bool)
1065 }
1066 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
1067 r1 = returnFunc(ctx, containerID)
1068 } else {
1069 r1 = ret.Error(1)
1070 }
1071 return r0, r1
1072}
1073
1074// MockContainerRuntime_IsContainerRunning_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsContainerRunning'
1075type MockContainerRuntime_IsContainerRunning_Call struct {
1076 *mock.Call
1077}
1078
1079// IsContainerRunning is a helper method to define mock.On call
1080// - ctx context.Context
1081// - containerID string
1082func (_e *MockContainerRuntime_Expecter) IsContainerRunning(ctx interface{}, containerID interface{}) *MockContainerRuntime_IsContainerRunning_Call {
1083 return &MockContainerRuntime_IsContainerRunning_Call{Call: _e.mock.On("IsContainerRunning", ctx, containerID)}
1084}
1085
1086func (_c *MockContainerRuntime_IsContainerRunning_Call) Run(run func(ctx context.Context, containerID string)) *MockContainerRuntime_IsContainerRunning_Call {
1087 _c.Call.Run(func(args mock.Arguments) {
1088 var arg0 context.Context
1089 if args[0] != nil {
1090 arg0 = args[0].(context.Context)
1091 }
1092 var arg1 string
1093 if args[1] != nil {
1094 arg1 = args[1].(string)
1095 }
1096 run(
1097 arg0,
1098 arg1,
1099 )
1100 })
1101 return _c
1102}
1103
1104func (_c *MockContainerRuntime_IsContainerRunning_Call) Return(b bool, err error) *MockContainerRuntime_IsContainerRunning_Call {
1105 _c.Call.Return(b, err)
1106 return _c
1107}
1108
1109func (_c *MockContainerRuntime_IsContainerRunning_Call) RunAndReturn(run func(ctx context.Context, containerID string) (bool, error)) *MockContainerRuntime_IsContainerRunning_Call {
1110 _c.Call.Return(run)
1111 return _c
1112}
1113
1114// ListContainers provides a mock function for the type MockContainerRuntime
1115func (_mock *MockContainerRuntime) ListContainers(ctx context.Context, all bool) ([]*domain.Container, error) {
1116 ret := _mock.Called(ctx, all)
1117
1118 if len(ret) == 0 {
1119 panic("no return value specified for ListContainers")
1120 }
1121
1122 var r0 []*domain.Container
1123 var r1 error
1124 if returnFunc, ok := ret.Get(0).(func(context.Context, bool) ([]*domain.Container, error)); ok {
1125 return returnFunc(ctx, all)
1126 }
1127 if returnFunc, ok := ret.Get(0).(func(context.Context, bool) []*domain.Container); ok {
1128 r0 = returnFunc(ctx, all)
1129 } else {
1130 if ret.Get(0) != nil {
1131 r0 = ret.Get(0).([]*domain.Container)
1132 }
1133 }
1134 if returnFunc, ok := ret.Get(1).(func(context.Context, bool) error); ok {
1135 r1 = returnFunc(ctx, all)
1136 } else {
1137 r1 = ret.Error(1)
1138 }
1139 return r0, r1
1140}
1141
1142// MockContainerRuntime_ListContainers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListContainers'
1143type MockContainerRuntime_ListContainers_Call struct {
1144 *mock.Call
1145}
1146
1147// ListContainers is a helper method to define mock.On call
1148// - ctx context.Context
1149// - all bool
1150func (_e *MockContainerRuntime_Expecter) ListContainers(ctx interface{}, all interface{}) *MockContainerRuntime_ListContainers_Call {
1151 return &MockContainerRuntime_ListContainers_Call{Call: _e.mock.On("ListContainers", ctx, all)}
1152}
1153
1154func (_c *MockContainerRuntime_ListContainers_Call) Run(run func(ctx context.Context, all bool)) *MockContainerRuntime_ListContainers_Call {
1155 _c.Call.Run(func(args mock.Arguments) {
1156 var arg0 context.Context
1157 if args[0] != nil {
1158 arg0 = args[0].(context.Context)
1159 }
1160 var arg1 bool
1161 if args[1] != nil {
1162 arg1 = args[1].(bool)
1163 }
1164 run(
1165 arg0,
1166 arg1,
1167 )
1168 })
1169 return _c
1170}
1171
1172func (_c *MockContainerRuntime_ListContainers_Call) Return(containers []*domain.Container, err error) *MockContainerRuntime_ListContainers_Call {
1173 _c.Call.Return(containers, err)
1174 return _c
1175}
1176
1177func (_c *MockContainerRuntime_ListContainers_Call) RunAndReturn(run func(ctx context.Context, all bool) ([]*domain.Container, error)) *MockContainerRuntime_ListContainers_Call {
1178 _c.Call.Return(run)
1179 return _c
1180}
1181
1182// ListImages provides a mock function for the type MockContainerRuntime
1183func (_mock *MockContainerRuntime) ListImages(ctx context.Context) ([]string, error) {
1184 ret := _mock.Called(ctx)
1185
1186 if len(ret) == 0 {
1187 panic("no return value specified for ListImages")
1188 }
1189
1190 var r0 []string
1191 var r1 error
1192 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]string, error)); ok {
1193 return returnFunc(ctx)
1194 }
1195 if returnFunc, ok := ret.Get(0).(func(context.Context) []string); ok {
1196 r0 = returnFunc(ctx)
1197 } else {
1198 if ret.Get(0) != nil {
1199 r0 = ret.Get(0).([]string)
1200 }
1201 }
1202 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1203 r1 = returnFunc(ctx)
1204 } else {
1205 r1 = ret.Error(1)
1206 }
1207 return r0, r1
1208}
1209
1210// MockContainerRuntime_ListImages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListImages'
1211type MockContainerRuntime_ListImages_Call struct {
1212 *mock.Call
1213}
1214
1215// ListImages is a helper method to define mock.On call
1216// - ctx context.Context
1217func (_e *MockContainerRuntime_Expecter) ListImages(ctx interface{}) *MockContainerRuntime_ListImages_Call {
1218 return &MockContainerRuntime_ListImages_Call{Call: _e.mock.On("ListImages", ctx)}
1219}
1220
1221func (_c *MockContainerRuntime_ListImages_Call) Run(run func(ctx context.Context)) *MockContainerRuntime_ListImages_Call {
1222 _c.Call.Run(func(args mock.Arguments) {
1223 var arg0 context.Context
1224 if args[0] != nil {
1225 arg0 = args[0].(context.Context)
1226 }
1227 run(
1228 arg0,
1229 )
1230 })
1231 return _c
1232}
1233
1234func (_c *MockContainerRuntime_ListImages_Call) Return(strings []string, err error) *MockContainerRuntime_ListImages_Call {
1235 _c.Call.Return(strings, err)
1236 return _c
1237}
1238
1239func (_c *MockContainerRuntime_ListImages_Call) RunAndReturn(run func(ctx context.Context) ([]string, error)) *MockContainerRuntime_ListImages_Call {
1240 _c.Call.Return(run)
1241 return _c
1242}
1243
1244// ListNetworks provides a mock function for the type MockContainerRuntime
1245func (_mock *MockContainerRuntime) ListNetworks(ctx context.Context) ([]*domain.NetworkInfo, error) {
1246 ret := _mock.Called(ctx)
1247
1248 if len(ret) == 0 {
1249 panic("no return value specified for ListNetworks")
1250 }
1251
1252 var r0 []*domain.NetworkInfo
1253 var r1 error
1254 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*domain.NetworkInfo, error)); ok {
1255 return returnFunc(ctx)
1256 }
1257 if returnFunc, ok := ret.Get(0).(func(context.Context) []*domain.NetworkInfo); ok {
1258 r0 = returnFunc(ctx)
1259 } else {
1260 if ret.Get(0) != nil {
1261 r0 = ret.Get(0).([]*domain.NetworkInfo)
1262 }
1263 }
1264 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1265 r1 = returnFunc(ctx)
1266 } else {
1267 r1 = ret.Error(1)
1268 }
1269 return r0, r1
1270}
1271
1272// MockContainerRuntime_ListNetworks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListNetworks'
1273type MockContainerRuntime_ListNetworks_Call struct {
1274 *mock.Call
1275}
1276
1277// ListNetworks is a helper method to define mock.On call
1278// - ctx context.Context
1279func (_e *MockContainerRuntime_Expecter) ListNetworks(ctx interface{}) *MockContainerRuntime_ListNetworks_Call {
1280 return &MockContainerRuntime_ListNetworks_Call{Call: _e.mock.On("ListNetworks", ctx)}
1281}
1282
1283func (_c *MockContainerRuntime_ListNetworks_Call) Run(run func(ctx context.Context)) *MockContainerRuntime_ListNetworks_Call {
1284 _c.Call.Run(func(args mock.Arguments) {
1285 var arg0 context.Context
1286 if args[0] != nil {
1287 arg0 = args[0].(context.Context)
1288 }
1289 run(
1290 arg0,
1291 )
1292 })
1293 return _c
1294}
1295
1296func (_c *MockContainerRuntime_ListNetworks_Call) Return(networkInfos []*domain.NetworkInfo, err error) *MockContainerRuntime_ListNetworks_Call {
1297 _c.Call.Return(networkInfos, err)
1298 return _c
1299}
1300
1301func (_c *MockContainerRuntime_ListNetworks_Call) RunAndReturn(run func(ctx context.Context) ([]*domain.NetworkInfo, error)) *MockContainerRuntime_ListNetworks_Call {
1302 _c.Call.Return(run)
1303 return _c
1304}
1305
1306// NetworkExists provides a mock function for the type MockContainerRuntime
1307func (_mock *MockContainerRuntime) NetworkExists(ctx context.Context, name string) (bool, error) {
1308 ret := _mock.Called(ctx, name)
1309
1310 if len(ret) == 0 {
1311 panic("no return value specified for NetworkExists")
1312 }
1313
1314 var r0 bool
1315 var r1 error
1316 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (bool, error)); ok {
1317 return returnFunc(ctx, name)
1318 }
1319 if returnFunc, ok := ret.Get(0).(func(context.Context, string) bool); ok {
1320 r0 = returnFunc(ctx, name)
1321 } else {
1322 r0 = ret.Get(0).(bool)
1323 }
1324 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
1325 r1 = returnFunc(ctx, name)
1326 } else {
1327 r1 = ret.Error(1)
1328 }
1329 return r0, r1
1330}
1331
1332// MockContainerRuntime_NetworkExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NetworkExists'
1333type MockContainerRuntime_NetworkExists_Call struct {
1334 *mock.Call
1335}
1336
1337// NetworkExists is a helper method to define mock.On call
1338// - ctx context.Context
1339// - name string
1340func (_e *MockContainerRuntime_Expecter) NetworkExists(ctx interface{}, name interface{}) *MockContainerRuntime_NetworkExists_Call {
1341 return &MockContainerRuntime_NetworkExists_Call{Call: _e.mock.On("NetworkExists", ctx, name)}
1342}
1343
1344func (_c *MockContainerRuntime_NetworkExists_Call) Run(run func(ctx context.Context, name string)) *MockContainerRuntime_NetworkExists_Call {
1345 _c.Call.Run(func(args mock.Arguments) {
1346 var arg0 context.Context
1347 if args[0] != nil {
1348 arg0 = args[0].(context.Context)
1349 }
1350 var arg1 string
1351 if args[1] != nil {
1352 arg1 = args[1].(string)
1353 }
1354 run(
1355 arg0,
1356 arg1,
1357 )
1358 })
1359 return _c
1360}
1361
1362func (_c *MockContainerRuntime_NetworkExists_Call) Return(b bool, err error) *MockContainerRuntime_NetworkExists_Call {
1363 _c.Call.Return(b, err)
1364 return _c
1365}
1366
1367func (_c *MockContainerRuntime_NetworkExists_Call) RunAndReturn(run func(ctx context.Context, name string) (bool, error)) *MockContainerRuntime_NetworkExists_Call {
1368 _c.Call.Return(run)
1369 return _c
1370}
1371
1372// Ping provides a mock function for the type MockContainerRuntime
1373func (_mock *MockContainerRuntime) Ping(ctx context.Context) error {
1374 ret := _mock.Called(ctx)
1375
1376 if len(ret) == 0 {
1377 panic("no return value specified for Ping")
1378 }
1379
1380 var r0 error
1381 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1382 r0 = returnFunc(ctx)
1383 } else {
1384 r0 = ret.Error(0)
1385 }
1386 return r0
1387}
1388
1389// MockContainerRuntime_Ping_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Ping'
1390type MockContainerRuntime_Ping_Call struct {
1391 *mock.Call
1392}
1393
1394// Ping is a helper method to define mock.On call
1395// - ctx context.Context
1396func (_e *MockContainerRuntime_Expecter) Ping(ctx interface{}) *MockContainerRuntime_Ping_Call {
1397 return &MockContainerRuntime_Ping_Call{Call: _e.mock.On("Ping", ctx)}
1398}
1399
1400func (_c *MockContainerRuntime_Ping_Call) Run(run func(ctx context.Context)) *MockContainerRuntime_Ping_Call {
1401 _c.Call.Run(func(args mock.Arguments) {
1402 var arg0 context.Context
1403 if args[0] != nil {
1404 arg0 = args[0].(context.Context)
1405 }
1406 run(
1407 arg0,
1408 )
1409 })
1410 return _c
1411}
1412
1413func (_c *MockContainerRuntime_Ping_Call) Return(err error) *MockContainerRuntime_Ping_Call {
1414 _c.Call.Return(err)
1415 return _c
1416}
1417
1418func (_c *MockContainerRuntime_Ping_Call) RunAndReturn(run func(ctx context.Context) error) *MockContainerRuntime_Ping_Call {
1419 _c.Call.Return(run)
1420 return _c
1421}
1422
1423// PullImage provides a mock function for the type MockContainerRuntime
1424func (_mock *MockContainerRuntime) PullImage(ctx context.Context, image string) error {
1425 ret := _mock.Called(ctx, image)
1426
1427 if len(ret) == 0 {
1428 panic("no return value specified for PullImage")
1429 }
1430
1431 var r0 error
1432 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
1433 r0 = returnFunc(ctx, image)
1434 } else {
1435 r0 = ret.Error(0)
1436 }
1437 return r0
1438}
1439
1440// MockContainerRuntime_PullImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PullImage'
1441type MockContainerRuntime_PullImage_Call struct {
1442 *mock.Call
1443}
1444
1445// PullImage is a helper method to define mock.On call
1446// - ctx context.Context
1447// - image string
1448func (_e *MockContainerRuntime_Expecter) PullImage(ctx interface{}, image interface{}) *MockContainerRuntime_PullImage_Call {
1449 return &MockContainerRuntime_PullImage_Call{Call: _e.mock.On("PullImage", ctx, image)}
1450}
1451
1452func (_c *MockContainerRuntime_PullImage_Call) Run(run func(ctx context.Context, image string)) *MockContainerRuntime_PullImage_Call {
1453 _c.Call.Run(func(args mock.Arguments) {
1454 var arg0 context.Context
1455 if args[0] != nil {
1456 arg0 = args[0].(context.Context)
1457 }
1458 var arg1 string
1459 if args[1] != nil {
1460 arg1 = args[1].(string)
1461 }
1462 run(
1463 arg0,
1464 arg1,
1465 )
1466 })
1467 return _c
1468}
1469
1470func (_c *MockContainerRuntime_PullImage_Call) Return(err error) *MockContainerRuntime_PullImage_Call {
1471 _c.Call.Return(err)
1472 return _c
1473}
1474
1475func (_c *MockContainerRuntime_PullImage_Call) RunAndReturn(run func(ctx context.Context, image string) error) *MockContainerRuntime_PullImage_Call {
1476 _c.Call.Return(run)
1477 return _c
1478}
1479
1480// PullImageWithAuth provides a mock function for the type MockContainerRuntime
1481func (_mock *MockContainerRuntime) PullImageWithAuth(ctx context.Context, image string, username string, password string) error {
1482 ret := _mock.Called(ctx, image, username, password)
1483
1484 if len(ret) == 0 {
1485 panic("no return value specified for PullImageWithAuth")
1486 }
1487
1488 var r0 error
1489 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
1490 r0 = returnFunc(ctx, image, username, password)
1491 } else {
1492 r0 = ret.Error(0)
1493 }
1494 return r0
1495}
1496
1497// MockContainerRuntime_PullImageWithAuth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PullImageWithAuth'
1498type MockContainerRuntime_PullImageWithAuth_Call struct {
1499 *mock.Call
1500}
1501
1502// PullImageWithAuth is a helper method to define mock.On call
1503// - ctx context.Context
1504// - image string
1505// - username string
1506// - password string
1507func (_e *MockContainerRuntime_Expecter) PullImageWithAuth(ctx interface{}, image interface{}, username interface{}, password interface{}) *MockContainerRuntime_PullImageWithAuth_Call {
1508 return &MockContainerRuntime_PullImageWithAuth_Call{Call: _e.mock.On("PullImageWithAuth", ctx, image, username, password)}
1509}
1510
1511func (_c *MockContainerRuntime_PullImageWithAuth_Call) Run(run func(ctx context.Context, image string, username string, password string)) *MockContainerRuntime_PullImageWithAuth_Call {
1512 _c.Call.Run(func(args mock.Arguments) {
1513 var arg0 context.Context
1514 if args[0] != nil {
1515 arg0 = args[0].(context.Context)
1516 }
1517 var arg1 string
1518 if args[1] != nil {
1519 arg1 = args[1].(string)
1520 }
1521 var arg2 string
1522 if args[2] != nil {
1523 arg2 = args[2].(string)
1524 }
1525 var arg3 string
1526 if args[3] != nil {
1527 arg3 = args[3].(string)
1528 }
1529 run(
1530 arg0,
1531 arg1,
1532 arg2,
1533 arg3,
1534 )
1535 })
1536 return _c
1537}
1538
1539func (_c *MockContainerRuntime_PullImageWithAuth_Call) Return(err error) *MockContainerRuntime_PullImageWithAuth_Call {
1540 _c.Call.Return(err)
1541 return _c
1542}
1543
1544func (_c *MockContainerRuntime_PullImageWithAuth_Call) RunAndReturn(run func(ctx context.Context, image string, username string, password string) error) *MockContainerRuntime_PullImageWithAuth_Call {
1545 _c.Call.Return(run)
1546 return _c
1547}
1548
1549// RemoveContainer provides a mock function for the type MockContainerRuntime
1550func (_mock *MockContainerRuntime) RemoveContainer(ctx context.Context, containerID string, force bool) error {
1551 ret := _mock.Called(ctx, containerID, force)
1552
1553 if len(ret) == 0 {
1554 panic("no return value specified for RemoveContainer")
1555 }
1556
1557 var r0 error
1558 if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) error); ok {
1559 r0 = returnFunc(ctx, containerID, force)
1560 } else {
1561 r0 = ret.Error(0)
1562 }
1563 return r0
1564}
1565
1566// MockContainerRuntime_RemoveContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveContainer'
1567type MockContainerRuntime_RemoveContainer_Call struct {
1568 *mock.Call
1569}
1570
1571// RemoveContainer is a helper method to define mock.On call
1572// - ctx context.Context
1573// - containerID string
1574// - force bool
1575func (_e *MockContainerRuntime_Expecter) RemoveContainer(ctx interface{}, containerID interface{}, force interface{}) *MockContainerRuntime_RemoveContainer_Call {
1576 return &MockContainerRuntime_RemoveContainer_Call{Call: _e.mock.On("RemoveContainer", ctx, containerID, force)}
1577}
1578
1579func (_c *MockContainerRuntime_RemoveContainer_Call) Run(run func(ctx context.Context, containerID string, force bool)) *MockContainerRuntime_RemoveContainer_Call {
1580 _c.Call.Run(func(args mock.Arguments) {
1581 var arg0 context.Context
1582 if args[0] != nil {
1583 arg0 = args[0].(context.Context)
1584 }
1585 var arg1 string
1586 if args[1] != nil {
1587 arg1 = args[1].(string)
1588 }
1589 var arg2 bool
1590 if args[2] != nil {
1591 arg2 = args[2].(bool)
1592 }
1593 run(
1594 arg0,
1595 arg1,
1596 arg2,
1597 )
1598 })
1599 return _c
1600}
1601
1602func (_c *MockContainerRuntime_RemoveContainer_Call) Return(err error) *MockContainerRuntime_RemoveContainer_Call {
1603 _c.Call.Return(err)
1604 return _c
1605}
1606
1607func (_c *MockContainerRuntime_RemoveContainer_Call) RunAndReturn(run func(ctx context.Context, containerID string, force bool) error) *MockContainerRuntime_RemoveContainer_Call {
1608 _c.Call.Return(run)
1609 return _c
1610}
1611
1612// RemoveImage provides a mock function for the type MockContainerRuntime
1613func (_mock *MockContainerRuntime) RemoveImage(ctx context.Context, image string, force bool) error {
1614 ret := _mock.Called(ctx, image, force)
1615
1616 if len(ret) == 0 {
1617 panic("no return value specified for RemoveImage")
1618 }
1619
1620 var r0 error
1621 if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) error); ok {
1622 r0 = returnFunc(ctx, image, force)
1623 } else {
1624 r0 = ret.Error(0)
1625 }
1626 return r0
1627}
1628
1629// MockContainerRuntime_RemoveImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveImage'
1630type MockContainerRuntime_RemoveImage_Call struct {
1631 *mock.Call
1632}
1633
1634// RemoveImage is a helper method to define mock.On call
1635// - ctx context.Context
1636// - image string
1637// - force bool
1638func (_e *MockContainerRuntime_Expecter) RemoveImage(ctx interface{}, image interface{}, force interface{}) *MockContainerRuntime_RemoveImage_Call {
1639 return &MockContainerRuntime_RemoveImage_Call{Call: _e.mock.On("RemoveImage", ctx, image, force)}
1640}
1641
1642func (_c *MockContainerRuntime_RemoveImage_Call) Run(run func(ctx context.Context, image string, force bool)) *MockContainerRuntime_RemoveImage_Call {
1643 _c.Call.Run(func(args mock.Arguments) {
1644 var arg0 context.Context
1645 if args[0] != nil {
1646 arg0 = args[0].(context.Context)
1647 }
1648 var arg1 string
1649 if args[1] != nil {
1650 arg1 = args[1].(string)
1651 }
1652 var arg2 bool
1653 if args[2] != nil {
1654 arg2 = args[2].(bool)
1655 }
1656 run(
1657 arg0,
1658 arg1,
1659 arg2,
1660 )
1661 })
1662 return _c
1663}
1664
1665func (_c *MockContainerRuntime_RemoveImage_Call) Return(err error) *MockContainerRuntime_RemoveImage_Call {
1666 _c.Call.Return(err)
1667 return _c
1668}
1669
1670func (_c *MockContainerRuntime_RemoveImage_Call) RunAndReturn(run func(ctx context.Context, image string, force bool) error) *MockContainerRuntime_RemoveImage_Call {
1671 _c.Call.Return(run)
1672 return _c
1673}
1674
1675// RemoveNetwork provides a mock function for the type MockContainerRuntime
1676func (_mock *MockContainerRuntime) RemoveNetwork(ctx context.Context, name string) error {
1677 ret := _mock.Called(ctx, name)
1678
1679 if len(ret) == 0 {
1680 panic("no return value specified for RemoveNetwork")
1681 }
1682
1683 var r0 error
1684 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
1685 r0 = returnFunc(ctx, name)
1686 } else {
1687 r0 = ret.Error(0)
1688 }
1689 return r0
1690}
1691
1692// MockContainerRuntime_RemoveNetwork_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveNetwork'
1693type MockContainerRuntime_RemoveNetwork_Call struct {
1694 *mock.Call
1695}
1696
1697// RemoveNetwork is a helper method to define mock.On call
1698// - ctx context.Context
1699// - name string
1700func (_e *MockContainerRuntime_Expecter) RemoveNetwork(ctx interface{}, name interface{}) *MockContainerRuntime_RemoveNetwork_Call {
1701 return &MockContainerRuntime_RemoveNetwork_Call{Call: _e.mock.On("RemoveNetwork", ctx, name)}
1702}
1703
1704func (_c *MockContainerRuntime_RemoveNetwork_Call) Run(run func(ctx context.Context, name string)) *MockContainerRuntime_RemoveNetwork_Call {
1705 _c.Call.Run(func(args mock.Arguments) {
1706 var arg0 context.Context
1707 if args[0] != nil {
1708 arg0 = args[0].(context.Context)
1709 }
1710 var arg1 string
1711 if args[1] != nil {
1712 arg1 = args[1].(string)
1713 }
1714 run(
1715 arg0,
1716 arg1,
1717 )
1718 })
1719 return _c
1720}
1721
1722func (_c *MockContainerRuntime_RemoveNetwork_Call) Return(err error) *MockContainerRuntime_RemoveNetwork_Call {
1723 _c.Call.Return(err)
1724 return _c
1725}
1726
1727func (_c *MockContainerRuntime_RemoveNetwork_Call) RunAndReturn(run func(ctx context.Context, name string) error) *MockContainerRuntime_RemoveNetwork_Call {
1728 _c.Call.Return(run)
1729 return _c
1730}
1731
1732// RemoveVolume provides a mock function for the type MockContainerRuntime
1733func (_mock *MockContainerRuntime) RemoveVolume(ctx context.Context, volumeName string, force bool) error {
1734 ret := _mock.Called(ctx, volumeName, force)
1735
1736 if len(ret) == 0 {
1737 panic("no return value specified for RemoveVolume")
1738 }
1739
1740 var r0 error
1741 if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) error); ok {
1742 r0 = returnFunc(ctx, volumeName, force)
1743 } else {
1744 r0 = ret.Error(0)
1745 }
1746 return r0
1747}
1748
1749// MockContainerRuntime_RemoveVolume_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveVolume'
1750type MockContainerRuntime_RemoveVolume_Call struct {
1751 *mock.Call
1752}
1753
1754// RemoveVolume is a helper method to define mock.On call
1755// - ctx context.Context
1756// - volumeName string
1757// - force bool
1758func (_e *MockContainerRuntime_Expecter) RemoveVolume(ctx interface{}, volumeName interface{}, force interface{}) *MockContainerRuntime_RemoveVolume_Call {
1759 return &MockContainerRuntime_RemoveVolume_Call{Call: _e.mock.On("RemoveVolume", ctx, volumeName, force)}
1760}
1761
1762func (_c *MockContainerRuntime_RemoveVolume_Call) Run(run func(ctx context.Context, volumeName string, force bool)) *MockContainerRuntime_RemoveVolume_Call {
1763 _c.Call.Run(func(args mock.Arguments) {
1764 var arg0 context.Context
1765 if args[0] != nil {
1766 arg0 = args[0].(context.Context)
1767 }
1768 var arg1 string
1769 if args[1] != nil {
1770 arg1 = args[1].(string)
1771 }
1772 var arg2 bool
1773 if args[2] != nil {
1774 arg2 = args[2].(bool)
1775 }
1776 run(
1777 arg0,
1778 arg1,
1779 arg2,
1780 )
1781 })
1782 return _c
1783}
1784
1785func (_c *MockContainerRuntime_RemoveVolume_Call) Return(err error) *MockContainerRuntime_RemoveVolume_Call {
1786 _c.Call.Return(err)
1787 return _c
1788}
1789
1790func (_c *MockContainerRuntime_RemoveVolume_Call) RunAndReturn(run func(ctx context.Context, volumeName string, force bool) error) *MockContainerRuntime_RemoveVolume_Call {
1791 _c.Call.Return(run)
1792 return _c
1793}
1794
1795// RenameContainer provides a mock function for the type MockContainerRuntime
1796func (_mock *MockContainerRuntime) RenameContainer(ctx context.Context, containerID string, newName string) error {
1797 ret := _mock.Called(ctx, containerID, newName)
1798
1799 if len(ret) == 0 {
1800 panic("no return value specified for RenameContainer")
1801 }
1802
1803 var r0 error
1804 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
1805 r0 = returnFunc(ctx, containerID, newName)
1806 } else {
1807 r0 = ret.Error(0)
1808 }
1809 return r0
1810}
1811
1812// MockContainerRuntime_RenameContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenameContainer'
1813type MockContainerRuntime_RenameContainer_Call struct {
1814 *mock.Call
1815}
1816
1817// RenameContainer is a helper method to define mock.On call
1818// - ctx context.Context
1819// - containerID string
1820// - newName string
1821func (_e *MockContainerRuntime_Expecter) RenameContainer(ctx interface{}, containerID interface{}, newName interface{}) *MockContainerRuntime_RenameContainer_Call {
1822 return &MockContainerRuntime_RenameContainer_Call{Call: _e.mock.On("RenameContainer", ctx, containerID, newName)}
1823}
1824
1825func (_c *MockContainerRuntime_RenameContainer_Call) Run(run func(ctx context.Context, containerID string, newName string)) *MockContainerRuntime_RenameContainer_Call {
1826 _c.Call.Run(func(args mock.Arguments) {
1827 var arg0 context.Context
1828 if args[0] != nil {
1829 arg0 = args[0].(context.Context)
1830 }
1831 var arg1 string
1832 if args[1] != nil {
1833 arg1 = args[1].(string)
1834 }
1835 var arg2 string
1836 if args[2] != nil {
1837 arg2 = args[2].(string)
1838 }
1839 run(
1840 arg0,
1841 arg1,
1842 arg2,
1843 )
1844 })
1845 return _c
1846}
1847
1848func (_c *MockContainerRuntime_RenameContainer_Call) Return(err error) *MockContainerRuntime_RenameContainer_Call {
1849 _c.Call.Return(err)
1850 return _c
1851}
1852
1853func (_c *MockContainerRuntime_RenameContainer_Call) RunAndReturn(run func(ctx context.Context, containerID string, newName string) error) *MockContainerRuntime_RenameContainer_Call {
1854 _c.Call.Return(run)
1855 return _c
1856}
1857
1858// RestartContainer provides a mock function for the type MockContainerRuntime
1859func (_mock *MockContainerRuntime) RestartContainer(ctx context.Context, containerID string) error {
1860 ret := _mock.Called(ctx, containerID)
1861
1862 if len(ret) == 0 {
1863 panic("no return value specified for RestartContainer")
1864 }
1865
1866 var r0 error
1867 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
1868 r0 = returnFunc(ctx, containerID)
1869 } else {
1870 r0 = ret.Error(0)
1871 }
1872 return r0
1873}
1874
1875// MockContainerRuntime_RestartContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestartContainer'
1876type MockContainerRuntime_RestartContainer_Call struct {
1877 *mock.Call
1878}
1879
1880// RestartContainer is a helper method to define mock.On call
1881// - ctx context.Context
1882// - containerID string
1883func (_e *MockContainerRuntime_Expecter) RestartContainer(ctx interface{}, containerID interface{}) *MockContainerRuntime_RestartContainer_Call {
1884 return &MockContainerRuntime_RestartContainer_Call{Call: _e.mock.On("RestartContainer", ctx, containerID)}
1885}
1886
1887func (_c *MockContainerRuntime_RestartContainer_Call) Run(run func(ctx context.Context, containerID string)) *MockContainerRuntime_RestartContainer_Call {
1888 _c.Call.Run(func(args mock.Arguments) {
1889 var arg0 context.Context
1890 if args[0] != nil {
1891 arg0 = args[0].(context.Context)
1892 }
1893 var arg1 string
1894 if args[1] != nil {
1895 arg1 = args[1].(string)
1896 }
1897 run(
1898 arg0,
1899 arg1,
1900 )
1901 })
1902 return _c
1903}
1904
1905func (_c *MockContainerRuntime_RestartContainer_Call) Return(err error) *MockContainerRuntime_RestartContainer_Call {
1906 _c.Call.Return(err)
1907 return _c
1908}
1909
1910func (_c *MockContainerRuntime_RestartContainer_Call) RunAndReturn(run func(ctx context.Context, containerID string) error) *MockContainerRuntime_RestartContainer_Call {
1911 _c.Call.Return(run)
1912 return _c
1913}
1914
1915// StartContainer provides a mock function for the type MockContainerRuntime
1916func (_mock *MockContainerRuntime) StartContainer(ctx context.Context, containerID string) error {
1917 ret := _mock.Called(ctx, containerID)
1918
1919 if len(ret) == 0 {
1920 panic("no return value specified for StartContainer")
1921 }
1922
1923 var r0 error
1924 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
1925 r0 = returnFunc(ctx, containerID)
1926 } else {
1927 r0 = ret.Error(0)
1928 }
1929 return r0
1930}
1931
1932// MockContainerRuntime_StartContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartContainer'
1933type MockContainerRuntime_StartContainer_Call struct {
1934 *mock.Call
1935}
1936
1937// StartContainer is a helper method to define mock.On call
1938// - ctx context.Context
1939// - containerID string
1940func (_e *MockContainerRuntime_Expecter) StartContainer(ctx interface{}, containerID interface{}) *MockContainerRuntime_StartContainer_Call {
1941 return &MockContainerRuntime_StartContainer_Call{Call: _e.mock.On("StartContainer", ctx, containerID)}
1942}
1943
1944func (_c *MockContainerRuntime_StartContainer_Call) Run(run func(ctx context.Context, containerID string)) *MockContainerRuntime_StartContainer_Call {
1945 _c.Call.Run(func(args mock.Arguments) {
1946 var arg0 context.Context
1947 if args[0] != nil {
1948 arg0 = args[0].(context.Context)
1949 }
1950 var arg1 string
1951 if args[1] != nil {
1952 arg1 = args[1].(string)
1953 }
1954 run(
1955 arg0,
1956 arg1,
1957 )
1958 })
1959 return _c
1960}
1961
1962func (_c *MockContainerRuntime_StartContainer_Call) Return(err error) *MockContainerRuntime_StartContainer_Call {
1963 _c.Call.Return(err)
1964 return _c
1965}
1966
1967func (_c *MockContainerRuntime_StartContainer_Call) RunAndReturn(run func(ctx context.Context, containerID string) error) *MockContainerRuntime_StartContainer_Call {
1968 _c.Call.Return(run)
1969 return _c
1970}
1971
1972// StopContainer provides a mock function for the type MockContainerRuntime
1973func (_mock *MockContainerRuntime) StopContainer(ctx context.Context, containerID string) error {
1974 ret := _mock.Called(ctx, containerID)
1975
1976 if len(ret) == 0 {
1977 panic("no return value specified for StopContainer")
1978 }
1979
1980 var r0 error
1981 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
1982 r0 = returnFunc(ctx, containerID)
1983 } else {
1984 r0 = ret.Error(0)
1985 }
1986 return r0
1987}
1988
1989// MockContainerRuntime_StopContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StopContainer'
1990type MockContainerRuntime_StopContainer_Call struct {
1991 *mock.Call
1992}
1993
1994// StopContainer is a helper method to define mock.On call
1995// - ctx context.Context
1996// - containerID string
1997func (_e *MockContainerRuntime_Expecter) StopContainer(ctx interface{}, containerID interface{}) *MockContainerRuntime_StopContainer_Call {
1998 return &MockContainerRuntime_StopContainer_Call{Call: _e.mock.On("StopContainer", ctx, containerID)}
1999}
2000
2001func (_c *MockContainerRuntime_StopContainer_Call) Run(run func(ctx context.Context, containerID string)) *MockContainerRuntime_StopContainer_Call {
2002 _c.Call.Run(func(args mock.Arguments) {
2003 var arg0 context.Context
2004 if args[0] != nil {
2005 arg0 = args[0].(context.Context)
2006 }
2007 var arg1 string
2008 if args[1] != nil {
2009 arg1 = args[1].(string)
2010 }
2011 run(
2012 arg0,
2013 arg1,
2014 )
2015 })
2016 return _c
2017}
2018
2019func (_c *MockContainerRuntime_StopContainer_Call) Return(err error) *MockContainerRuntime_StopContainer_Call {
2020 _c.Call.Return(err)
2021 return _c
2022}
2023
2024func (_c *MockContainerRuntime_StopContainer_Call) RunAndReturn(run func(ctx context.Context, containerID string) error) *MockContainerRuntime_StopContainer_Call {
2025 _c.Call.Return(run)
2026 return _c
2027}
2028
2029// TagImage provides a mock function for the type MockContainerRuntime
2030func (_mock *MockContainerRuntime) TagImage(ctx context.Context, sourceRef string, targetRef string) error {
2031 ret := _mock.Called(ctx, sourceRef, targetRef)
2032
2033 if len(ret) == 0 {
2034 panic("no return value specified for TagImage")
2035 }
2036
2037 var r0 error
2038 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
2039 r0 = returnFunc(ctx, sourceRef, targetRef)
2040 } else {
2041 r0 = ret.Error(0)
2042 }
2043 return r0
2044}
2045
2046// MockContainerRuntime_TagImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TagImage'
2047type MockContainerRuntime_TagImage_Call struct {
2048 *mock.Call
2049}
2050
2051// TagImage is a helper method to define mock.On call
2052// - ctx context.Context
2053// - sourceRef string
2054// - targetRef string
2055func (_e *MockContainerRuntime_Expecter) TagImage(ctx interface{}, sourceRef interface{}, targetRef interface{}) *MockContainerRuntime_TagImage_Call {
2056 return &MockContainerRuntime_TagImage_Call{Call: _e.mock.On("TagImage", ctx, sourceRef, targetRef)}
2057}
2058
2059func (_c *MockContainerRuntime_TagImage_Call) Run(run func(ctx context.Context, sourceRef string, targetRef string)) *MockContainerRuntime_TagImage_Call {
2060 _c.Call.Run(func(args mock.Arguments) {
2061 var arg0 context.Context
2062 if args[0] != nil {
2063 arg0 = args[0].(context.Context)
2064 }
2065 var arg1 string
2066 if args[1] != nil {
2067 arg1 = args[1].(string)
2068 }
2069 var arg2 string
2070 if args[2] != nil {
2071 arg2 = args[2].(string)
2072 }
2073 run(
2074 arg0,
2075 arg1,
2076 arg2,
2077 )
2078 })
2079 return _c
2080}
2081
2082func (_c *MockContainerRuntime_TagImage_Call) Return(err error) *MockContainerRuntime_TagImage_Call {
2083 _c.Call.Return(err)
2084 return _c
2085}
2086
2087func (_c *MockContainerRuntime_TagImage_Call) RunAndReturn(run func(ctx context.Context, sourceRef string, targetRef string) error) *MockContainerRuntime_TagImage_Call {
2088 _c.Call.Return(run)
2089 return _c
2090}
2091
2092// UntagImage provides a mock function for the type MockContainerRuntime
2093func (_mock *MockContainerRuntime) UntagImage(ctx context.Context, imageRef string) error {
2094 ret := _mock.Called(ctx, imageRef)
2095
2096 if len(ret) == 0 {
2097 panic("no return value specified for UntagImage")
2098 }
2099
2100 var r0 error
2101 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
2102 r0 = returnFunc(ctx, imageRef)
2103 } else {
2104 r0 = ret.Error(0)
2105 }
2106 return r0
2107}
2108
2109// MockContainerRuntime_UntagImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UntagImage'
2110type MockContainerRuntime_UntagImage_Call struct {
2111 *mock.Call
2112}
2113
2114// UntagImage is a helper method to define mock.On call
2115// - ctx context.Context
2116// - imageRef string
2117func (_e *MockContainerRuntime_Expecter) UntagImage(ctx interface{}, imageRef interface{}) *MockContainerRuntime_UntagImage_Call {
2118 return &MockContainerRuntime_UntagImage_Call{Call: _e.mock.On("UntagImage", ctx, imageRef)}
2119}
2120
2121func (_c *MockContainerRuntime_UntagImage_Call) Run(run func(ctx context.Context, imageRef string)) *MockContainerRuntime_UntagImage_Call {
2122 _c.Call.Run(func(args mock.Arguments) {
2123 var arg0 context.Context
2124 if args[0] != nil {
2125 arg0 = args[0].(context.Context)
2126 }
2127 var arg1 string
2128 if args[1] != nil {
2129 arg1 = args[1].(string)
2130 }
2131 run(
2132 arg0,
2133 arg1,
2134 )
2135 })
2136 return _c
2137}
2138
2139func (_c *MockContainerRuntime_UntagImage_Call) Return(err error) *MockContainerRuntime_UntagImage_Call {
2140 _c.Call.Return(err)
2141 return _c
2142}
2143
2144func (_c *MockContainerRuntime_UntagImage_Call) RunAndReturn(run func(ctx context.Context, imageRef string) error) *MockContainerRuntime_UntagImage_Call {
2145 _c.Call.Return(run)
2146 return _c
2147}
2148
2149// Version provides a mock function for the type MockContainerRuntime
2150func (_mock *MockContainerRuntime) Version(ctx context.Context) (string, error) {
2151 ret := _mock.Called(ctx)
2152
2153 if len(ret) == 0 {
2154 panic("no return value specified for Version")
2155 }
2156
2157 var r0 string
2158 var r1 error
2159 if returnFunc, ok := ret.Get(0).(func(context.Context) (string, error)); ok {
2160 return returnFunc(ctx)
2161 }
2162 if returnFunc, ok := ret.Get(0).(func(context.Context) string); ok {
2163 r0 = returnFunc(ctx)
2164 } else {
2165 r0 = ret.Get(0).(string)
2166 }
2167 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
2168 r1 = returnFunc(ctx)
2169 } else {
2170 r1 = ret.Error(1)
2171 }
2172 return r0, r1
2173}
2174
2175// MockContainerRuntime_Version_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Version'
2176type MockContainerRuntime_Version_Call struct {
2177 *mock.Call
2178}
2179
2180// Version is a helper method to define mock.On call
2181// - ctx context.Context
2182func (_e *MockContainerRuntime_Expecter) Version(ctx interface{}) *MockContainerRuntime_Version_Call {
2183 return &MockContainerRuntime_Version_Call{Call: _e.mock.On("Version", ctx)}
2184}
2185
2186func (_c *MockContainerRuntime_Version_Call) Run(run func(ctx context.Context)) *MockContainerRuntime_Version_Call {
2187 _c.Call.Run(func(args mock.Arguments) {
2188 var arg0 context.Context
2189 if args[0] != nil {
2190 arg0 = args[0].(context.Context)
2191 }
2192 run(
2193 arg0,
2194 )
2195 })
2196 return _c
2197}
2198
2199func (_c *MockContainerRuntime_Version_Call) Return(s string, err error) *MockContainerRuntime_Version_Call {
2200 _c.Call.Return(s, err)
2201 return _c
2202}
2203
2204func (_c *MockContainerRuntime_Version_Call) RunAndReturn(run func(ctx context.Context) (string, error)) *MockContainerRuntime_Version_Call {
2205 _c.Call.Return(run)
2206 return _c
2207}
2208
2209// VolumeExists provides a mock function for the type MockContainerRuntime
2210func (_mock *MockContainerRuntime) VolumeExists(ctx context.Context, volumeName string) (bool, error) {
2211 ret := _mock.Called(ctx, volumeName)
2212
2213 if len(ret) == 0 {
2214 panic("no return value specified for VolumeExists")
2215 }
2216
2217 var r0 bool
2218 var r1 error
2219 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (bool, error)); ok {
2220 return returnFunc(ctx, volumeName)
2221 }
2222 if returnFunc, ok := ret.Get(0).(func(context.Context, string) bool); ok {
2223 r0 = returnFunc(ctx, volumeName)
2224 } else {
2225 r0 = ret.Get(0).(bool)
2226 }
2227 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
2228 r1 = returnFunc(ctx, volumeName)
2229 } else {
2230 r1 = ret.Error(1)
2231 }
2232 return r0, r1
2233}
2234
2235// MockContainerRuntime_VolumeExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VolumeExists'
2236type MockContainerRuntime_VolumeExists_Call struct {
2237 *mock.Call
2238}
2239
2240// VolumeExists is a helper method to define mock.On call
2241// - ctx context.Context
2242// - volumeName string
2243func (_e *MockContainerRuntime_Expecter) VolumeExists(ctx interface{}, volumeName interface{}) *MockContainerRuntime_VolumeExists_Call {
2244 return &MockContainerRuntime_VolumeExists_Call{Call: _e.mock.On("VolumeExists", ctx, volumeName)}
2245}
2246
2247func (_c *MockContainerRuntime_VolumeExists_Call) Run(run func(ctx context.Context, volumeName string)) *MockContainerRuntime_VolumeExists_Call {
2248 _c.Call.Run(func(args mock.Arguments) {
2249 var arg0 context.Context
2250 if args[0] != nil {
2251 arg0 = args[0].(context.Context)
2252 }
2253 var arg1 string
2254 if args[1] != nil {
2255 arg1 = args[1].(string)
2256 }
2257 run(
2258 arg0,
2259 arg1,
2260 )
2261 })
2262 return _c
2263}
2264
2265func (_c *MockContainerRuntime_VolumeExists_Call) Return(b bool, err error) *MockContainerRuntime_VolumeExists_Call {
2266 _c.Call.Return(b, err)
2267 return _c
2268}
2269
2270func (_c *MockContainerRuntime_VolumeExists_Call) RunAndReturn(run func(ctx context.Context, volumeName string) (bool, error)) *MockContainerRuntime_VolumeExists_Call {
2271 _c.Call.Return(run)
2272 return _c
2273}