1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package mocks
6
7import (
8 "context"
9 "gordon/internal/domain"
10
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// Shutdown provides a mock function for the type MockContainerService
578func (_mock *MockContainerService) Shutdown(ctx context.Context) error {
579 ret := _mock.Called(ctx)
580
581 if len(ret) == 0 {
582 panic("no return value specified for Shutdown")
583 }
584
585 var r0 error
586 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
587 r0 = returnFunc(ctx)
588 } else {
589 r0 = ret.Error(0)
590 }
591 return r0
592}
593
594// MockContainerService_Shutdown_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Shutdown'
595type MockContainerService_Shutdown_Call struct {
596 *mock.Call
597}
598
599// Shutdown is a helper method to define mock.On call
600// - ctx context.Context
601func (_e *MockContainerService_Expecter) Shutdown(ctx interface{}) *MockContainerService_Shutdown_Call {
602 return &MockContainerService_Shutdown_Call{Call: _e.mock.On("Shutdown", ctx)}
603}
604
605func (_c *MockContainerService_Shutdown_Call) Run(run func(ctx context.Context)) *MockContainerService_Shutdown_Call {
606 _c.Call.Run(func(args mock.Arguments) {
607 var arg0 context.Context
608 if args[0] != nil {
609 arg0 = args[0].(context.Context)
610 }
611 run(
612 arg0,
613 )
614 })
615 return _c
616}
617
618func (_c *MockContainerService_Shutdown_Call) Return(err error) *MockContainerService_Shutdown_Call {
619 _c.Call.Return(err)
620 return _c
621}
622
623func (_c *MockContainerService_Shutdown_Call) RunAndReturn(run func(ctx context.Context) error) *MockContainerService_Shutdown_Call {
624 _c.Call.Return(run)
625 return _c
626}
627
628// Stop provides a mock function for the type MockContainerService
629func (_mock *MockContainerService) Stop(ctx context.Context, containerID string) error {
630 ret := _mock.Called(ctx, containerID)
631
632 if len(ret) == 0 {
633 panic("no return value specified for Stop")
634 }
635
636 var r0 error
637 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
638 r0 = returnFunc(ctx, containerID)
639 } else {
640 r0 = ret.Error(0)
641 }
642 return r0
643}
644
645// MockContainerService_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
646type MockContainerService_Stop_Call struct {
647 *mock.Call
648}
649
650// Stop is a helper method to define mock.On call
651// - ctx context.Context
652// - containerID string
653func (_e *MockContainerService_Expecter) Stop(ctx interface{}, containerID interface{}) *MockContainerService_Stop_Call {
654 return &MockContainerService_Stop_Call{Call: _e.mock.On("Stop", ctx, containerID)}
655}
656
657func (_c *MockContainerService_Stop_Call) Run(run func(ctx context.Context, containerID string)) *MockContainerService_Stop_Call {
658 _c.Call.Run(func(args mock.Arguments) {
659 var arg0 context.Context
660 if args[0] != nil {
661 arg0 = args[0].(context.Context)
662 }
663 var arg1 string
664 if args[1] != nil {
665 arg1 = args[1].(string)
666 }
667 run(
668 arg0,
669 arg1,
670 )
671 })
672 return _c
673}
674
675func (_c *MockContainerService_Stop_Call) Return(err error) *MockContainerService_Stop_Call {
676 _c.Call.Return(err)
677 return _c
678}
679
680func (_c *MockContainerService_Stop_Call) RunAndReturn(run func(ctx context.Context, containerID string) error) *MockContainerService_Stop_Call {
681 _c.Call.Return(run)
682 return _c
683}
684
685// SyncContainers provides a mock function for the type MockContainerService
686func (_mock *MockContainerService) SyncContainers(ctx context.Context) error {
687 ret := _mock.Called(ctx)
688
689 if len(ret) == 0 {
690 panic("no return value specified for SyncContainers")
691 }
692
693 var r0 error
694 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
695 r0 = returnFunc(ctx)
696 } else {
697 r0 = ret.Error(0)
698 }
699 return r0
700}
701
702// MockContainerService_SyncContainers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SyncContainers'
703type MockContainerService_SyncContainers_Call struct {
704 *mock.Call
705}
706
707// SyncContainers is a helper method to define mock.On call
708// - ctx context.Context
709func (_e *MockContainerService_Expecter) SyncContainers(ctx interface{}) *MockContainerService_SyncContainers_Call {
710 return &MockContainerService_SyncContainers_Call{Call: _e.mock.On("SyncContainers", ctx)}
711}
712
713func (_c *MockContainerService_SyncContainers_Call) Run(run func(ctx context.Context)) *MockContainerService_SyncContainers_Call {
714 _c.Call.Run(func(args mock.Arguments) {
715 var arg0 context.Context
716 if args[0] != nil {
717 arg0 = args[0].(context.Context)
718 }
719 run(
720 arg0,
721 )
722 })
723 return _c
724}
725
726func (_c *MockContainerService_SyncContainers_Call) Return(err error) *MockContainerService_SyncContainers_Call {
727 _c.Call.Return(err)
728 return _c
729}
730
731func (_c *MockContainerService_SyncContainers_Call) RunAndReturn(run func(ctx context.Context) error) *MockContainerService_SyncContainers_Call {
732 _c.Call.Return(run)
733 return _c
734}