mock_container_runtime.go RawHistoryFolder

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// 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}