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