1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package mocks
6
7import (
8 "context"
9
10 "github.com/bnema/gordon/internal/domain"
11 mock "github.com/stretchr/testify/mock"
12)
13
14// NewMockContainerService creates a new instance of MockContainerService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15// The first argument is typically a *testing.T value.
16func NewMockContainerService(t interface {
17 mock.TestingT
18 Cleanup(func())
19}) *MockContainerService {
20 mock := &MockContainerService{}
21 mock.Mock.Test(t)
22
23 t.Cleanup(func() { mock.AssertExpectations(t) })
24
25 return mock
26}
27
28// MockContainerService is an autogenerated mock type for the ContainerService type
29type MockContainerService struct {
30 mock.Mock
31}
32
33type MockContainerService_Expecter struct {
34 mock *mock.Mock
35}
36
37func (_m *MockContainerService) EXPECT() *MockContainerService_Expecter {
38 return &MockContainerService_Expecter{mock: &_m.Mock}
39}
40
41// AutoStart provides a mock function for the type MockContainerService
42func (_mock *MockContainerService) AutoStart(ctx context.Context, routes []domain.Route) error {
43 ret := _mock.Called(ctx, routes)
44
45 if len(ret) == 0 {
46 panic("no return value specified for AutoStart")
47 }
48
49 var r0 error
50 if returnFunc, ok := ret.Get(0).(func(context.Context, []domain.Route) error); ok {
51 r0 = returnFunc(ctx, routes)
52 } else {
53 r0 = ret.Error(0)
54 }
55 return r0
56}
57
58// MockContainerService_AutoStart_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AutoStart'
59type MockContainerService_AutoStart_Call struct {
60 *mock.Call
61}
62
63// AutoStart is a helper method to define mock.On call
64// - ctx context.Context
65// - routes []domain.Route
66func (_e *MockContainerService_Expecter) AutoStart(ctx interface{}, routes interface{}) *MockContainerService_AutoStart_Call {
67 return &MockContainerService_AutoStart_Call{Call: _e.mock.On("AutoStart", ctx, routes)}
68}
69
70func (_c *MockContainerService_AutoStart_Call) Run(run func(ctx context.Context, routes []domain.Route)) *MockContainerService_AutoStart_Call {
71 _c.Call.Run(func(args mock.Arguments) {
72 var arg0 context.Context
73 if args[0] != nil {
74 arg0 = args[0].(context.Context)
75 }
76 var arg1 []domain.Route
77 if args[1] != nil {
78 arg1 = args[1].([]domain.Route)
79 }
80 run(
81 arg0,
82 arg1,
83 )
84 })
85 return _c
86}
87
88func (_c *MockContainerService_AutoStart_Call) Return(err error) *MockContainerService_AutoStart_Call {
89 _c.Call.Return(err)
90 return _c
91}
92
93func (_c *MockContainerService_AutoStart_Call) RunAndReturn(run func(ctx context.Context, routes []domain.Route) error) *MockContainerService_AutoStart_Call {
94 _c.Call.Return(run)
95 return _c
96}
97
98// Deploy provides a mock function for the type MockContainerService
99func (_mock *MockContainerService) Deploy(ctx context.Context, route domain.Route) (*domain.Container, error) {
100 ret := _mock.Called(ctx, route)
101
102 if len(ret) == 0 {
103 panic("no return value specified for Deploy")
104 }
105
106 var r0 *domain.Container
107 var r1 error
108 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Route) (*domain.Container, error)); ok {
109 return returnFunc(ctx, route)
110 }
111 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Route) *domain.Container); ok {
112 r0 = returnFunc(ctx, route)
113 } else {
114 if ret.Get(0) != nil {
115 r0 = ret.Get(0).(*domain.Container)
116 }
117 }
118 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Route) error); ok {
119 r1 = returnFunc(ctx, route)
120 } else {
121 r1 = ret.Error(1)
122 }
123 return r0, r1
124}
125
126// MockContainerService_Deploy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Deploy'
127type MockContainerService_Deploy_Call struct {
128 *mock.Call
129}
130
131// Deploy is a helper method to define mock.On call
132// - ctx context.Context
133// - route domain.Route
134func (_e *MockContainerService_Expecter) Deploy(ctx interface{}, route interface{}) *MockContainerService_Deploy_Call {
135 return &MockContainerService_Deploy_Call{Call: _e.mock.On("Deploy", ctx, route)}
136}
137
138func (_c *MockContainerService_Deploy_Call) Run(run func(ctx context.Context, route domain.Route)) *MockContainerService_Deploy_Call {
139 _c.Call.Run(func(args mock.Arguments) {
140 var arg0 context.Context
141 if args[0] != nil {
142 arg0 = args[0].(context.Context)
143 }
144 var arg1 domain.Route
145 if args[1] != nil {
146 arg1 = args[1].(domain.Route)
147 }
148 run(
149 arg0,
150 arg1,
151 )
152 })
153 return _c
154}
155
156func (_c *MockContainerService_Deploy_Call) Return(container *domain.Container, err error) *MockContainerService_Deploy_Call {
157 _c.Call.Return(container, err)
158 return _c
159}
160
161func (_c *MockContainerService_Deploy_Call) RunAndReturn(run func(ctx context.Context, route domain.Route) (*domain.Container, error)) *MockContainerService_Deploy_Call {
162 _c.Call.Return(run)
163 return _c
164}
165
166// Get provides a mock function for the type MockContainerService
167func (_mock *MockContainerService) Get(ctx context.Context, domain1 string) (*domain.Container, bool) {
168 ret := _mock.Called(ctx, domain1)
169
170 if len(ret) == 0 {
171 panic("no return value specified for Get")
172 }
173
174 var r0 *domain.Container
175 var r1 bool
176 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*domain.Container, bool)); ok {
177 return returnFunc(ctx, domain1)
178 }
179 if returnFunc, ok := ret.Get(0).(func(context.Context, string) *domain.Container); ok {
180 r0 = returnFunc(ctx, domain1)
181 } else {
182 if ret.Get(0) != nil {
183 r0 = ret.Get(0).(*domain.Container)
184 }
185 }
186 if returnFunc, ok := ret.Get(1).(func(context.Context, string) bool); ok {
187 r1 = returnFunc(ctx, domain1)
188 } else {
189 r1 = ret.Get(1).(bool)
190 }
191 return r0, r1
192}
193
194// MockContainerService_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
195type MockContainerService_Get_Call struct {
196 *mock.Call
197}
198
199// Get is a helper method to define mock.On call
200// - ctx context.Context
201// - domain1 string
202func (_e *MockContainerService_Expecter) Get(ctx interface{}, domain1 interface{}) *MockContainerService_Get_Call {
203 return &MockContainerService_Get_Call{Call: _e.mock.On("Get", ctx, domain1)}
204}
205
206func (_c *MockContainerService_Get_Call) Run(run func(ctx context.Context, domain1 string)) *MockContainerService_Get_Call {
207 _c.Call.Run(func(args mock.Arguments) {
208 var arg0 context.Context
209 if args[0] != nil {
210 arg0 = args[0].(context.Context)
211 }
212 var arg1 string
213 if args[1] != nil {
214 arg1 = args[1].(string)
215 }
216 run(
217 arg0,
218 arg1,
219 )
220 })
221 return _c
222}
223
224func (_c *MockContainerService_Get_Call) Return(container *domain.Container, b bool) *MockContainerService_Get_Call {
225 _c.Call.Return(container, b)
226 return _c
227}
228
229func (_c *MockContainerService_Get_Call) RunAndReturn(run func(ctx context.Context, domain1 string) (*domain.Container, bool)) *MockContainerService_Get_Call {
230 _c.Call.Return(run)
231 return _c
232}
233
234// HealthCheck provides a mock function for the type MockContainerService
235func (_mock *MockContainerService) HealthCheck(ctx context.Context) map[string]bool {
236 ret := _mock.Called(ctx)
237
238 if len(ret) == 0 {
239 panic("no return value specified for HealthCheck")
240 }
241
242 var r0 map[string]bool
243 if returnFunc, ok := ret.Get(0).(func(context.Context) map[string]bool); ok {
244 r0 = returnFunc(ctx)
245 } else {
246 if ret.Get(0) != nil {
247 r0 = ret.Get(0).(map[string]bool)
248 }
249 }
250 return r0
251}
252
253// MockContainerService_HealthCheck_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HealthCheck'
254type MockContainerService_HealthCheck_Call struct {
255 *mock.Call
256}
257
258// HealthCheck is a helper method to define mock.On call
259// - ctx context.Context
260func (_e *MockContainerService_Expecter) HealthCheck(ctx interface{}) *MockContainerService_HealthCheck_Call {
261 return &MockContainerService_HealthCheck_Call{Call: _e.mock.On("HealthCheck", ctx)}
262}
263
264func (_c *MockContainerService_HealthCheck_Call) Run(run func(ctx context.Context)) *MockContainerService_HealthCheck_Call {
265 _c.Call.Run(func(args mock.Arguments) {
266 var arg0 context.Context
267 if args[0] != nil {
268 arg0 = args[0].(context.Context)
269 }
270 run(
271 arg0,
272 )
273 })
274 return _c
275}
276
277func (_c *MockContainerService_HealthCheck_Call) Return(stringToBool map[string]bool) *MockContainerService_HealthCheck_Call {
278 _c.Call.Return(stringToBool)
279 return _c
280}
281
282func (_c *MockContainerService_HealthCheck_Call) RunAndReturn(run func(ctx context.Context) map[string]bool) *MockContainerService_HealthCheck_Call {
283 _c.Call.Return(run)
284 return _c
285}
286
287// List provides a mock function for the type MockContainerService
288func (_mock *MockContainerService) List(ctx context.Context) map[string]*domain.Container {
289 ret := _mock.Called(ctx)
290
291 if len(ret) == 0 {
292 panic("no return value specified for List")
293 }
294
295 var r0 map[string]*domain.Container
296 if returnFunc, ok := ret.Get(0).(func(context.Context) map[string]*domain.Container); ok {
297 r0 = returnFunc(ctx)
298 } else {
299 if ret.Get(0) != nil {
300 r0 = ret.Get(0).(map[string]*domain.Container)
301 }
302 }
303 return r0
304}
305
306// MockContainerService_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List'
307type MockContainerService_List_Call struct {
308 *mock.Call
309}
310
311// List is a helper method to define mock.On call
312// - ctx context.Context
313func (_e *MockContainerService_Expecter) List(ctx interface{}) *MockContainerService_List_Call {
314 return &MockContainerService_List_Call{Call: _e.mock.On("List", ctx)}
315}
316
317func (_c *MockContainerService_List_Call) Run(run func(ctx context.Context)) *MockContainerService_List_Call {
318 _c.Call.Run(func(args mock.Arguments) {
319 var arg0 context.Context
320 if args[0] != nil {
321 arg0 = args[0].(context.Context)
322 }
323 run(
324 arg0,
325 )
326 })
327 return _c
328}
329
330func (_c *MockContainerService_List_Call) Return(stringToContainer map[string]*domain.Container) *MockContainerService_List_Call {
331 _c.Call.Return(stringToContainer)
332 return _c
333}
334
335func (_c *MockContainerService_List_Call) RunAndReturn(run func(ctx context.Context) map[string]*domain.Container) *MockContainerService_List_Call {
336 _c.Call.Return(run)
337 return _c
338}
339
340// ListAttachments provides a mock function for the type MockContainerService
341func (_mock *MockContainerService) ListAttachments(ctx context.Context, domain1 string) []domain.Attachment {
342 ret := _mock.Called(ctx, domain1)
343
344 if len(ret) == 0 {
345 panic("no return value specified for ListAttachments")
346 }
347
348 var r0 []domain.Attachment
349 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []domain.Attachment); ok {
350 r0 = returnFunc(ctx, domain1)
351 } else {
352 if ret.Get(0) != nil {
353 r0 = ret.Get(0).([]domain.Attachment)
354 }
355 }
356 return r0
357}
358
359// MockContainerService_ListAttachments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAttachments'
360type MockContainerService_ListAttachments_Call struct {
361 *mock.Call
362}
363
364// ListAttachments is a helper method to define mock.On call
365// - ctx context.Context
366// - domain1 string
367func (_e *MockContainerService_Expecter) ListAttachments(ctx interface{}, domain1 interface{}) *MockContainerService_ListAttachments_Call {
368 return &MockContainerService_ListAttachments_Call{Call: _e.mock.On("ListAttachments", ctx, domain1)}
369}
370
371func (_c *MockContainerService_ListAttachments_Call) Run(run func(ctx context.Context, domain1 string)) *MockContainerService_ListAttachments_Call {
372 _c.Call.Run(func(args mock.Arguments) {
373 var arg0 context.Context
374 if args[0] != nil {
375 arg0 = args[0].(context.Context)
376 }
377 var arg1 string
378 if args[1] != nil {
379 arg1 = args[1].(string)
380 }
381 run(
382 arg0,
383 arg1,
384 )
385 })
386 return _c
387}
388
389func (_c *MockContainerService_ListAttachments_Call) Return(attachments []domain.Attachment) *MockContainerService_ListAttachments_Call {
390 _c.Call.Return(attachments)
391 return _c
392}
393
394func (_c *MockContainerService_ListAttachments_Call) RunAndReturn(run func(ctx context.Context, domain1 string) []domain.Attachment) *MockContainerService_ListAttachments_Call {
395 _c.Call.Return(run)
396 return _c
397}
398
399// ListNetworks provides a mock function for the type MockContainerService
400func (_mock *MockContainerService) ListNetworks(ctx context.Context) ([]*domain.NetworkInfo, error) {
401 ret := _mock.Called(ctx)
402
403 if len(ret) == 0 {
404 panic("no return value specified for ListNetworks")
405 }
406
407 var r0 []*domain.NetworkInfo
408 var r1 error
409 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*domain.NetworkInfo, error)); ok {
410 return returnFunc(ctx)
411 }
412 if returnFunc, ok := ret.Get(0).(func(context.Context) []*domain.NetworkInfo); ok {
413 r0 = returnFunc(ctx)
414 } else {
415 if ret.Get(0) != nil {
416 r0 = ret.Get(0).([]*domain.NetworkInfo)
417 }
418 }
419 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
420 r1 = returnFunc(ctx)
421 } else {
422 r1 = ret.Error(1)
423 }
424 return r0, r1
425}
426
427// MockContainerService_ListNetworks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListNetworks'
428type MockContainerService_ListNetworks_Call struct {
429 *mock.Call
430}
431
432// ListNetworks is a helper method to define mock.On call
433// - ctx context.Context
434func (_e *MockContainerService_Expecter) ListNetworks(ctx interface{}) *MockContainerService_ListNetworks_Call {
435 return &MockContainerService_ListNetworks_Call{Call: _e.mock.On("ListNetworks", ctx)}
436}
437
438func (_c *MockContainerService_ListNetworks_Call) Run(run func(ctx context.Context)) *MockContainerService_ListNetworks_Call {
439 _c.Call.Run(func(args mock.Arguments) {
440 var arg0 context.Context
441 if args[0] != nil {
442 arg0 = args[0].(context.Context)
443 }
444 run(
445 arg0,
446 )
447 })
448 return _c
449}
450
451func (_c *MockContainerService_ListNetworks_Call) Return(networkInfos []*domain.NetworkInfo, err error) *MockContainerService_ListNetworks_Call {
452 _c.Call.Return(networkInfos, err)
453 return _c
454}
455
456func (_c *MockContainerService_ListNetworks_Call) RunAndReturn(run func(ctx context.Context) ([]*domain.NetworkInfo, error)) *MockContainerService_ListNetworks_Call {
457 _c.Call.Return(run)
458 return _c
459}
460
461// ListRoutesWithDetails provides a mock function for the type MockContainerService
462func (_mock *MockContainerService) ListRoutesWithDetails(ctx context.Context) []domain.RouteInfo {
463 ret := _mock.Called(ctx)
464
465 if len(ret) == 0 {
466 panic("no return value specified for ListRoutesWithDetails")
467 }
468
469 var r0 []domain.RouteInfo
470 if returnFunc, ok := ret.Get(0).(func(context.Context) []domain.RouteInfo); ok {
471 r0 = returnFunc(ctx)
472 } else {
473 if ret.Get(0) != nil {
474 r0 = ret.Get(0).([]domain.RouteInfo)
475 }
476 }
477 return r0
478}
479
480// MockContainerService_ListRoutesWithDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRoutesWithDetails'
481type MockContainerService_ListRoutesWithDetails_Call struct {
482 *mock.Call
483}
484
485// ListRoutesWithDetails is a helper method to define mock.On call
486// - ctx context.Context
487func (_e *MockContainerService_Expecter) ListRoutesWithDetails(ctx interface{}) *MockContainerService_ListRoutesWithDetails_Call {
488 return &MockContainerService_ListRoutesWithDetails_Call{Call: _e.mock.On("ListRoutesWithDetails", ctx)}
489}
490
491func (_c *MockContainerService_ListRoutesWithDetails_Call) Run(run func(ctx context.Context)) *MockContainerService_ListRoutesWithDetails_Call {
492 _c.Call.Run(func(args mock.Arguments) {
493 var arg0 context.Context
494 if args[0] != nil {
495 arg0 = args[0].(context.Context)
496 }
497 run(
498 arg0,
499 )
500 })
501 return _c
502}
503
504func (_c *MockContainerService_ListRoutesWithDetails_Call) Return(routeInfos []domain.RouteInfo) *MockContainerService_ListRoutesWithDetails_Call {
505 _c.Call.Return(routeInfos)
506 return _c
507}
508
509func (_c *MockContainerService_ListRoutesWithDetails_Call) RunAndReturn(run func(ctx context.Context) []domain.RouteInfo) *MockContainerService_ListRoutesWithDetails_Call {
510 _c.Call.Return(run)
511 return _c
512}
513
514// Remove provides a mock function for the type MockContainerService
515func (_mock *MockContainerService) Remove(ctx context.Context, containerID string, force bool) error {
516 ret := _mock.Called(ctx, containerID, force)
517
518 if len(ret) == 0 {
519 panic("no return value specified for Remove")
520 }
521
522 var r0 error
523 if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) error); ok {
524 r0 = returnFunc(ctx, containerID, force)
525 } else {
526 r0 = ret.Error(0)
527 }
528 return r0
529}
530
531// MockContainerService_Remove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Remove'
532type MockContainerService_Remove_Call struct {
533 *mock.Call
534}
535
536// Remove is a helper method to define mock.On call
537// - ctx context.Context
538// - containerID string
539// - force bool
540func (_e *MockContainerService_Expecter) Remove(ctx interface{}, containerID interface{}, force interface{}) *MockContainerService_Remove_Call {
541 return &MockContainerService_Remove_Call{Call: _e.mock.On("Remove", ctx, containerID, force)}
542}
543
544func (_c *MockContainerService_Remove_Call) Run(run func(ctx context.Context, containerID string, force bool)) *MockContainerService_Remove_Call {
545 _c.Call.Run(func(args mock.Arguments) {
546 var arg0 context.Context
547 if args[0] != nil {
548 arg0 = args[0].(context.Context)
549 }
550 var arg1 string
551 if args[1] != nil {
552 arg1 = args[1].(string)
553 }
554 var arg2 bool
555 if args[2] != nil {
556 arg2 = args[2].(bool)
557 }
558 run(
559 arg0,
560 arg1,
561 arg2,
562 )
563 })
564 return _c
565}
566
567func (_c *MockContainerService_Remove_Call) Return(err error) *MockContainerService_Remove_Call {
568 _c.Call.Return(err)
569 return _c
570}
571
572func (_c *MockContainerService_Remove_Call) RunAndReturn(run func(ctx context.Context, containerID string, force bool) error) *MockContainerService_Remove_Call {
573 _c.Call.Return(run)
574 return _c
575}
576
577// Restart provides a mock function for the type MockContainerService
578func (_mock *MockContainerService) Restart(ctx context.Context, domain1 string, withAttachments bool) error {
579 ret := _mock.Called(ctx, domain1, withAttachments)
580
581 if len(ret) == 0 {
582 panic("no return value specified for Restart")
583 }
584
585 var r0 error
586 if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) error); ok {
587 r0 = returnFunc(ctx, domain1, withAttachments)
588 } else {
589 r0 = ret.Error(0)
590 }
591 return r0
592}
593
594// MockContainerService_Restart_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Restart'
595type MockContainerService_Restart_Call struct {
596 *mock.Call
597}
598
599// Restart is a helper method to define mock.On call
600// - ctx context.Context
601// - domain1 string
602// - withAttachments bool
603func (_e *MockContainerService_Expecter) Restart(ctx interface{}, domain1 interface{}, withAttachments interface{}) *MockContainerService_Restart_Call {
604 return &MockContainerService_Restart_Call{Call: _e.mock.On("Restart", ctx, domain1, withAttachments)}
605}
606
607func (_c *MockContainerService_Restart_Call) Run(run func(ctx context.Context, domain1 string, withAttachments bool)) *MockContainerService_Restart_Call {
608 _c.Call.Run(func(args mock.Arguments) {
609 var arg0 context.Context
610 if args[0] != nil {
611 arg0 = args[0].(context.Context)
612 }
613 var arg1 string
614 if args[1] != nil {
615 arg1 = args[1].(string)
616 }
617 var arg2 bool
618 if args[2] != nil {
619 arg2 = args[2].(bool)
620 }
621 run(
622 arg0,
623 arg1,
624 arg2,
625 )
626 })
627 return _c
628}
629
630func (_c *MockContainerService_Restart_Call) Return(err error) *MockContainerService_Restart_Call {
631 _c.Call.Return(err)
632 return _c
633}
634
635func (_c *MockContainerService_Restart_Call) RunAndReturn(run func(ctx context.Context, domain1 string, withAttachments bool) error) *MockContainerService_Restart_Call {
636 _c.Call.Return(run)
637 return _c
638}
639
640// Shutdown provides a mock function for the type MockContainerService
641func (_mock *MockContainerService) Shutdown(ctx context.Context) error {
642 ret := _mock.Called(ctx)
643
644 if len(ret) == 0 {
645 panic("no return value specified for Shutdown")
646 }
647
648 var r0 error
649 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
650 r0 = returnFunc(ctx)
651 } else {
652 r0 = ret.Error(0)
653 }
654 return r0
655}
656
657// MockContainerService_Shutdown_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Shutdown'
658type MockContainerService_Shutdown_Call struct {
659 *mock.Call
660}
661
662// Shutdown is a helper method to define mock.On call
663// - ctx context.Context
664func (_e *MockContainerService_Expecter) Shutdown(ctx interface{}) *MockContainerService_Shutdown_Call {
665 return &MockContainerService_Shutdown_Call{Call: _e.mock.On("Shutdown", ctx)}
666}
667
668func (_c *MockContainerService_Shutdown_Call) Run(run func(ctx context.Context)) *MockContainerService_Shutdown_Call {
669 _c.Call.Run(func(args mock.Arguments) {
670 var arg0 context.Context
671 if args[0] != nil {
672 arg0 = args[0].(context.Context)
673 }
674 run(
675 arg0,
676 )
677 })
678 return _c
679}
680
681func (_c *MockContainerService_Shutdown_Call) Return(err error) *MockContainerService_Shutdown_Call {
682 _c.Call.Return(err)
683 return _c
684}
685
686func (_c *MockContainerService_Shutdown_Call) RunAndReturn(run func(ctx context.Context) error) *MockContainerService_Shutdown_Call {
687 _c.Call.Return(run)
688 return _c
689}
690
691// Stop provides a mock function for the type MockContainerService
692func (_mock *MockContainerService) Stop(ctx context.Context, containerID string) error {
693 ret := _mock.Called(ctx, containerID)
694
695 if len(ret) == 0 {
696 panic("no return value specified for Stop")
697 }
698
699 var r0 error
700 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
701 r0 = returnFunc(ctx, containerID)
702 } else {
703 r0 = ret.Error(0)
704 }
705 return r0
706}
707
708// MockContainerService_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
709type MockContainerService_Stop_Call struct {
710 *mock.Call
711}
712
713// Stop is a helper method to define mock.On call
714// - ctx context.Context
715// - containerID string
716func (_e *MockContainerService_Expecter) Stop(ctx interface{}, containerID interface{}) *MockContainerService_Stop_Call {
717 return &MockContainerService_Stop_Call{Call: _e.mock.On("Stop", ctx, containerID)}
718}
719
720func (_c *MockContainerService_Stop_Call) Run(run func(ctx context.Context, containerID string)) *MockContainerService_Stop_Call {
721 _c.Call.Run(func(args mock.Arguments) {
722 var arg0 context.Context
723 if args[0] != nil {
724 arg0 = args[0].(context.Context)
725 }
726 var arg1 string
727 if args[1] != nil {
728 arg1 = args[1].(string)
729 }
730 run(
731 arg0,
732 arg1,
733 )
734 })
735 return _c
736}
737
738func (_c *MockContainerService_Stop_Call) Return(err error) *MockContainerService_Stop_Call {
739 _c.Call.Return(err)
740 return _c
741}
742
743func (_c *MockContainerService_Stop_Call) RunAndReturn(run func(ctx context.Context, containerID string) error) *MockContainerService_Stop_Call {
744 _c.Call.Return(run)
745 return _c
746}
747
748// SyncContainers provides a mock function for the type MockContainerService
749func (_mock *MockContainerService) SyncContainers(ctx context.Context) error {
750 ret := _mock.Called(ctx)
751
752 if len(ret) == 0 {
753 panic("no return value specified for SyncContainers")
754 }
755
756 var r0 error
757 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
758 r0 = returnFunc(ctx)
759 } else {
760 r0 = ret.Error(0)
761 }
762 return r0
763}
764
765// MockContainerService_SyncContainers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SyncContainers'
766type MockContainerService_SyncContainers_Call struct {
767 *mock.Call
768}
769
770// SyncContainers is a helper method to define mock.On call
771// - ctx context.Context
772func (_e *MockContainerService_Expecter) SyncContainers(ctx interface{}) *MockContainerService_SyncContainers_Call {
773 return &MockContainerService_SyncContainers_Call{Call: _e.mock.On("SyncContainers", ctx)}
774}
775
776func (_c *MockContainerService_SyncContainers_Call) Run(run func(ctx context.Context)) *MockContainerService_SyncContainers_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 run(
783 arg0,
784 )
785 })
786 return _c
787}
788
789func (_c *MockContainerService_SyncContainers_Call) Return(err error) *MockContainerService_SyncContainers_Call {
790 _c.Call.Return(err)
791 return _c
792}
793
794func (_c *MockContainerService_SyncContainers_Call) RunAndReturn(run func(ctx context.Context) error) *MockContainerService_SyncContainers_Call {
795 _c.Call.Return(run)
796 return _c
797}