mock_container_runtime.go RawHistoryFolder

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