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, config domain.NetworkConfig) error {
250	ret := _mock.Called(ctx, name, config)
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, domain.NetworkConfig) error); ok {
258		r0 = returnFunc(ctx, name, config)
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//   - config domain.NetworkConfig
274func (_e *MockContainerRuntime_Expecter) CreateNetwork(ctx interface{}, name interface{}, config interface{}) *MockContainerRuntime_CreateNetwork_Call {
275	return &MockContainerRuntime_CreateNetwork_Call{Call: _e.mock.On("CreateNetwork", ctx, name, config)}
276}
277
278func (_c *MockContainerRuntime_CreateNetwork_Call) Run(run func(ctx context.Context, name string, config domain.NetworkConfig)) *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 domain.NetworkConfig
289		if args[2] != nil {
290			arg2 = args[2].(domain.NetworkConfig)
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, config domain.NetworkConfig) 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// ListVolumes provides a mock function for the type MockContainerRuntime
1594func (_mock *MockContainerRuntime) ListVolumes(ctx context.Context) ([]*domain.VolumeInfo, error) {
1595	ret := _mock.Called(ctx)
1596
1597	if len(ret) == 0 {
1598		panic("no return value specified for ListVolumes")
1599	}
1600
1601	var r0 []*domain.VolumeInfo
1602	var r1 error
1603	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*domain.VolumeInfo, error)); ok {
1604		return returnFunc(ctx)
1605	}
1606	if returnFunc, ok := ret.Get(0).(func(context.Context) []*domain.VolumeInfo); ok {
1607		r0 = returnFunc(ctx)
1608	} else {
1609		if ret.Get(0) != nil {
1610			r0 = ret.Get(0).([]*domain.VolumeInfo)
1611		}
1612	}
1613	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1614		r1 = returnFunc(ctx)
1615	} else {
1616		r1 = ret.Error(1)
1617	}
1618	return r0, r1
1619}
1620
1621// MockContainerRuntime_ListVolumes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVolumes'
1622type MockContainerRuntime_ListVolumes_Call struct {
1623	*mock.Call
1624}
1625
1626// ListVolumes is a helper method to define mock.On call
1627//   - ctx context.Context
1628func (_e *MockContainerRuntime_Expecter) ListVolumes(ctx interface{}) *MockContainerRuntime_ListVolumes_Call {
1629	return &MockContainerRuntime_ListVolumes_Call{Call: _e.mock.On("ListVolumes", ctx)}
1630}
1631
1632func (_c *MockContainerRuntime_ListVolumes_Call) Run(run func(ctx context.Context)) *MockContainerRuntime_ListVolumes_Call {
1633	_c.Call.Run(func(args mock.Arguments) {
1634		var arg0 context.Context
1635		if args[0] != nil {
1636			arg0 = args[0].(context.Context)
1637		}
1638		run(
1639			arg0,
1640		)
1641	})
1642	return _c
1643}
1644
1645func (_c *MockContainerRuntime_ListVolumes_Call) Return(volumeInfos []*domain.VolumeInfo, err error) *MockContainerRuntime_ListVolumes_Call {
1646	_c.Call.Return(volumeInfos, err)
1647	return _c
1648}
1649
1650func (_c *MockContainerRuntime_ListVolumes_Call) RunAndReturn(run func(ctx context.Context) ([]*domain.VolumeInfo, error)) *MockContainerRuntime_ListVolumes_Call {
1651	_c.Call.Return(run)
1652	return _c
1653}
1654
1655// NetworkExists provides a mock function for the type MockContainerRuntime
1656func (_mock *MockContainerRuntime) NetworkExists(ctx context.Context, name string) (bool, error) {
1657	ret := _mock.Called(ctx, name)
1658
1659	if len(ret) == 0 {
1660		panic("no return value specified for NetworkExists")
1661	}
1662
1663	var r0 bool
1664	var r1 error
1665	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (bool, error)); ok {
1666		return returnFunc(ctx, name)
1667	}
1668	if returnFunc, ok := ret.Get(0).(func(context.Context, string) bool); ok {
1669		r0 = returnFunc(ctx, name)
1670	} else {
1671		r0 = ret.Get(0).(bool)
1672	}
1673	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
1674		r1 = returnFunc(ctx, name)
1675	} else {
1676		r1 = ret.Error(1)
1677	}
1678	return r0, r1
1679}
1680
1681// MockContainerRuntime_NetworkExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NetworkExists'
1682type MockContainerRuntime_NetworkExists_Call struct {
1683	*mock.Call
1684}
1685
1686// NetworkExists is a helper method to define mock.On call
1687//   - ctx context.Context
1688//   - name string
1689func (_e *MockContainerRuntime_Expecter) NetworkExists(ctx interface{}, name interface{}) *MockContainerRuntime_NetworkExists_Call {
1690	return &MockContainerRuntime_NetworkExists_Call{Call: _e.mock.On("NetworkExists", ctx, name)}
1691}
1692
1693func (_c *MockContainerRuntime_NetworkExists_Call) Run(run func(ctx context.Context, name string)) *MockContainerRuntime_NetworkExists_Call {
1694	_c.Call.Run(func(args mock.Arguments) {
1695		var arg0 context.Context
1696		if args[0] != nil {
1697			arg0 = args[0].(context.Context)
1698		}
1699		var arg1 string
1700		if args[1] != nil {
1701			arg1 = args[1].(string)
1702		}
1703		run(
1704			arg0,
1705			arg1,
1706		)
1707	})
1708	return _c
1709}
1710
1711func (_c *MockContainerRuntime_NetworkExists_Call) Return(b bool, err error) *MockContainerRuntime_NetworkExists_Call {
1712	_c.Call.Return(b, err)
1713	return _c
1714}
1715
1716func (_c *MockContainerRuntime_NetworkExists_Call) RunAndReturn(run func(ctx context.Context, name string) (bool, error)) *MockContainerRuntime_NetworkExists_Call {
1717	_c.Call.Return(run)
1718	return _c
1719}
1720
1721// Ping provides a mock function for the type MockContainerRuntime
1722func (_mock *MockContainerRuntime) Ping(ctx context.Context) error {
1723	ret := _mock.Called(ctx)
1724
1725	if len(ret) == 0 {
1726		panic("no return value specified for Ping")
1727	}
1728
1729	var r0 error
1730	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1731		r0 = returnFunc(ctx)
1732	} else {
1733		r0 = ret.Error(0)
1734	}
1735	return r0
1736}
1737
1738// MockContainerRuntime_Ping_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Ping'
1739type MockContainerRuntime_Ping_Call struct {
1740	*mock.Call
1741}
1742
1743// Ping is a helper method to define mock.On call
1744//   - ctx context.Context
1745func (_e *MockContainerRuntime_Expecter) Ping(ctx interface{}) *MockContainerRuntime_Ping_Call {
1746	return &MockContainerRuntime_Ping_Call{Call: _e.mock.On("Ping", ctx)}
1747}
1748
1749func (_c *MockContainerRuntime_Ping_Call) Run(run func(ctx context.Context)) *MockContainerRuntime_Ping_Call {
1750	_c.Call.Run(func(args mock.Arguments) {
1751		var arg0 context.Context
1752		if args[0] != nil {
1753			arg0 = args[0].(context.Context)
1754		}
1755		run(
1756			arg0,
1757		)
1758	})
1759	return _c
1760}
1761
1762func (_c *MockContainerRuntime_Ping_Call) Return(err error) *MockContainerRuntime_Ping_Call {
1763	_c.Call.Return(err)
1764	return _c
1765}
1766
1767func (_c *MockContainerRuntime_Ping_Call) RunAndReturn(run func(ctx context.Context) error) *MockContainerRuntime_Ping_Call {
1768	_c.Call.Return(run)
1769	return _c
1770}
1771
1772// PullImage provides a mock function for the type MockContainerRuntime
1773func (_mock *MockContainerRuntime) PullImage(ctx context.Context, image string) error {
1774	ret := _mock.Called(ctx, image)
1775
1776	if len(ret) == 0 {
1777		panic("no return value specified for PullImage")
1778	}
1779
1780	var r0 error
1781	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
1782		r0 = returnFunc(ctx, image)
1783	} else {
1784		r0 = ret.Error(0)
1785	}
1786	return r0
1787}
1788
1789// MockContainerRuntime_PullImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PullImage'
1790type MockContainerRuntime_PullImage_Call struct {
1791	*mock.Call
1792}
1793
1794// PullImage is a helper method to define mock.On call
1795//   - ctx context.Context
1796//   - image string
1797func (_e *MockContainerRuntime_Expecter) PullImage(ctx interface{}, image interface{}) *MockContainerRuntime_PullImage_Call {
1798	return &MockContainerRuntime_PullImage_Call{Call: _e.mock.On("PullImage", ctx, image)}
1799}
1800
1801func (_c *MockContainerRuntime_PullImage_Call) Run(run func(ctx context.Context, image string)) *MockContainerRuntime_PullImage_Call {
1802	_c.Call.Run(func(args mock.Arguments) {
1803		var arg0 context.Context
1804		if args[0] != nil {
1805			arg0 = args[0].(context.Context)
1806		}
1807		var arg1 string
1808		if args[1] != nil {
1809			arg1 = args[1].(string)
1810		}
1811		run(
1812			arg0,
1813			arg1,
1814		)
1815	})
1816	return _c
1817}
1818
1819func (_c *MockContainerRuntime_PullImage_Call) Return(err error) *MockContainerRuntime_PullImage_Call {
1820	_c.Call.Return(err)
1821	return _c
1822}
1823
1824func (_c *MockContainerRuntime_PullImage_Call) RunAndReturn(run func(ctx context.Context, image string) error) *MockContainerRuntime_PullImage_Call {
1825	_c.Call.Return(run)
1826	return _c
1827}
1828
1829// PullImageWithAuth provides a mock function for the type MockContainerRuntime
1830func (_mock *MockContainerRuntime) PullImageWithAuth(ctx context.Context, image string, username string, password string) error {
1831	ret := _mock.Called(ctx, image, username, password)
1832
1833	if len(ret) == 0 {
1834		panic("no return value specified for PullImageWithAuth")
1835	}
1836
1837	var r0 error
1838	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
1839		r0 = returnFunc(ctx, image, username, password)
1840	} else {
1841		r0 = ret.Error(0)
1842	}
1843	return r0
1844}
1845
1846// MockContainerRuntime_PullImageWithAuth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PullImageWithAuth'
1847type MockContainerRuntime_PullImageWithAuth_Call struct {
1848	*mock.Call
1849}
1850
1851// PullImageWithAuth is a helper method to define mock.On call
1852//   - ctx context.Context
1853//   - image string
1854//   - username string
1855//   - password string
1856func (_e *MockContainerRuntime_Expecter) PullImageWithAuth(ctx interface{}, image interface{}, username interface{}, password interface{}) *MockContainerRuntime_PullImageWithAuth_Call {
1857	return &MockContainerRuntime_PullImageWithAuth_Call{Call: _e.mock.On("PullImageWithAuth", ctx, image, username, password)}
1858}
1859
1860func (_c *MockContainerRuntime_PullImageWithAuth_Call) Run(run func(ctx context.Context, image string, username string, password string)) *MockContainerRuntime_PullImageWithAuth_Call {
1861	_c.Call.Run(func(args mock.Arguments) {
1862		var arg0 context.Context
1863		if args[0] != nil {
1864			arg0 = args[0].(context.Context)
1865		}
1866		var arg1 string
1867		if args[1] != nil {
1868			arg1 = args[1].(string)
1869		}
1870		var arg2 string
1871		if args[2] != nil {
1872			arg2 = args[2].(string)
1873		}
1874		var arg3 string
1875		if args[3] != nil {
1876			arg3 = args[3].(string)
1877		}
1878		run(
1879			arg0,
1880			arg1,
1881			arg2,
1882			arg3,
1883		)
1884	})
1885	return _c
1886}
1887
1888func (_c *MockContainerRuntime_PullImageWithAuth_Call) Return(err error) *MockContainerRuntime_PullImageWithAuth_Call {
1889	_c.Call.Return(err)
1890	return _c
1891}
1892
1893func (_c *MockContainerRuntime_PullImageWithAuth_Call) RunAndReturn(run func(ctx context.Context, image string, username string, password string) error) *MockContainerRuntime_PullImageWithAuth_Call {
1894	_c.Call.Return(run)
1895	return _c
1896}
1897
1898// RemoveContainer provides a mock function for the type MockContainerRuntime
1899func (_mock *MockContainerRuntime) RemoveContainer(ctx context.Context, containerID string, force bool) error {
1900	ret := _mock.Called(ctx, containerID, force)
1901
1902	if len(ret) == 0 {
1903		panic("no return value specified for RemoveContainer")
1904	}
1905
1906	var r0 error
1907	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) error); ok {
1908		r0 = returnFunc(ctx, containerID, force)
1909	} else {
1910		r0 = ret.Error(0)
1911	}
1912	return r0
1913}
1914
1915// MockContainerRuntime_RemoveContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveContainer'
1916type MockContainerRuntime_RemoveContainer_Call struct {
1917	*mock.Call
1918}
1919
1920// RemoveContainer is a helper method to define mock.On call
1921//   - ctx context.Context
1922//   - containerID string
1923//   - force bool
1924func (_e *MockContainerRuntime_Expecter) RemoveContainer(ctx interface{}, containerID interface{}, force interface{}) *MockContainerRuntime_RemoveContainer_Call {
1925	return &MockContainerRuntime_RemoveContainer_Call{Call: _e.mock.On("RemoveContainer", ctx, containerID, force)}
1926}
1927
1928func (_c *MockContainerRuntime_RemoveContainer_Call) Run(run func(ctx context.Context, containerID string, force bool)) *MockContainerRuntime_RemoveContainer_Call {
1929	_c.Call.Run(func(args mock.Arguments) {
1930		var arg0 context.Context
1931		if args[0] != nil {
1932			arg0 = args[0].(context.Context)
1933		}
1934		var arg1 string
1935		if args[1] != nil {
1936			arg1 = args[1].(string)
1937		}
1938		var arg2 bool
1939		if args[2] != nil {
1940			arg2 = args[2].(bool)
1941		}
1942		run(
1943			arg0,
1944			arg1,
1945			arg2,
1946		)
1947	})
1948	return _c
1949}
1950
1951func (_c *MockContainerRuntime_RemoveContainer_Call) Return(err error) *MockContainerRuntime_RemoveContainer_Call {
1952	_c.Call.Return(err)
1953	return _c
1954}
1955
1956func (_c *MockContainerRuntime_RemoveContainer_Call) RunAndReturn(run func(ctx context.Context, containerID string, force bool) error) *MockContainerRuntime_RemoveContainer_Call {
1957	_c.Call.Return(run)
1958	return _c
1959}
1960
1961// RemoveImage provides a mock function for the type MockContainerRuntime
1962func (_mock *MockContainerRuntime) RemoveImage(ctx context.Context, image string, force bool) error {
1963	ret := _mock.Called(ctx, image, force)
1964
1965	if len(ret) == 0 {
1966		panic("no return value specified for RemoveImage")
1967	}
1968
1969	var r0 error
1970	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) error); ok {
1971		r0 = returnFunc(ctx, image, force)
1972	} else {
1973		r0 = ret.Error(0)
1974	}
1975	return r0
1976}
1977
1978// MockContainerRuntime_RemoveImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveImage'
1979type MockContainerRuntime_RemoveImage_Call struct {
1980	*mock.Call
1981}
1982
1983// RemoveImage is a helper method to define mock.On call
1984//   - ctx context.Context
1985//   - image string
1986//   - force bool
1987func (_e *MockContainerRuntime_Expecter) RemoveImage(ctx interface{}, image interface{}, force interface{}) *MockContainerRuntime_RemoveImage_Call {
1988	return &MockContainerRuntime_RemoveImage_Call{Call: _e.mock.On("RemoveImage", ctx, image, force)}
1989}
1990
1991func (_c *MockContainerRuntime_RemoveImage_Call) Run(run func(ctx context.Context, image string, force bool)) *MockContainerRuntime_RemoveImage_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		var arg2 bool
2002		if args[2] != nil {
2003			arg2 = args[2].(bool)
2004		}
2005		run(
2006			arg0,
2007			arg1,
2008			arg2,
2009		)
2010	})
2011	return _c
2012}
2013
2014func (_c *MockContainerRuntime_RemoveImage_Call) Return(err error) *MockContainerRuntime_RemoveImage_Call {
2015	_c.Call.Return(err)
2016	return _c
2017}
2018
2019func (_c *MockContainerRuntime_RemoveImage_Call) RunAndReturn(run func(ctx context.Context, image string, force bool) error) *MockContainerRuntime_RemoveImage_Call {
2020	_c.Call.Return(run)
2021	return _c
2022}
2023
2024// RemoveNetwork provides a mock function for the type MockContainerRuntime
2025func (_mock *MockContainerRuntime) RemoveNetwork(ctx context.Context, name string) error {
2026	ret := _mock.Called(ctx, name)
2027
2028	if len(ret) == 0 {
2029		panic("no return value specified for RemoveNetwork")
2030	}
2031
2032	var r0 error
2033	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
2034		r0 = returnFunc(ctx, name)
2035	} else {
2036		r0 = ret.Error(0)
2037	}
2038	return r0
2039}
2040
2041// MockContainerRuntime_RemoveNetwork_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveNetwork'
2042type MockContainerRuntime_RemoveNetwork_Call struct {
2043	*mock.Call
2044}
2045
2046// RemoveNetwork is a helper method to define mock.On call
2047//   - ctx context.Context
2048//   - name string
2049func (_e *MockContainerRuntime_Expecter) RemoveNetwork(ctx interface{}, name interface{}) *MockContainerRuntime_RemoveNetwork_Call {
2050	return &MockContainerRuntime_RemoveNetwork_Call{Call: _e.mock.On("RemoveNetwork", ctx, name)}
2051}
2052
2053func (_c *MockContainerRuntime_RemoveNetwork_Call) Run(run func(ctx context.Context, name string)) *MockContainerRuntime_RemoveNetwork_Call {
2054	_c.Call.Run(func(args mock.Arguments) {
2055		var arg0 context.Context
2056		if args[0] != nil {
2057			arg0 = args[0].(context.Context)
2058		}
2059		var arg1 string
2060		if args[1] != nil {
2061			arg1 = args[1].(string)
2062		}
2063		run(
2064			arg0,
2065			arg1,
2066		)
2067	})
2068	return _c
2069}
2070
2071func (_c *MockContainerRuntime_RemoveNetwork_Call) Return(err error) *MockContainerRuntime_RemoveNetwork_Call {
2072	_c.Call.Return(err)
2073	return _c
2074}
2075
2076func (_c *MockContainerRuntime_RemoveNetwork_Call) RunAndReturn(run func(ctx context.Context, name string) error) *MockContainerRuntime_RemoveNetwork_Call {
2077	_c.Call.Return(run)
2078	return _c
2079}
2080
2081// RemoveVolume provides a mock function for the type MockContainerRuntime
2082func (_mock *MockContainerRuntime) RemoveVolume(ctx context.Context, volumeName string, force bool) error {
2083	ret := _mock.Called(ctx, volumeName, force)
2084
2085	if len(ret) == 0 {
2086		panic("no return value specified for RemoveVolume")
2087	}
2088
2089	var r0 error
2090	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) error); ok {
2091		r0 = returnFunc(ctx, volumeName, force)
2092	} else {
2093		r0 = ret.Error(0)
2094	}
2095	return r0
2096}
2097
2098// MockContainerRuntime_RemoveVolume_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveVolume'
2099type MockContainerRuntime_RemoveVolume_Call struct {
2100	*mock.Call
2101}
2102
2103// RemoveVolume is a helper method to define mock.On call
2104//   - ctx context.Context
2105//   - volumeName string
2106//   - force bool
2107func (_e *MockContainerRuntime_Expecter) RemoveVolume(ctx interface{}, volumeName interface{}, force interface{}) *MockContainerRuntime_RemoveVolume_Call {
2108	return &MockContainerRuntime_RemoveVolume_Call{Call: _e.mock.On("RemoveVolume", ctx, volumeName, force)}
2109}
2110
2111func (_c *MockContainerRuntime_RemoveVolume_Call) Run(run func(ctx context.Context, volumeName string, force bool)) *MockContainerRuntime_RemoveVolume_Call {
2112	_c.Call.Run(func(args mock.Arguments) {
2113		var arg0 context.Context
2114		if args[0] != nil {
2115			arg0 = args[0].(context.Context)
2116		}
2117		var arg1 string
2118		if args[1] != nil {
2119			arg1 = args[1].(string)
2120		}
2121		var arg2 bool
2122		if args[2] != nil {
2123			arg2 = args[2].(bool)
2124		}
2125		run(
2126			arg0,
2127			arg1,
2128			arg2,
2129		)
2130	})
2131	return _c
2132}
2133
2134func (_c *MockContainerRuntime_RemoveVolume_Call) Return(err error) *MockContainerRuntime_RemoveVolume_Call {
2135	_c.Call.Return(err)
2136	return _c
2137}
2138
2139func (_c *MockContainerRuntime_RemoveVolume_Call) RunAndReturn(run func(ctx context.Context, volumeName string, force bool) error) *MockContainerRuntime_RemoveVolume_Call {
2140	_c.Call.Return(run)
2141	return _c
2142}
2143
2144// RenameContainer provides a mock function for the type MockContainerRuntime
2145func (_mock *MockContainerRuntime) RenameContainer(ctx context.Context, containerID string, newName string) error {
2146	ret := _mock.Called(ctx, containerID, newName)
2147
2148	if len(ret) == 0 {
2149		panic("no return value specified for RenameContainer")
2150	}
2151
2152	var r0 error
2153	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
2154		r0 = returnFunc(ctx, containerID, newName)
2155	} else {
2156		r0 = ret.Error(0)
2157	}
2158	return r0
2159}
2160
2161// MockContainerRuntime_RenameContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenameContainer'
2162type MockContainerRuntime_RenameContainer_Call struct {
2163	*mock.Call
2164}
2165
2166// RenameContainer is a helper method to define mock.On call
2167//   - ctx context.Context
2168//   - containerID string
2169//   - newName string
2170func (_e *MockContainerRuntime_Expecter) RenameContainer(ctx interface{}, containerID interface{}, newName interface{}) *MockContainerRuntime_RenameContainer_Call {
2171	return &MockContainerRuntime_RenameContainer_Call{Call: _e.mock.On("RenameContainer", ctx, containerID, newName)}
2172}
2173
2174func (_c *MockContainerRuntime_RenameContainer_Call) Run(run func(ctx context.Context, containerID string, newName string)) *MockContainerRuntime_RenameContainer_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		var arg2 string
2185		if args[2] != nil {
2186			arg2 = args[2].(string)
2187		}
2188		run(
2189			arg0,
2190			arg1,
2191			arg2,
2192		)
2193	})
2194	return _c
2195}
2196
2197func (_c *MockContainerRuntime_RenameContainer_Call) Return(err error) *MockContainerRuntime_RenameContainer_Call {
2198	_c.Call.Return(err)
2199	return _c
2200}
2201
2202func (_c *MockContainerRuntime_RenameContainer_Call) RunAndReturn(run func(ctx context.Context, containerID string, newName string) error) *MockContainerRuntime_RenameContainer_Call {
2203	_c.Call.Return(run)
2204	return _c
2205}
2206
2207// RestartContainer provides a mock function for the type MockContainerRuntime
2208func (_mock *MockContainerRuntime) RestartContainer(ctx context.Context, containerID string) error {
2209	ret := _mock.Called(ctx, containerID)
2210
2211	if len(ret) == 0 {
2212		panic("no return value specified for RestartContainer")
2213	}
2214
2215	var r0 error
2216	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
2217		r0 = returnFunc(ctx, containerID)
2218	} else {
2219		r0 = ret.Error(0)
2220	}
2221	return r0
2222}
2223
2224// MockContainerRuntime_RestartContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestartContainer'
2225type MockContainerRuntime_RestartContainer_Call struct {
2226	*mock.Call
2227}
2228
2229// RestartContainer is a helper method to define mock.On call
2230//   - ctx context.Context
2231//   - containerID string
2232func (_e *MockContainerRuntime_Expecter) RestartContainer(ctx interface{}, containerID interface{}) *MockContainerRuntime_RestartContainer_Call {
2233	return &MockContainerRuntime_RestartContainer_Call{Call: _e.mock.On("RestartContainer", ctx, containerID)}
2234}
2235
2236func (_c *MockContainerRuntime_RestartContainer_Call) Run(run func(ctx context.Context, containerID string)) *MockContainerRuntime_RestartContainer_Call {
2237	_c.Call.Run(func(args mock.Arguments) {
2238		var arg0 context.Context
2239		if args[0] != nil {
2240			arg0 = args[0].(context.Context)
2241		}
2242		var arg1 string
2243		if args[1] != nil {
2244			arg1 = args[1].(string)
2245		}
2246		run(
2247			arg0,
2248			arg1,
2249		)
2250	})
2251	return _c
2252}
2253
2254func (_c *MockContainerRuntime_RestartContainer_Call) Return(err error) *MockContainerRuntime_RestartContainer_Call {
2255	_c.Call.Return(err)
2256	return _c
2257}
2258
2259func (_c *MockContainerRuntime_RestartContainer_Call) RunAndReturn(run func(ctx context.Context, containerID string) error) *MockContainerRuntime_RestartContainer_Call {
2260	_c.Call.Return(run)
2261	return _c
2262}
2263
2264// StartContainer provides a mock function for the type MockContainerRuntime
2265func (_mock *MockContainerRuntime) StartContainer(ctx context.Context, containerID string) error {
2266	ret := _mock.Called(ctx, containerID)
2267
2268	if len(ret) == 0 {
2269		panic("no return value specified for StartContainer")
2270	}
2271
2272	var r0 error
2273	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
2274		r0 = returnFunc(ctx, containerID)
2275	} else {
2276		r0 = ret.Error(0)
2277	}
2278	return r0
2279}
2280
2281// MockContainerRuntime_StartContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartContainer'
2282type MockContainerRuntime_StartContainer_Call struct {
2283	*mock.Call
2284}
2285
2286// StartContainer is a helper method to define mock.On call
2287//   - ctx context.Context
2288//   - containerID string
2289func (_e *MockContainerRuntime_Expecter) StartContainer(ctx interface{}, containerID interface{}) *MockContainerRuntime_StartContainer_Call {
2290	return &MockContainerRuntime_StartContainer_Call{Call: _e.mock.On("StartContainer", ctx, containerID)}
2291}
2292
2293func (_c *MockContainerRuntime_StartContainer_Call) Run(run func(ctx context.Context, containerID string)) *MockContainerRuntime_StartContainer_Call {
2294	_c.Call.Run(func(args mock.Arguments) {
2295		var arg0 context.Context
2296		if args[0] != nil {
2297			arg0 = args[0].(context.Context)
2298		}
2299		var arg1 string
2300		if args[1] != nil {
2301			arg1 = args[1].(string)
2302		}
2303		run(
2304			arg0,
2305			arg1,
2306		)
2307	})
2308	return _c
2309}
2310
2311func (_c *MockContainerRuntime_StartContainer_Call) Return(err error) *MockContainerRuntime_StartContainer_Call {
2312	_c.Call.Return(err)
2313	return _c
2314}
2315
2316func (_c *MockContainerRuntime_StartContainer_Call) RunAndReturn(run func(ctx context.Context, containerID string) error) *MockContainerRuntime_StartContainer_Call {
2317	_c.Call.Return(run)
2318	return _c
2319}
2320
2321// StopContainer provides a mock function for the type MockContainerRuntime
2322func (_mock *MockContainerRuntime) StopContainer(ctx context.Context, containerID string) error {
2323	ret := _mock.Called(ctx, containerID)
2324
2325	if len(ret) == 0 {
2326		panic("no return value specified for StopContainer")
2327	}
2328
2329	var r0 error
2330	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
2331		r0 = returnFunc(ctx, containerID)
2332	} else {
2333		r0 = ret.Error(0)
2334	}
2335	return r0
2336}
2337
2338// MockContainerRuntime_StopContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StopContainer'
2339type MockContainerRuntime_StopContainer_Call struct {
2340	*mock.Call
2341}
2342
2343// StopContainer is a helper method to define mock.On call
2344//   - ctx context.Context
2345//   - containerID string
2346func (_e *MockContainerRuntime_Expecter) StopContainer(ctx interface{}, containerID interface{}) *MockContainerRuntime_StopContainer_Call {
2347	return &MockContainerRuntime_StopContainer_Call{Call: _e.mock.On("StopContainer", ctx, containerID)}
2348}
2349
2350func (_c *MockContainerRuntime_StopContainer_Call) Run(run func(ctx context.Context, containerID string)) *MockContainerRuntime_StopContainer_Call {
2351	_c.Call.Run(func(args mock.Arguments) {
2352		var arg0 context.Context
2353		if args[0] != nil {
2354			arg0 = args[0].(context.Context)
2355		}
2356		var arg1 string
2357		if args[1] != nil {
2358			arg1 = args[1].(string)
2359		}
2360		run(
2361			arg0,
2362			arg1,
2363		)
2364	})
2365	return _c
2366}
2367
2368func (_c *MockContainerRuntime_StopContainer_Call) Return(err error) *MockContainerRuntime_StopContainer_Call {
2369	_c.Call.Return(err)
2370	return _c
2371}
2372
2373func (_c *MockContainerRuntime_StopContainer_Call) RunAndReturn(run func(ctx context.Context, containerID string) error) *MockContainerRuntime_StopContainer_Call {
2374	_c.Call.Return(run)
2375	return _c
2376}
2377
2378// TagImage provides a mock function for the type MockContainerRuntime
2379func (_mock *MockContainerRuntime) TagImage(ctx context.Context, sourceRef string, targetRef string) error {
2380	ret := _mock.Called(ctx, sourceRef, targetRef)
2381
2382	if len(ret) == 0 {
2383		panic("no return value specified for TagImage")
2384	}
2385
2386	var r0 error
2387	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
2388		r0 = returnFunc(ctx, sourceRef, targetRef)
2389	} else {
2390		r0 = ret.Error(0)
2391	}
2392	return r0
2393}
2394
2395// MockContainerRuntime_TagImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TagImage'
2396type MockContainerRuntime_TagImage_Call struct {
2397	*mock.Call
2398}
2399
2400// TagImage is a helper method to define mock.On call
2401//   - ctx context.Context
2402//   - sourceRef string
2403//   - targetRef string
2404func (_e *MockContainerRuntime_Expecter) TagImage(ctx interface{}, sourceRef interface{}, targetRef interface{}) *MockContainerRuntime_TagImage_Call {
2405	return &MockContainerRuntime_TagImage_Call{Call: _e.mock.On("TagImage", ctx, sourceRef, targetRef)}
2406}
2407
2408func (_c *MockContainerRuntime_TagImage_Call) Run(run func(ctx context.Context, sourceRef string, targetRef string)) *MockContainerRuntime_TagImage_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		var arg2 string
2419		if args[2] != nil {
2420			arg2 = args[2].(string)
2421		}
2422		run(
2423			arg0,
2424			arg1,
2425			arg2,
2426		)
2427	})
2428	return _c
2429}
2430
2431func (_c *MockContainerRuntime_TagImage_Call) Return(err error) *MockContainerRuntime_TagImage_Call {
2432	_c.Call.Return(err)
2433	return _c
2434}
2435
2436func (_c *MockContainerRuntime_TagImage_Call) RunAndReturn(run func(ctx context.Context, sourceRef string, targetRef string) error) *MockContainerRuntime_TagImage_Call {
2437	_c.Call.Return(run)
2438	return _c
2439}
2440
2441// UntagImage provides a mock function for the type MockContainerRuntime
2442func (_mock *MockContainerRuntime) UntagImage(ctx context.Context, imageRef string) error {
2443	ret := _mock.Called(ctx, imageRef)
2444
2445	if len(ret) == 0 {
2446		panic("no return value specified for UntagImage")
2447	}
2448
2449	var r0 error
2450	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
2451		r0 = returnFunc(ctx, imageRef)
2452	} else {
2453		r0 = ret.Error(0)
2454	}
2455	return r0
2456}
2457
2458// MockContainerRuntime_UntagImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UntagImage'
2459type MockContainerRuntime_UntagImage_Call struct {
2460	*mock.Call
2461}
2462
2463// UntagImage is a helper method to define mock.On call
2464//   - ctx context.Context
2465//   - imageRef string
2466func (_e *MockContainerRuntime_Expecter) UntagImage(ctx interface{}, imageRef interface{}) *MockContainerRuntime_UntagImage_Call {
2467	return &MockContainerRuntime_UntagImage_Call{Call: _e.mock.On("UntagImage", ctx, imageRef)}
2468}
2469
2470func (_c *MockContainerRuntime_UntagImage_Call) Run(run func(ctx context.Context, imageRef string)) *MockContainerRuntime_UntagImage_Call {
2471	_c.Call.Run(func(args mock.Arguments) {
2472		var arg0 context.Context
2473		if args[0] != nil {
2474			arg0 = args[0].(context.Context)
2475		}
2476		var arg1 string
2477		if args[1] != nil {
2478			arg1 = args[1].(string)
2479		}
2480		run(
2481			arg0,
2482			arg1,
2483		)
2484	})
2485	return _c
2486}
2487
2488func (_c *MockContainerRuntime_UntagImage_Call) Return(err error) *MockContainerRuntime_UntagImage_Call {
2489	_c.Call.Return(err)
2490	return _c
2491}
2492
2493func (_c *MockContainerRuntime_UntagImage_Call) RunAndReturn(run func(ctx context.Context, imageRef string) error) *MockContainerRuntime_UntagImage_Call {
2494	_c.Call.Return(run)
2495	return _c
2496}
2497
2498// Version provides a mock function for the type MockContainerRuntime
2499func (_mock *MockContainerRuntime) Version(ctx context.Context) (string, error) {
2500	ret := _mock.Called(ctx)
2501
2502	if len(ret) == 0 {
2503		panic("no return value specified for Version")
2504	}
2505
2506	var r0 string
2507	var r1 error
2508	if returnFunc, ok := ret.Get(0).(func(context.Context) (string, error)); ok {
2509		return returnFunc(ctx)
2510	}
2511	if returnFunc, ok := ret.Get(0).(func(context.Context) string); ok {
2512		r0 = returnFunc(ctx)
2513	} else {
2514		r0 = ret.Get(0).(string)
2515	}
2516	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
2517		r1 = returnFunc(ctx)
2518	} else {
2519		r1 = ret.Error(1)
2520	}
2521	return r0, r1
2522}
2523
2524// MockContainerRuntime_Version_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Version'
2525type MockContainerRuntime_Version_Call struct {
2526	*mock.Call
2527}
2528
2529// Version is a helper method to define mock.On call
2530//   - ctx context.Context
2531func (_e *MockContainerRuntime_Expecter) Version(ctx interface{}) *MockContainerRuntime_Version_Call {
2532	return &MockContainerRuntime_Version_Call{Call: _e.mock.On("Version", ctx)}
2533}
2534
2535func (_c *MockContainerRuntime_Version_Call) Run(run func(ctx context.Context)) *MockContainerRuntime_Version_Call {
2536	_c.Call.Run(func(args mock.Arguments) {
2537		var arg0 context.Context
2538		if args[0] != nil {
2539			arg0 = args[0].(context.Context)
2540		}
2541		run(
2542			arg0,
2543		)
2544	})
2545	return _c
2546}
2547
2548func (_c *MockContainerRuntime_Version_Call) Return(s string, err error) *MockContainerRuntime_Version_Call {
2549	_c.Call.Return(s, err)
2550	return _c
2551}
2552
2553func (_c *MockContainerRuntime_Version_Call) RunAndReturn(run func(ctx context.Context) (string, error)) *MockContainerRuntime_Version_Call {
2554	_c.Call.Return(run)
2555	return _c
2556}
2557
2558// VolumeExists provides a mock function for the type MockContainerRuntime
2559func (_mock *MockContainerRuntime) VolumeExists(ctx context.Context, volumeName string) (bool, error) {
2560	ret := _mock.Called(ctx, volumeName)
2561
2562	if len(ret) == 0 {
2563		panic("no return value specified for VolumeExists")
2564	}
2565
2566	var r0 bool
2567	var r1 error
2568	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (bool, error)); ok {
2569		return returnFunc(ctx, volumeName)
2570	}
2571	if returnFunc, ok := ret.Get(0).(func(context.Context, string) bool); ok {
2572		r0 = returnFunc(ctx, volumeName)
2573	} else {
2574		r0 = ret.Get(0).(bool)
2575	}
2576	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
2577		r1 = returnFunc(ctx, volumeName)
2578	} else {
2579		r1 = ret.Error(1)
2580	}
2581	return r0, r1
2582}
2583
2584// MockContainerRuntime_VolumeExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VolumeExists'
2585type MockContainerRuntime_VolumeExists_Call struct {
2586	*mock.Call
2587}
2588
2589// VolumeExists is a helper method to define mock.On call
2590//   - ctx context.Context
2591//   - volumeName string
2592func (_e *MockContainerRuntime_Expecter) VolumeExists(ctx interface{}, volumeName interface{}) *MockContainerRuntime_VolumeExists_Call {
2593	return &MockContainerRuntime_VolumeExists_Call{Call: _e.mock.On("VolumeExists", ctx, volumeName)}
2594}
2595
2596func (_c *MockContainerRuntime_VolumeExists_Call) Run(run func(ctx context.Context, volumeName string)) *MockContainerRuntime_VolumeExists_Call {
2597	_c.Call.Run(func(args mock.Arguments) {
2598		var arg0 context.Context
2599		if args[0] != nil {
2600			arg0 = args[0].(context.Context)
2601		}
2602		var arg1 string
2603		if args[1] != nil {
2604			arg1 = args[1].(string)
2605		}
2606		run(
2607			arg0,
2608			arg1,
2609		)
2610	})
2611	return _c
2612}
2613
2614func (_c *MockContainerRuntime_VolumeExists_Call) Return(b bool, err error) *MockContainerRuntime_VolumeExists_Call {
2615	_c.Call.Return(b, err)
2616	return _c
2617}
2618
2619func (_c *MockContainerRuntime_VolumeExists_Call) RunAndReturn(run func(ctx context.Context, volumeName string) (bool, error)) *MockContainerRuntime_VolumeExists_Call {
2620	_c.Call.Return(run)
2621	return _c
2622}