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// CleanupOrphanedAttachments provides a mock function for the type MockContainerService
99func (_mock *MockContainerService) CleanupOrphanedAttachments(ctx context.Context, owner string, stop bool) (*domain.CleanupReport, error) {
100 ret := _mock.Called(ctx, owner, stop)
101
102 if len(ret) == 0 {
103 panic("no return value specified for CleanupOrphanedAttachments")
104 }
105
106 var r0 *domain.CleanupReport
107 var r1 error
108 if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) (*domain.CleanupReport, error)); ok {
109 return returnFunc(ctx, owner, stop)
110 }
111 if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) *domain.CleanupReport); ok {
112 r0 = returnFunc(ctx, owner, stop)
113 } else {
114 if ret.Get(0) != nil {
115 r0 = ret.Get(0).(*domain.CleanupReport)
116 }
117 }
118 if returnFunc, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
119 r1 = returnFunc(ctx, owner, stop)
120 } else {
121 r1 = ret.Error(1)
122 }
123 return r0, r1
124}
125
126// MockContainerService_CleanupOrphanedAttachments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CleanupOrphanedAttachments'
127type MockContainerService_CleanupOrphanedAttachments_Call struct {
128 *mock.Call
129}
130
131// CleanupOrphanedAttachments is a helper method to define mock.On call
132// - ctx context.Context
133// - owner string
134// - stop bool
135func (_e *MockContainerService_Expecter) CleanupOrphanedAttachments(ctx interface{}, owner interface{}, stop interface{}) *MockContainerService_CleanupOrphanedAttachments_Call {
136 return &MockContainerService_CleanupOrphanedAttachments_Call{Call: _e.mock.On("CleanupOrphanedAttachments", ctx, owner, stop)}
137}
138
139func (_c *MockContainerService_CleanupOrphanedAttachments_Call) Run(run func(ctx context.Context, owner string, stop bool)) *MockContainerService_CleanupOrphanedAttachments_Call {
140 _c.Call.Run(func(args mock.Arguments) {
141 var arg0 context.Context
142 if args[0] != nil {
143 arg0 = args[0].(context.Context)
144 }
145 var arg1 string
146 if args[1] != nil {
147 arg1 = args[1].(string)
148 }
149 var arg2 bool
150 if args[2] != nil {
151 arg2 = args[2].(bool)
152 }
153 run(
154 arg0,
155 arg1,
156 arg2,
157 )
158 })
159 return _c
160}
161
162func (_c *MockContainerService_CleanupOrphanedAttachments_Call) Return(cleanupReport *domain.CleanupReport, err error) *MockContainerService_CleanupOrphanedAttachments_Call {
163 _c.Call.Return(cleanupReport, err)
164 return _c
165}
166
167func (_c *MockContainerService_CleanupOrphanedAttachments_Call) RunAndReturn(run func(ctx context.Context, owner string, stop bool) (*domain.CleanupReport, error)) *MockContainerService_CleanupOrphanedAttachments_Call {
168 _c.Call.Return(run)
169 return _c
170}
171
172// Deploy provides a mock function for the type MockContainerService
173func (_mock *MockContainerService) Deploy(ctx context.Context, route domain.Route) (*domain.Container, error) {
174 ret := _mock.Called(ctx, route)
175
176 if len(ret) == 0 {
177 panic("no return value specified for Deploy")
178 }
179
180 var r0 *domain.Container
181 var r1 error
182 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Route) (*domain.Container, error)); ok {
183 return returnFunc(ctx, route)
184 }
185 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Route) *domain.Container); ok {
186 r0 = returnFunc(ctx, route)
187 } else {
188 if ret.Get(0) != nil {
189 r0 = ret.Get(0).(*domain.Container)
190 }
191 }
192 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Route) error); ok {
193 r1 = returnFunc(ctx, route)
194 } else {
195 r1 = ret.Error(1)
196 }
197 return r0, r1
198}
199
200// MockContainerService_Deploy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Deploy'
201type MockContainerService_Deploy_Call struct {
202 *mock.Call
203}
204
205// Deploy is a helper method to define mock.On call
206// - ctx context.Context
207// - route domain.Route
208func (_e *MockContainerService_Expecter) Deploy(ctx interface{}, route interface{}) *MockContainerService_Deploy_Call {
209 return &MockContainerService_Deploy_Call{Call: _e.mock.On("Deploy", ctx, route)}
210}
211
212func (_c *MockContainerService_Deploy_Call) Run(run func(ctx context.Context, route domain.Route)) *MockContainerService_Deploy_Call {
213 _c.Call.Run(func(args mock.Arguments) {
214 var arg0 context.Context
215 if args[0] != nil {
216 arg0 = args[0].(context.Context)
217 }
218 var arg1 domain.Route
219 if args[1] != nil {
220 arg1 = args[1].(domain.Route)
221 }
222 run(
223 arg0,
224 arg1,
225 )
226 })
227 return _c
228}
229
230func (_c *MockContainerService_Deploy_Call) Return(container *domain.Container, err error) *MockContainerService_Deploy_Call {
231 _c.Call.Return(container, err)
232 return _c
233}
234
235func (_c *MockContainerService_Deploy_Call) RunAndReturn(run func(ctx context.Context, route domain.Route) (*domain.Container, error)) *MockContainerService_Deploy_Call {
236 _c.Call.Return(run)
237 return _c
238}
239
240// Get provides a mock function for the type MockContainerService
241func (_mock *MockContainerService) Get(ctx context.Context, domain1 string) (*domain.Container, bool) {
242 ret := _mock.Called(ctx, domain1)
243
244 if len(ret) == 0 {
245 panic("no return value specified for Get")
246 }
247
248 var r0 *domain.Container
249 var r1 bool
250 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*domain.Container, bool)); ok {
251 return returnFunc(ctx, domain1)
252 }
253 if returnFunc, ok := ret.Get(0).(func(context.Context, string) *domain.Container); ok {
254 r0 = returnFunc(ctx, domain1)
255 } else {
256 if ret.Get(0) != nil {
257 r0 = ret.Get(0).(*domain.Container)
258 }
259 }
260 if returnFunc, ok := ret.Get(1).(func(context.Context, string) bool); ok {
261 r1 = returnFunc(ctx, domain1)
262 } else {
263 r1 = ret.Get(1).(bool)
264 }
265 return r0, r1
266}
267
268// MockContainerService_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
269type MockContainerService_Get_Call struct {
270 *mock.Call
271}
272
273// Get is a helper method to define mock.On call
274// - ctx context.Context
275// - domain1 string
276func (_e *MockContainerService_Expecter) Get(ctx interface{}, domain1 interface{}) *MockContainerService_Get_Call {
277 return &MockContainerService_Get_Call{Call: _e.mock.On("Get", ctx, domain1)}
278}
279
280func (_c *MockContainerService_Get_Call) Run(run func(ctx context.Context, domain1 string)) *MockContainerService_Get_Call {
281 _c.Call.Run(func(args mock.Arguments) {
282 var arg0 context.Context
283 if args[0] != nil {
284 arg0 = args[0].(context.Context)
285 }
286 var arg1 string
287 if args[1] != nil {
288 arg1 = args[1].(string)
289 }
290 run(
291 arg0,
292 arg1,
293 )
294 })
295 return _c
296}
297
298func (_c *MockContainerService_Get_Call) Return(container *domain.Container, b bool) *MockContainerService_Get_Call {
299 _c.Call.Return(container, b)
300 return _c
301}
302
303func (_c *MockContainerService_Get_Call) RunAndReturn(run func(ctx context.Context, domain1 string) (*domain.Container, bool)) *MockContainerService_Get_Call {
304 _c.Call.Return(run)
305 return _c
306}
307
308// HealthCheck provides a mock function for the type MockContainerService
309func (_mock *MockContainerService) HealthCheck(ctx context.Context) map[string]bool {
310 ret := _mock.Called(ctx)
311
312 if len(ret) == 0 {
313 panic("no return value specified for HealthCheck")
314 }
315
316 var r0 map[string]bool
317 if returnFunc, ok := ret.Get(0).(func(context.Context) map[string]bool); ok {
318 r0 = returnFunc(ctx)
319 } else {
320 if ret.Get(0) != nil {
321 r0 = ret.Get(0).(map[string]bool)
322 }
323 }
324 return r0
325}
326
327// MockContainerService_HealthCheck_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HealthCheck'
328type MockContainerService_HealthCheck_Call struct {
329 *mock.Call
330}
331
332// HealthCheck is a helper method to define mock.On call
333// - ctx context.Context
334func (_e *MockContainerService_Expecter) HealthCheck(ctx interface{}) *MockContainerService_HealthCheck_Call {
335 return &MockContainerService_HealthCheck_Call{Call: _e.mock.On("HealthCheck", ctx)}
336}
337
338func (_c *MockContainerService_HealthCheck_Call) Run(run func(ctx context.Context)) *MockContainerService_HealthCheck_Call {
339 _c.Call.Run(func(args mock.Arguments) {
340 var arg0 context.Context
341 if args[0] != nil {
342 arg0 = args[0].(context.Context)
343 }
344 run(
345 arg0,
346 )
347 })
348 return _c
349}
350
351func (_c *MockContainerService_HealthCheck_Call) Return(stringToBool map[string]bool) *MockContainerService_HealthCheck_Call {
352 _c.Call.Return(stringToBool)
353 return _c
354}
355
356func (_c *MockContainerService_HealthCheck_Call) RunAndReturn(run func(ctx context.Context) map[string]bool) *MockContainerService_HealthCheck_Call {
357 _c.Call.Return(run)
358 return _c
359}
360
361// List provides a mock function for the type MockContainerService
362func (_mock *MockContainerService) List(ctx context.Context) map[string]*domain.Container {
363 ret := _mock.Called(ctx)
364
365 if len(ret) == 0 {
366 panic("no return value specified for List")
367 }
368
369 var r0 map[string]*domain.Container
370 if returnFunc, ok := ret.Get(0).(func(context.Context) map[string]*domain.Container); ok {
371 r0 = returnFunc(ctx)
372 } else {
373 if ret.Get(0) != nil {
374 r0 = ret.Get(0).(map[string]*domain.Container)
375 }
376 }
377 return r0
378}
379
380// MockContainerService_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List'
381type MockContainerService_List_Call struct {
382 *mock.Call
383}
384
385// List is a helper method to define mock.On call
386// - ctx context.Context
387func (_e *MockContainerService_Expecter) List(ctx interface{}) *MockContainerService_List_Call {
388 return &MockContainerService_List_Call{Call: _e.mock.On("List", ctx)}
389}
390
391func (_c *MockContainerService_List_Call) Run(run func(ctx context.Context)) *MockContainerService_List_Call {
392 _c.Call.Run(func(args mock.Arguments) {
393 var arg0 context.Context
394 if args[0] != nil {
395 arg0 = args[0].(context.Context)
396 }
397 run(
398 arg0,
399 )
400 })
401 return _c
402}
403
404func (_c *MockContainerService_List_Call) Return(stringToContainer map[string]*domain.Container) *MockContainerService_List_Call {
405 _c.Call.Return(stringToContainer)
406 return _c
407}
408
409func (_c *MockContainerService_List_Call) RunAndReturn(run func(ctx context.Context) map[string]*domain.Container) *MockContainerService_List_Call {
410 _c.Call.Return(run)
411 return _c
412}
413
414// ListAttachments provides a mock function for the type MockContainerService
415func (_mock *MockContainerService) ListAttachments(ctx context.Context, domain1 string) []domain.Attachment {
416 ret := _mock.Called(ctx, domain1)
417
418 if len(ret) == 0 {
419 panic("no return value specified for ListAttachments")
420 }
421
422 var r0 []domain.Attachment
423 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []domain.Attachment); ok {
424 r0 = returnFunc(ctx, domain1)
425 } else {
426 if ret.Get(0) != nil {
427 r0 = ret.Get(0).([]domain.Attachment)
428 }
429 }
430 return r0
431}
432
433// MockContainerService_ListAttachments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAttachments'
434type MockContainerService_ListAttachments_Call struct {
435 *mock.Call
436}
437
438// ListAttachments is a helper method to define mock.On call
439// - ctx context.Context
440// - domain1 string
441func (_e *MockContainerService_Expecter) ListAttachments(ctx interface{}, domain1 interface{}) *MockContainerService_ListAttachments_Call {
442 return &MockContainerService_ListAttachments_Call{Call: _e.mock.On("ListAttachments", ctx, domain1)}
443}
444
445func (_c *MockContainerService_ListAttachments_Call) Run(run func(ctx context.Context, domain1 string)) *MockContainerService_ListAttachments_Call {
446 _c.Call.Run(func(args mock.Arguments) {
447 var arg0 context.Context
448 if args[0] != nil {
449 arg0 = args[0].(context.Context)
450 }
451 var arg1 string
452 if args[1] != nil {
453 arg1 = args[1].(string)
454 }
455 run(
456 arg0,
457 arg1,
458 )
459 })
460 return _c
461}
462
463func (_c *MockContainerService_ListAttachments_Call) Return(attachments []domain.Attachment) *MockContainerService_ListAttachments_Call {
464 _c.Call.Return(attachments)
465 return _c
466}
467
468func (_c *MockContainerService_ListAttachments_Call) RunAndReturn(run func(ctx context.Context, domain1 string) []domain.Attachment) *MockContainerService_ListAttachments_Call {
469 _c.Call.Return(run)
470 return _c
471}
472
473// ListNetworks provides a mock function for the type MockContainerService
474func (_mock *MockContainerService) ListNetworks(ctx context.Context) ([]*domain.NetworkInfo, error) {
475 ret := _mock.Called(ctx)
476
477 if len(ret) == 0 {
478 panic("no return value specified for ListNetworks")
479 }
480
481 var r0 []*domain.NetworkInfo
482 var r1 error
483 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*domain.NetworkInfo, error)); ok {
484 return returnFunc(ctx)
485 }
486 if returnFunc, ok := ret.Get(0).(func(context.Context) []*domain.NetworkInfo); ok {
487 r0 = returnFunc(ctx)
488 } else {
489 if ret.Get(0) != nil {
490 r0 = ret.Get(0).([]*domain.NetworkInfo)
491 }
492 }
493 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
494 r1 = returnFunc(ctx)
495 } else {
496 r1 = ret.Error(1)
497 }
498 return r0, r1
499}
500
501// MockContainerService_ListNetworks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListNetworks'
502type MockContainerService_ListNetworks_Call struct {
503 *mock.Call
504}
505
506// ListNetworks is a helper method to define mock.On call
507// - ctx context.Context
508func (_e *MockContainerService_Expecter) ListNetworks(ctx interface{}) *MockContainerService_ListNetworks_Call {
509 return &MockContainerService_ListNetworks_Call{Call: _e.mock.On("ListNetworks", ctx)}
510}
511
512func (_c *MockContainerService_ListNetworks_Call) Run(run func(ctx context.Context)) *MockContainerService_ListNetworks_Call {
513 _c.Call.Run(func(args mock.Arguments) {
514 var arg0 context.Context
515 if args[0] != nil {
516 arg0 = args[0].(context.Context)
517 }
518 run(
519 arg0,
520 )
521 })
522 return _c
523}
524
525func (_c *MockContainerService_ListNetworks_Call) Return(networkInfos []*domain.NetworkInfo, err error) *MockContainerService_ListNetworks_Call {
526 _c.Call.Return(networkInfos, err)
527 return _c
528}
529
530func (_c *MockContainerService_ListNetworks_Call) RunAndReturn(run func(ctx context.Context) ([]*domain.NetworkInfo, error)) *MockContainerService_ListNetworks_Call {
531 _c.Call.Return(run)
532 return _c
533}
534
535// ListOrphanedAttachments provides a mock function for the type MockContainerService
536func (_mock *MockContainerService) ListOrphanedAttachments(ctx context.Context) ([]domain.CleanupAttachment, error) {
537 ret := _mock.Called(ctx)
538
539 if len(ret) == 0 {
540 panic("no return value specified for ListOrphanedAttachments")
541 }
542
543 var r0 []domain.CleanupAttachment
544 var r1 error
545 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]domain.CleanupAttachment, error)); ok {
546 return returnFunc(ctx)
547 }
548 if returnFunc, ok := ret.Get(0).(func(context.Context) []domain.CleanupAttachment); ok {
549 r0 = returnFunc(ctx)
550 } else {
551 if ret.Get(0) != nil {
552 r0 = ret.Get(0).([]domain.CleanupAttachment)
553 }
554 }
555 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
556 r1 = returnFunc(ctx)
557 } else {
558 r1 = ret.Error(1)
559 }
560 return r0, r1
561}
562
563// MockContainerService_ListOrphanedAttachments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOrphanedAttachments'
564type MockContainerService_ListOrphanedAttachments_Call struct {
565 *mock.Call
566}
567
568// ListOrphanedAttachments is a helper method to define mock.On call
569// - ctx context.Context
570func (_e *MockContainerService_Expecter) ListOrphanedAttachments(ctx interface{}) *MockContainerService_ListOrphanedAttachments_Call {
571 return &MockContainerService_ListOrphanedAttachments_Call{Call: _e.mock.On("ListOrphanedAttachments", ctx)}
572}
573
574func (_c *MockContainerService_ListOrphanedAttachments_Call) Run(run func(ctx context.Context)) *MockContainerService_ListOrphanedAttachments_Call {
575 _c.Call.Run(func(args mock.Arguments) {
576 var arg0 context.Context
577 if args[0] != nil {
578 arg0 = args[0].(context.Context)
579 }
580 run(
581 arg0,
582 )
583 })
584 return _c
585}
586
587func (_c *MockContainerService_ListOrphanedAttachments_Call) Return(cleanupAttachments []domain.CleanupAttachment, err error) *MockContainerService_ListOrphanedAttachments_Call {
588 _c.Call.Return(cleanupAttachments, err)
589 return _c
590}
591
592func (_c *MockContainerService_ListOrphanedAttachments_Call) RunAndReturn(run func(ctx context.Context) ([]domain.CleanupAttachment, error)) *MockContainerService_ListOrphanedAttachments_Call {
593 _c.Call.Return(run)
594 return _c
595}
596
597// ListRoutesWithDetails provides a mock function for the type MockContainerService
598func (_mock *MockContainerService) ListRoutesWithDetails(ctx context.Context) []domain.RouteInfo {
599 ret := _mock.Called(ctx)
600
601 if len(ret) == 0 {
602 panic("no return value specified for ListRoutesWithDetails")
603 }
604
605 var r0 []domain.RouteInfo
606 if returnFunc, ok := ret.Get(0).(func(context.Context) []domain.RouteInfo); ok {
607 r0 = returnFunc(ctx)
608 } else {
609 if ret.Get(0) != nil {
610 r0 = ret.Get(0).([]domain.RouteInfo)
611 }
612 }
613 return r0
614}
615
616// MockContainerService_ListRoutesWithDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRoutesWithDetails'
617type MockContainerService_ListRoutesWithDetails_Call struct {
618 *mock.Call
619}
620
621// ListRoutesWithDetails is a helper method to define mock.On call
622// - ctx context.Context
623func (_e *MockContainerService_Expecter) ListRoutesWithDetails(ctx interface{}) *MockContainerService_ListRoutesWithDetails_Call {
624 return &MockContainerService_ListRoutesWithDetails_Call{Call: _e.mock.On("ListRoutesWithDetails", ctx)}
625}
626
627func (_c *MockContainerService_ListRoutesWithDetails_Call) Run(run func(ctx context.Context)) *MockContainerService_ListRoutesWithDetails_Call {
628 _c.Call.Run(func(args mock.Arguments) {
629 var arg0 context.Context
630 if args[0] != nil {
631 arg0 = args[0].(context.Context)
632 }
633 run(
634 arg0,
635 )
636 })
637 return _c
638}
639
640func (_c *MockContainerService_ListRoutesWithDetails_Call) Return(routeInfos []domain.RouteInfo) *MockContainerService_ListRoutesWithDetails_Call {
641 _c.Call.Return(routeInfos)
642 return _c
643}
644
645func (_c *MockContainerService_ListRoutesWithDetails_Call) RunAndReturn(run func(ctx context.Context) []domain.RouteInfo) *MockContainerService_ListRoutesWithDetails_Call {
646 _c.Call.Return(run)
647 return _c
648}
649
650// ReconcileRemovedRoute provides a mock function for the type MockContainerService
651func (_mock *MockContainerService) ReconcileRemovedRoute(ctx context.Context, domain1 string) (*domain.CleanupReport, error) {
652 ret := _mock.Called(ctx, domain1)
653
654 if len(ret) == 0 {
655 panic("no return value specified for ReconcileRemovedRoute")
656 }
657
658 var r0 *domain.CleanupReport
659 var r1 error
660 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*domain.CleanupReport, error)); ok {
661 return returnFunc(ctx, domain1)
662 }
663 if returnFunc, ok := ret.Get(0).(func(context.Context, string) *domain.CleanupReport); ok {
664 r0 = returnFunc(ctx, domain1)
665 } else {
666 if ret.Get(0) != nil {
667 r0 = ret.Get(0).(*domain.CleanupReport)
668 }
669 }
670 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
671 r1 = returnFunc(ctx, domain1)
672 } else {
673 r1 = ret.Error(1)
674 }
675 return r0, r1
676}
677
678// MockContainerService_ReconcileRemovedRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReconcileRemovedRoute'
679type MockContainerService_ReconcileRemovedRoute_Call struct {
680 *mock.Call
681}
682
683// ReconcileRemovedRoute is a helper method to define mock.On call
684// - ctx context.Context
685// - domain1 string
686func (_e *MockContainerService_Expecter) ReconcileRemovedRoute(ctx interface{}, domain1 interface{}) *MockContainerService_ReconcileRemovedRoute_Call {
687 return &MockContainerService_ReconcileRemovedRoute_Call{Call: _e.mock.On("ReconcileRemovedRoute", ctx, domain1)}
688}
689
690func (_c *MockContainerService_ReconcileRemovedRoute_Call) Run(run func(ctx context.Context, domain1 string)) *MockContainerService_ReconcileRemovedRoute_Call {
691 _c.Call.Run(func(args mock.Arguments) {
692 var arg0 context.Context
693 if args[0] != nil {
694 arg0 = args[0].(context.Context)
695 }
696 var arg1 string
697 if args[1] != nil {
698 arg1 = args[1].(string)
699 }
700 run(
701 arg0,
702 arg1,
703 )
704 })
705 return _c
706}
707
708func (_c *MockContainerService_ReconcileRemovedRoute_Call) Return(cleanupReport *domain.CleanupReport, err error) *MockContainerService_ReconcileRemovedRoute_Call {
709 _c.Call.Return(cleanupReport, err)
710 return _c
711}
712
713func (_c *MockContainerService_ReconcileRemovedRoute_Call) RunAndReturn(run func(ctx context.Context, domain1 string) (*domain.CleanupReport, error)) *MockContainerService_ReconcileRemovedRoute_Call {
714 _c.Call.Return(run)
715 return _c
716}
717
718// Remove provides a mock function for the type MockContainerService
719func (_mock *MockContainerService) Remove(ctx context.Context, containerID string, force bool) error {
720 ret := _mock.Called(ctx, containerID, force)
721
722 if len(ret) == 0 {
723 panic("no return value specified for Remove")
724 }
725
726 var r0 error
727 if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) error); ok {
728 r0 = returnFunc(ctx, containerID, force)
729 } else {
730 r0 = ret.Error(0)
731 }
732 return r0
733}
734
735// MockContainerService_Remove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Remove'
736type MockContainerService_Remove_Call struct {
737 *mock.Call
738}
739
740// Remove is a helper method to define mock.On call
741// - ctx context.Context
742// - containerID string
743// - force bool
744func (_e *MockContainerService_Expecter) Remove(ctx interface{}, containerID interface{}, force interface{}) *MockContainerService_Remove_Call {
745 return &MockContainerService_Remove_Call{Call: _e.mock.On("Remove", ctx, containerID, force)}
746}
747
748func (_c *MockContainerService_Remove_Call) Run(run func(ctx context.Context, containerID string, force bool)) *MockContainerService_Remove_Call {
749 _c.Call.Run(func(args mock.Arguments) {
750 var arg0 context.Context
751 if args[0] != nil {
752 arg0 = args[0].(context.Context)
753 }
754 var arg1 string
755 if args[1] != nil {
756 arg1 = args[1].(string)
757 }
758 var arg2 bool
759 if args[2] != nil {
760 arg2 = args[2].(bool)
761 }
762 run(
763 arg0,
764 arg1,
765 arg2,
766 )
767 })
768 return _c
769}
770
771func (_c *MockContainerService_Remove_Call) Return(err error) *MockContainerService_Remove_Call {
772 _c.Call.Return(err)
773 return _c
774}
775
776func (_c *MockContainerService_Remove_Call) RunAndReturn(run func(ctx context.Context, containerID string, force bool) error) *MockContainerService_Remove_Call {
777 _c.Call.Return(run)
778 return _c
779}
780
781// Restart provides a mock function for the type MockContainerService
782func (_mock *MockContainerService) Restart(ctx context.Context, domain1 string, withAttachments bool) error {
783 ret := _mock.Called(ctx, domain1, withAttachments)
784
785 if len(ret) == 0 {
786 panic("no return value specified for Restart")
787 }
788
789 var r0 error
790 if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) error); ok {
791 r0 = returnFunc(ctx, domain1, withAttachments)
792 } else {
793 r0 = ret.Error(0)
794 }
795 return r0
796}
797
798// MockContainerService_Restart_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Restart'
799type MockContainerService_Restart_Call struct {
800 *mock.Call
801}
802
803// Restart is a helper method to define mock.On call
804// - ctx context.Context
805// - domain1 string
806// - withAttachments bool
807func (_e *MockContainerService_Expecter) Restart(ctx interface{}, domain1 interface{}, withAttachments interface{}) *MockContainerService_Restart_Call {
808 return &MockContainerService_Restart_Call{Call: _e.mock.On("Restart", ctx, domain1, withAttachments)}
809}
810
811func (_c *MockContainerService_Restart_Call) Run(run func(ctx context.Context, domain1 string, withAttachments bool)) *MockContainerService_Restart_Call {
812 _c.Call.Run(func(args mock.Arguments) {
813 var arg0 context.Context
814 if args[0] != nil {
815 arg0 = args[0].(context.Context)
816 }
817 var arg1 string
818 if args[1] != nil {
819 arg1 = args[1].(string)
820 }
821 var arg2 bool
822 if args[2] != nil {
823 arg2 = args[2].(bool)
824 }
825 run(
826 arg0,
827 arg1,
828 arg2,
829 )
830 })
831 return _c
832}
833
834func (_c *MockContainerService_Restart_Call) Return(err error) *MockContainerService_Restart_Call {
835 _c.Call.Return(err)
836 return _c
837}
838
839func (_c *MockContainerService_Restart_Call) RunAndReturn(run func(ctx context.Context, domain1 string, withAttachments bool) error) *MockContainerService_Restart_Call {
840 _c.Call.Return(run)
841 return _c
842}
843
844// Shutdown provides a mock function for the type MockContainerService
845func (_mock *MockContainerService) Shutdown(ctx context.Context) error {
846 ret := _mock.Called(ctx)
847
848 if len(ret) == 0 {
849 panic("no return value specified for Shutdown")
850 }
851
852 var r0 error
853 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
854 r0 = returnFunc(ctx)
855 } else {
856 r0 = ret.Error(0)
857 }
858 return r0
859}
860
861// MockContainerService_Shutdown_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Shutdown'
862type MockContainerService_Shutdown_Call struct {
863 *mock.Call
864}
865
866// Shutdown is a helper method to define mock.On call
867// - ctx context.Context
868func (_e *MockContainerService_Expecter) Shutdown(ctx interface{}) *MockContainerService_Shutdown_Call {
869 return &MockContainerService_Shutdown_Call{Call: _e.mock.On("Shutdown", ctx)}
870}
871
872func (_c *MockContainerService_Shutdown_Call) Run(run func(ctx context.Context)) *MockContainerService_Shutdown_Call {
873 _c.Call.Run(func(args mock.Arguments) {
874 var arg0 context.Context
875 if args[0] != nil {
876 arg0 = args[0].(context.Context)
877 }
878 run(
879 arg0,
880 )
881 })
882 return _c
883}
884
885func (_c *MockContainerService_Shutdown_Call) Return(err error) *MockContainerService_Shutdown_Call {
886 _c.Call.Return(err)
887 return _c
888}
889
890func (_c *MockContainerService_Shutdown_Call) RunAndReturn(run func(ctx context.Context) error) *MockContainerService_Shutdown_Call {
891 _c.Call.Return(run)
892 return _c
893}
894
895// Stop provides a mock function for the type MockContainerService
896func (_mock *MockContainerService) Stop(ctx context.Context, containerID string) error {
897 ret := _mock.Called(ctx, containerID)
898
899 if len(ret) == 0 {
900 panic("no return value specified for Stop")
901 }
902
903 var r0 error
904 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
905 r0 = returnFunc(ctx, containerID)
906 } else {
907 r0 = ret.Error(0)
908 }
909 return r0
910}
911
912// MockContainerService_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
913type MockContainerService_Stop_Call struct {
914 *mock.Call
915}
916
917// Stop is a helper method to define mock.On call
918// - ctx context.Context
919// - containerID string
920func (_e *MockContainerService_Expecter) Stop(ctx interface{}, containerID interface{}) *MockContainerService_Stop_Call {
921 return &MockContainerService_Stop_Call{Call: _e.mock.On("Stop", ctx, containerID)}
922}
923
924func (_c *MockContainerService_Stop_Call) Run(run func(ctx context.Context, containerID string)) *MockContainerService_Stop_Call {
925 _c.Call.Run(func(args mock.Arguments) {
926 var arg0 context.Context
927 if args[0] != nil {
928 arg0 = args[0].(context.Context)
929 }
930 var arg1 string
931 if args[1] != nil {
932 arg1 = args[1].(string)
933 }
934 run(
935 arg0,
936 arg1,
937 )
938 })
939 return _c
940}
941
942func (_c *MockContainerService_Stop_Call) Return(err error) *MockContainerService_Stop_Call {
943 _c.Call.Return(err)
944 return _c
945}
946
947func (_c *MockContainerService_Stop_Call) RunAndReturn(run func(ctx context.Context, containerID string) error) *MockContainerService_Stop_Call {
948 _c.Call.Return(run)
949 return _c
950}
951
952// SyncContainers provides a mock function for the type MockContainerService
953func (_mock *MockContainerService) SyncContainers(ctx context.Context) error {
954 ret := _mock.Called(ctx)
955
956 if len(ret) == 0 {
957 panic("no return value specified for SyncContainers")
958 }
959
960 var r0 error
961 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
962 r0 = returnFunc(ctx)
963 } else {
964 r0 = ret.Error(0)
965 }
966 return r0
967}
968
969// MockContainerService_SyncContainers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SyncContainers'
970type MockContainerService_SyncContainers_Call struct {
971 *mock.Call
972}
973
974// SyncContainers is a helper method to define mock.On call
975// - ctx context.Context
976func (_e *MockContainerService_Expecter) SyncContainers(ctx interface{}) *MockContainerService_SyncContainers_Call {
977 return &MockContainerService_SyncContainers_Call{Call: _e.mock.On("SyncContainers", ctx)}
978}
979
980func (_c *MockContainerService_SyncContainers_Call) Run(run func(ctx context.Context)) *MockContainerService_SyncContainers_Call {
981 _c.Call.Run(func(args mock.Arguments) {
982 var arg0 context.Context
983 if args[0] != nil {
984 arg0 = args[0].(context.Context)
985 }
986 run(
987 arg0,
988 )
989 })
990 return _c
991}
992
993func (_c *MockContainerService_SyncContainers_Call) Return(err error) *MockContainerService_SyncContainers_Call {
994 _c.Call.Return(err)
995 return _c
996}
997
998func (_c *MockContainerService_SyncContainers_Call) RunAndReturn(run func(ctx context.Context) error) *MockContainerService_SyncContainers_Call {
999 _c.Call.Return(run)
1000 return _c
1001}
1002
1003// UpdateAttachments provides a mock function for the type MockContainerService
1004func (_mock *MockContainerService) UpdateAttachments(attachments map[string][]string) {
1005 _mock.Called(attachments)
1006 return
1007}
1008
1009// MockContainerService_UpdateAttachments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAttachments'
1010type MockContainerService_UpdateAttachments_Call struct {
1011 *mock.Call
1012}
1013
1014// UpdateAttachments is a helper method to define mock.On call
1015// - attachments map[string][]string
1016func (_e *MockContainerService_Expecter) UpdateAttachments(attachments interface{}) *MockContainerService_UpdateAttachments_Call {
1017 return &MockContainerService_UpdateAttachments_Call{Call: _e.mock.On("UpdateAttachments", attachments)}
1018}
1019
1020func (_c *MockContainerService_UpdateAttachments_Call) Run(run func(attachments map[string][]string)) *MockContainerService_UpdateAttachments_Call {
1021 _c.Call.Run(func(args mock.Arguments) {
1022 var arg0 map[string][]string
1023 if args[0] != nil {
1024 arg0 = args[0].(map[string][]string)
1025 }
1026 run(
1027 arg0,
1028 )
1029 })
1030 return _c
1031}
1032
1033func (_c *MockContainerService_UpdateAttachments_Call) Return() *MockContainerService_UpdateAttachments_Call {
1034 _c.Call.Return()
1035 return _c
1036}
1037
1038func (_c *MockContainerService_UpdateAttachments_Call) RunAndReturn(run func(attachments map[string][]string)) *MockContainerService_UpdateAttachments_Call {
1039 _c.Run(run)
1040 return _c
1041}