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