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// NewMockConfigService creates a new instance of MockConfigService. 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 NewMockConfigService(t interface {
17 mock.TestingT
18 Cleanup(func())
19}) *MockConfigService {
20 mock := &MockConfigService{}
21 mock.Mock.Test(t)
22
23 t.Cleanup(func() { mock.AssertExpectations(t) })
24
25 return mock
26}
27
28// MockConfigService is an autogenerated mock type for the ConfigService type
29type MockConfigService struct {
30 mock.Mock
31}
32
33type MockConfigService_Expecter struct {
34 mock *mock.Mock
35}
36
37func (_m *MockConfigService) EXPECT() *MockConfigService_Expecter {
38 return &MockConfigService_Expecter{mock: &_m.Mock}
39}
40
41// AddAttachment provides a mock function for the type MockConfigService
42func (_mock *MockConfigService) AddAttachment(ctx context.Context, domainOrGroup string, image string) error {
43 ret := _mock.Called(ctx, domainOrGroup, image)
44
45 if len(ret) == 0 {
46 panic("no return value specified for AddAttachment")
47 }
48
49 var r0 error
50 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
51 r0 = returnFunc(ctx, domainOrGroup, image)
52 } else {
53 r0 = ret.Error(0)
54 }
55 return r0
56}
57
58// MockConfigService_AddAttachment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddAttachment'
59type MockConfigService_AddAttachment_Call struct {
60 *mock.Call
61}
62
63// AddAttachment is a helper method to define mock.On call
64// - ctx context.Context
65// - domainOrGroup string
66// - image string
67func (_e *MockConfigService_Expecter) AddAttachment(ctx interface{}, domainOrGroup interface{}, image interface{}) *MockConfigService_AddAttachment_Call {
68 return &MockConfigService_AddAttachment_Call{Call: _e.mock.On("AddAttachment", ctx, domainOrGroup, image)}
69}
70
71func (_c *MockConfigService_AddAttachment_Call) Run(run func(ctx context.Context, domainOrGroup string, image string)) *MockConfigService_AddAttachment_Call {
72 _c.Call.Run(func(args mock.Arguments) {
73 var arg0 context.Context
74 if args[0] != nil {
75 arg0 = args[0].(context.Context)
76 }
77 var arg1 string
78 if args[1] != nil {
79 arg1 = args[1].(string)
80 }
81 var arg2 string
82 if args[2] != nil {
83 arg2 = args[2].(string)
84 }
85 run(
86 arg0,
87 arg1,
88 arg2,
89 )
90 })
91 return _c
92}
93
94func (_c *MockConfigService_AddAttachment_Call) Return(err error) *MockConfigService_AddAttachment_Call {
95 _c.Call.Return(err)
96 return _c
97}
98
99func (_c *MockConfigService_AddAttachment_Call) RunAndReturn(run func(ctx context.Context, domainOrGroup string, image string) error) *MockConfigService_AddAttachment_Call {
100 _c.Call.Return(run)
101 return _c
102}
103
104// AddRoute provides a mock function for the type MockConfigService
105func (_mock *MockConfigService) AddRoute(ctx context.Context, route domain.Route) error {
106 ret := _mock.Called(ctx, route)
107
108 if len(ret) == 0 {
109 panic("no return value specified for AddRoute")
110 }
111
112 var r0 error
113 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Route) error); ok {
114 r0 = returnFunc(ctx, route)
115 } else {
116 r0 = ret.Error(0)
117 }
118 return r0
119}
120
121// MockConfigService_AddRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddRoute'
122type MockConfigService_AddRoute_Call struct {
123 *mock.Call
124}
125
126// AddRoute is a helper method to define mock.On call
127// - ctx context.Context
128// - route domain.Route
129func (_e *MockConfigService_Expecter) AddRoute(ctx interface{}, route interface{}) *MockConfigService_AddRoute_Call {
130 return &MockConfigService_AddRoute_Call{Call: _e.mock.On("AddRoute", ctx, route)}
131}
132
133func (_c *MockConfigService_AddRoute_Call) Run(run func(ctx context.Context, route domain.Route)) *MockConfigService_AddRoute_Call {
134 _c.Call.Run(func(args mock.Arguments) {
135 var arg0 context.Context
136 if args[0] != nil {
137 arg0 = args[0].(context.Context)
138 }
139 var arg1 domain.Route
140 if args[1] != nil {
141 arg1 = args[1].(domain.Route)
142 }
143 run(
144 arg0,
145 arg1,
146 )
147 })
148 return _c
149}
150
151func (_c *MockConfigService_AddRoute_Call) Return(err error) *MockConfigService_AddRoute_Call {
152 _c.Call.Return(err)
153 return _c
154}
155
156func (_c *MockConfigService_AddRoute_Call) RunAndReturn(run func(ctx context.Context, route domain.Route) error) *MockConfigService_AddRoute_Call {
157 _c.Call.Return(run)
158 return _c
159}
160
161// GetAllAttachments provides a mock function for the type MockConfigService
162func (_mock *MockConfigService) GetAllAttachments(ctx context.Context) map[string][]string {
163 ret := _mock.Called(ctx)
164
165 if len(ret) == 0 {
166 panic("no return value specified for GetAllAttachments")
167 }
168
169 var r0 map[string][]string
170 if returnFunc, ok := ret.Get(0).(func(context.Context) map[string][]string); ok {
171 r0 = returnFunc(ctx)
172 } else {
173 if ret.Get(0) != nil {
174 r0 = ret.Get(0).(map[string][]string)
175 }
176 }
177 return r0
178}
179
180// MockConfigService_GetAllAttachments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllAttachments'
181type MockConfigService_GetAllAttachments_Call struct {
182 *mock.Call
183}
184
185// GetAllAttachments is a helper method to define mock.On call
186// - ctx context.Context
187func (_e *MockConfigService_Expecter) GetAllAttachments(ctx interface{}) *MockConfigService_GetAllAttachments_Call {
188 return &MockConfigService_GetAllAttachments_Call{Call: _e.mock.On("GetAllAttachments", ctx)}
189}
190
191func (_c *MockConfigService_GetAllAttachments_Call) Run(run func(ctx context.Context)) *MockConfigService_GetAllAttachments_Call {
192 _c.Call.Run(func(args mock.Arguments) {
193 var arg0 context.Context
194 if args[0] != nil {
195 arg0 = args[0].(context.Context)
196 }
197 run(
198 arg0,
199 )
200 })
201 return _c
202}
203
204func (_c *MockConfigService_GetAllAttachments_Call) Return(stringToStrings map[string][]string) *MockConfigService_GetAllAttachments_Call {
205 _c.Call.Return(stringToStrings)
206 return _c
207}
208
209func (_c *MockConfigService_GetAllAttachments_Call) RunAndReturn(run func(ctx context.Context) map[string][]string) *MockConfigService_GetAllAttachments_Call {
210 _c.Call.Return(run)
211 return _c
212}
213
214// GetAttachmentsFor provides a mock function for the type MockConfigService
215func (_mock *MockConfigService) GetAttachmentsFor(ctx context.Context, domainOrGroup string) ([]string, error) {
216 ret := _mock.Called(ctx, domainOrGroup)
217
218 if len(ret) == 0 {
219 panic("no return value specified for GetAttachmentsFor")
220 }
221
222 var r0 []string
223 var r1 error
224 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]string, error)); ok {
225 return returnFunc(ctx, domainOrGroup)
226 }
227 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []string); ok {
228 r0 = returnFunc(ctx, domainOrGroup)
229 } else {
230 if ret.Get(0) != nil {
231 r0 = ret.Get(0).([]string)
232 }
233 }
234 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
235 r1 = returnFunc(ctx, domainOrGroup)
236 } else {
237 r1 = ret.Error(1)
238 }
239 return r0, r1
240}
241
242// MockConfigService_GetAttachmentsFor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAttachmentsFor'
243type MockConfigService_GetAttachmentsFor_Call struct {
244 *mock.Call
245}
246
247// GetAttachmentsFor is a helper method to define mock.On call
248// - ctx context.Context
249// - domainOrGroup string
250func (_e *MockConfigService_Expecter) GetAttachmentsFor(ctx interface{}, domainOrGroup interface{}) *MockConfigService_GetAttachmentsFor_Call {
251 return &MockConfigService_GetAttachmentsFor_Call{Call: _e.mock.On("GetAttachmentsFor", ctx, domainOrGroup)}
252}
253
254func (_c *MockConfigService_GetAttachmentsFor_Call) Run(run func(ctx context.Context, domainOrGroup string)) *MockConfigService_GetAttachmentsFor_Call {
255 _c.Call.Run(func(args mock.Arguments) {
256 var arg0 context.Context
257 if args[0] != nil {
258 arg0 = args[0].(context.Context)
259 }
260 var arg1 string
261 if args[1] != nil {
262 arg1 = args[1].(string)
263 }
264 run(
265 arg0,
266 arg1,
267 )
268 })
269 return _c
270}
271
272func (_c *MockConfigService_GetAttachmentsFor_Call) Return(strings []string, err error) *MockConfigService_GetAttachmentsFor_Call {
273 _c.Call.Return(strings, err)
274 return _c
275}
276
277func (_c *MockConfigService_GetAttachmentsFor_Call) RunAndReturn(run func(ctx context.Context, domainOrGroup string) ([]string, error)) *MockConfigService_GetAttachmentsFor_Call {
278 _c.Call.Return(run)
279 return _c
280}
281
282// GetDataDir provides a mock function for the type MockConfigService
283func (_mock *MockConfigService) GetDataDir() string {
284 ret := _mock.Called()
285
286 if len(ret) == 0 {
287 panic("no return value specified for GetDataDir")
288 }
289
290 var r0 string
291 if returnFunc, ok := ret.Get(0).(func() string); ok {
292 r0 = returnFunc()
293 } else {
294 r0 = ret.Get(0).(string)
295 }
296 return r0
297}
298
299// MockConfigService_GetDataDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDataDir'
300type MockConfigService_GetDataDir_Call struct {
301 *mock.Call
302}
303
304// GetDataDir is a helper method to define mock.On call
305func (_e *MockConfigService_Expecter) GetDataDir() *MockConfigService_GetDataDir_Call {
306 return &MockConfigService_GetDataDir_Call{Call: _e.mock.On("GetDataDir")}
307}
308
309func (_c *MockConfigService_GetDataDir_Call) Run(run func()) *MockConfigService_GetDataDir_Call {
310 _c.Call.Run(func(args mock.Arguments) {
311 run()
312 })
313 return _c
314}
315
316func (_c *MockConfigService_GetDataDir_Call) Return(s string) *MockConfigService_GetDataDir_Call {
317 _c.Call.Return(s)
318 return _c
319}
320
321func (_c *MockConfigService_GetDataDir_Call) RunAndReturn(run func() string) *MockConfigService_GetDataDir_Call {
322 _c.Call.Return(run)
323 return _c
324}
325
326// GetExternalRoutes provides a mock function for the type MockConfigService
327func (_mock *MockConfigService) GetExternalRoutes() map[string]string {
328 ret := _mock.Called()
329
330 if len(ret) == 0 {
331 panic("no return value specified for GetExternalRoutes")
332 }
333
334 var r0 map[string]string
335 if returnFunc, ok := ret.Get(0).(func() map[string]string); ok {
336 r0 = returnFunc()
337 } else {
338 if ret.Get(0) != nil {
339 r0 = ret.Get(0).(map[string]string)
340 }
341 }
342 return r0
343}
344
345// MockConfigService_GetExternalRoutes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetExternalRoutes'
346type MockConfigService_GetExternalRoutes_Call struct {
347 *mock.Call
348}
349
350// GetExternalRoutes is a helper method to define mock.On call
351func (_e *MockConfigService_Expecter) GetExternalRoutes() *MockConfigService_GetExternalRoutes_Call {
352 return &MockConfigService_GetExternalRoutes_Call{Call: _e.mock.On("GetExternalRoutes")}
353}
354
355func (_c *MockConfigService_GetExternalRoutes_Call) Run(run func()) *MockConfigService_GetExternalRoutes_Call {
356 _c.Call.Run(func(args mock.Arguments) {
357 run()
358 })
359 return _c
360}
361
362func (_c *MockConfigService_GetExternalRoutes_Call) Return(stringToString map[string]string) *MockConfigService_GetExternalRoutes_Call {
363 _c.Call.Return(stringToString)
364 return _c
365}
366
367func (_c *MockConfigService_GetExternalRoutes_Call) RunAndReturn(run func() map[string]string) *MockConfigService_GetExternalRoutes_Call {
368 _c.Call.Return(run)
369 return _c
370}
371
372// GetNetworkPrefix provides a mock function for the type MockConfigService
373func (_mock *MockConfigService) GetNetworkPrefix() string {
374 ret := _mock.Called()
375
376 if len(ret) == 0 {
377 panic("no return value specified for GetNetworkPrefix")
378 }
379
380 var r0 string
381 if returnFunc, ok := ret.Get(0).(func() string); ok {
382 r0 = returnFunc()
383 } else {
384 r0 = ret.Get(0).(string)
385 }
386 return r0
387}
388
389// MockConfigService_GetNetworkPrefix_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNetworkPrefix'
390type MockConfigService_GetNetworkPrefix_Call struct {
391 *mock.Call
392}
393
394// GetNetworkPrefix is a helper method to define mock.On call
395func (_e *MockConfigService_Expecter) GetNetworkPrefix() *MockConfigService_GetNetworkPrefix_Call {
396 return &MockConfigService_GetNetworkPrefix_Call{Call: _e.mock.On("GetNetworkPrefix")}
397}
398
399func (_c *MockConfigService_GetNetworkPrefix_Call) Run(run func()) *MockConfigService_GetNetworkPrefix_Call {
400 _c.Call.Run(func(args mock.Arguments) {
401 run()
402 })
403 return _c
404}
405
406func (_c *MockConfigService_GetNetworkPrefix_Call) Return(s string) *MockConfigService_GetNetworkPrefix_Call {
407 _c.Call.Return(s)
408 return _c
409}
410
411func (_c *MockConfigService_GetNetworkPrefix_Call) RunAndReturn(run func() string) *MockConfigService_GetNetworkPrefix_Call {
412 _c.Call.Return(run)
413 return _c
414}
415
416// GetRegistryDomain provides a mock function for the type MockConfigService
417func (_mock *MockConfigService) GetRegistryDomain() string {
418 ret := _mock.Called()
419
420 if len(ret) == 0 {
421 panic("no return value specified for GetRegistryDomain")
422 }
423
424 var r0 string
425 if returnFunc, ok := ret.Get(0).(func() string); ok {
426 r0 = returnFunc()
427 } else {
428 r0 = ret.Get(0).(string)
429 }
430 return r0
431}
432
433// MockConfigService_GetRegistryDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRegistryDomain'
434type MockConfigService_GetRegistryDomain_Call struct {
435 *mock.Call
436}
437
438// GetRegistryDomain is a helper method to define mock.On call
439func (_e *MockConfigService_Expecter) GetRegistryDomain() *MockConfigService_GetRegistryDomain_Call {
440 return &MockConfigService_GetRegistryDomain_Call{Call: _e.mock.On("GetRegistryDomain")}
441}
442
443func (_c *MockConfigService_GetRegistryDomain_Call) Run(run func()) *MockConfigService_GetRegistryDomain_Call {
444 _c.Call.Run(func(args mock.Arguments) {
445 run()
446 })
447 return _c
448}
449
450func (_c *MockConfigService_GetRegistryDomain_Call) Return(s string) *MockConfigService_GetRegistryDomain_Call {
451 _c.Call.Return(s)
452 return _c
453}
454
455func (_c *MockConfigService_GetRegistryDomain_Call) RunAndReturn(run func() string) *MockConfigService_GetRegistryDomain_Call {
456 _c.Call.Return(run)
457 return _c
458}
459
460// GetRegistryPort provides a mock function for the type MockConfigService
461func (_mock *MockConfigService) GetRegistryPort() int {
462 ret := _mock.Called()
463
464 if len(ret) == 0 {
465 panic("no return value specified for GetRegistryPort")
466 }
467
468 var r0 int
469 if returnFunc, ok := ret.Get(0).(func() int); ok {
470 r0 = returnFunc()
471 } else {
472 r0 = ret.Get(0).(int)
473 }
474 return r0
475}
476
477// MockConfigService_GetRegistryPort_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRegistryPort'
478type MockConfigService_GetRegistryPort_Call struct {
479 *mock.Call
480}
481
482// GetRegistryPort is a helper method to define mock.On call
483func (_e *MockConfigService_Expecter) GetRegistryPort() *MockConfigService_GetRegistryPort_Call {
484 return &MockConfigService_GetRegistryPort_Call{Call: _e.mock.On("GetRegistryPort")}
485}
486
487func (_c *MockConfigService_GetRegistryPort_Call) Run(run func()) *MockConfigService_GetRegistryPort_Call {
488 _c.Call.Run(func(args mock.Arguments) {
489 run()
490 })
491 return _c
492}
493
494func (_c *MockConfigService_GetRegistryPort_Call) Return(n int) *MockConfigService_GetRegistryPort_Call {
495 _c.Call.Return(n)
496 return _c
497}
498
499func (_c *MockConfigService_GetRegistryPort_Call) RunAndReturn(run func() int) *MockConfigService_GetRegistryPort_Call {
500 _c.Call.Return(run)
501 return _c
502}
503
504// GetRoute provides a mock function for the type MockConfigService
505func (_mock *MockConfigService) GetRoute(ctx context.Context, domain1 string) (*domain.Route, error) {
506 ret := _mock.Called(ctx, domain1)
507
508 if len(ret) == 0 {
509 panic("no return value specified for GetRoute")
510 }
511
512 var r0 *domain.Route
513 var r1 error
514 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*domain.Route, error)); ok {
515 return returnFunc(ctx, domain1)
516 }
517 if returnFunc, ok := ret.Get(0).(func(context.Context, string) *domain.Route); ok {
518 r0 = returnFunc(ctx, domain1)
519 } else {
520 if ret.Get(0) != nil {
521 r0 = ret.Get(0).(*domain.Route)
522 }
523 }
524 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
525 r1 = returnFunc(ctx, domain1)
526 } else {
527 r1 = ret.Error(1)
528 }
529 return r0, r1
530}
531
532// MockConfigService_GetRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRoute'
533type MockConfigService_GetRoute_Call struct {
534 *mock.Call
535}
536
537// GetRoute is a helper method to define mock.On call
538// - ctx context.Context
539// - domain1 string
540func (_e *MockConfigService_Expecter) GetRoute(ctx interface{}, domain1 interface{}) *MockConfigService_GetRoute_Call {
541 return &MockConfigService_GetRoute_Call{Call: _e.mock.On("GetRoute", ctx, domain1)}
542}
543
544func (_c *MockConfigService_GetRoute_Call) Run(run func(ctx context.Context, domain1 string)) *MockConfigService_GetRoute_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 run(
555 arg0,
556 arg1,
557 )
558 })
559 return _c
560}
561
562func (_c *MockConfigService_GetRoute_Call) Return(route *domain.Route, err error) *MockConfigService_GetRoute_Call {
563 _c.Call.Return(route, err)
564 return _c
565}
566
567func (_c *MockConfigService_GetRoute_Call) RunAndReturn(run func(ctx context.Context, domain1 string) (*domain.Route, error)) *MockConfigService_GetRoute_Call {
568 _c.Call.Return(run)
569 return _c
570}
571
572// GetRoutes provides a mock function for the type MockConfigService
573func (_mock *MockConfigService) GetRoutes(ctx context.Context) []domain.Route {
574 ret := _mock.Called(ctx)
575
576 if len(ret) == 0 {
577 panic("no return value specified for GetRoutes")
578 }
579
580 var r0 []domain.Route
581 if returnFunc, ok := ret.Get(0).(func(context.Context) []domain.Route); ok {
582 r0 = returnFunc(ctx)
583 } else {
584 if ret.Get(0) != nil {
585 r0 = ret.Get(0).([]domain.Route)
586 }
587 }
588 return r0
589}
590
591// MockConfigService_GetRoutes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRoutes'
592type MockConfigService_GetRoutes_Call struct {
593 *mock.Call
594}
595
596// GetRoutes is a helper method to define mock.On call
597// - ctx context.Context
598func (_e *MockConfigService_Expecter) GetRoutes(ctx interface{}) *MockConfigService_GetRoutes_Call {
599 return &MockConfigService_GetRoutes_Call{Call: _e.mock.On("GetRoutes", ctx)}
600}
601
602func (_c *MockConfigService_GetRoutes_Call) Run(run func(ctx context.Context)) *MockConfigService_GetRoutes_Call {
603 _c.Call.Run(func(args mock.Arguments) {
604 var arg0 context.Context
605 if args[0] != nil {
606 arg0 = args[0].(context.Context)
607 }
608 run(
609 arg0,
610 )
611 })
612 return _c
613}
614
615func (_c *MockConfigService_GetRoutes_Call) Return(routes []domain.Route) *MockConfigService_GetRoutes_Call {
616 _c.Call.Return(routes)
617 return _c
618}
619
620func (_c *MockConfigService_GetRoutes_Call) RunAndReturn(run func(ctx context.Context) []domain.Route) *MockConfigService_GetRoutes_Call {
621 _c.Call.Return(run)
622 return _c
623}
624
625// GetServerPort provides a mock function for the type MockConfigService
626func (_mock *MockConfigService) GetServerPort() int {
627 ret := _mock.Called()
628
629 if len(ret) == 0 {
630 panic("no return value specified for GetServerPort")
631 }
632
633 var r0 int
634 if returnFunc, ok := ret.Get(0).(func() int); ok {
635 r0 = returnFunc()
636 } else {
637 r0 = ret.Get(0).(int)
638 }
639 return r0
640}
641
642// MockConfigService_GetServerPort_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServerPort'
643type MockConfigService_GetServerPort_Call struct {
644 *mock.Call
645}
646
647// GetServerPort is a helper method to define mock.On call
648func (_e *MockConfigService_Expecter) GetServerPort() *MockConfigService_GetServerPort_Call {
649 return &MockConfigService_GetServerPort_Call{Call: _e.mock.On("GetServerPort")}
650}
651
652func (_c *MockConfigService_GetServerPort_Call) Run(run func()) *MockConfigService_GetServerPort_Call {
653 _c.Call.Run(func(args mock.Arguments) {
654 run()
655 })
656 return _c
657}
658
659func (_c *MockConfigService_GetServerPort_Call) Return(n int) *MockConfigService_GetServerPort_Call {
660 _c.Call.Return(n)
661 return _c
662}
663
664func (_c *MockConfigService_GetServerPort_Call) RunAndReturn(run func() int) *MockConfigService_GetServerPort_Call {
665 _c.Call.Return(run)
666 return _c
667}
668
669// IsAutoRouteEnabled provides a mock function for the type MockConfigService
670func (_mock *MockConfigService) IsAutoRouteEnabled() bool {
671 ret := _mock.Called()
672
673 if len(ret) == 0 {
674 panic("no return value specified for IsAutoRouteEnabled")
675 }
676
677 var r0 bool
678 if returnFunc, ok := ret.Get(0).(func() bool); ok {
679 r0 = returnFunc()
680 } else {
681 r0 = ret.Get(0).(bool)
682 }
683 return r0
684}
685
686// MockConfigService_IsAutoRouteEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsAutoRouteEnabled'
687type MockConfigService_IsAutoRouteEnabled_Call struct {
688 *mock.Call
689}
690
691// IsAutoRouteEnabled is a helper method to define mock.On call
692func (_e *MockConfigService_Expecter) IsAutoRouteEnabled() *MockConfigService_IsAutoRouteEnabled_Call {
693 return &MockConfigService_IsAutoRouteEnabled_Call{Call: _e.mock.On("IsAutoRouteEnabled")}
694}
695
696func (_c *MockConfigService_IsAutoRouteEnabled_Call) Run(run func()) *MockConfigService_IsAutoRouteEnabled_Call {
697 _c.Call.Run(func(args mock.Arguments) {
698 run()
699 })
700 return _c
701}
702
703func (_c *MockConfigService_IsAutoRouteEnabled_Call) Return(b bool) *MockConfigService_IsAutoRouteEnabled_Call {
704 _c.Call.Return(b)
705 return _c
706}
707
708func (_c *MockConfigService_IsAutoRouteEnabled_Call) RunAndReturn(run func() bool) *MockConfigService_IsAutoRouteEnabled_Call {
709 _c.Call.Return(run)
710 return _c
711}
712
713// IsNetworkIsolationEnabled provides a mock function for the type MockConfigService
714func (_mock *MockConfigService) IsNetworkIsolationEnabled() bool {
715 ret := _mock.Called()
716
717 if len(ret) == 0 {
718 panic("no return value specified for IsNetworkIsolationEnabled")
719 }
720
721 var r0 bool
722 if returnFunc, ok := ret.Get(0).(func() bool); ok {
723 r0 = returnFunc()
724 } else {
725 r0 = ret.Get(0).(bool)
726 }
727 return r0
728}
729
730// MockConfigService_IsNetworkIsolationEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsNetworkIsolationEnabled'
731type MockConfigService_IsNetworkIsolationEnabled_Call struct {
732 *mock.Call
733}
734
735// IsNetworkIsolationEnabled is a helper method to define mock.On call
736func (_e *MockConfigService_Expecter) IsNetworkIsolationEnabled() *MockConfigService_IsNetworkIsolationEnabled_Call {
737 return &MockConfigService_IsNetworkIsolationEnabled_Call{Call: _e.mock.On("IsNetworkIsolationEnabled")}
738}
739
740func (_c *MockConfigService_IsNetworkIsolationEnabled_Call) Run(run func()) *MockConfigService_IsNetworkIsolationEnabled_Call {
741 _c.Call.Run(func(args mock.Arguments) {
742 run()
743 })
744 return _c
745}
746
747func (_c *MockConfigService_IsNetworkIsolationEnabled_Call) Return(b bool) *MockConfigService_IsNetworkIsolationEnabled_Call {
748 _c.Call.Return(b)
749 return _c
750}
751
752func (_c *MockConfigService_IsNetworkIsolationEnabled_Call) RunAndReturn(run func() bool) *MockConfigService_IsNetworkIsolationEnabled_Call {
753 _c.Call.Return(run)
754 return _c
755}
756
757// Load provides a mock function for the type MockConfigService
758func (_mock *MockConfigService) Load(ctx context.Context) error {
759 ret := _mock.Called(ctx)
760
761 if len(ret) == 0 {
762 panic("no return value specified for Load")
763 }
764
765 var r0 error
766 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
767 r0 = returnFunc(ctx)
768 } else {
769 r0 = ret.Error(0)
770 }
771 return r0
772}
773
774// MockConfigService_Load_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Load'
775type MockConfigService_Load_Call struct {
776 *mock.Call
777}
778
779// Load is a helper method to define mock.On call
780// - ctx context.Context
781func (_e *MockConfigService_Expecter) Load(ctx interface{}) *MockConfigService_Load_Call {
782 return &MockConfigService_Load_Call{Call: _e.mock.On("Load", ctx)}
783}
784
785func (_c *MockConfigService_Load_Call) Run(run func(ctx context.Context)) *MockConfigService_Load_Call {
786 _c.Call.Run(func(args mock.Arguments) {
787 var arg0 context.Context
788 if args[0] != nil {
789 arg0 = args[0].(context.Context)
790 }
791 run(
792 arg0,
793 )
794 })
795 return _c
796}
797
798func (_c *MockConfigService_Load_Call) Return(err error) *MockConfigService_Load_Call {
799 _c.Call.Return(err)
800 return _c
801}
802
803func (_c *MockConfigService_Load_Call) RunAndReturn(run func(ctx context.Context) error) *MockConfigService_Load_Call {
804 _c.Call.Return(run)
805 return _c
806}
807
808// Reload provides a mock function for the type MockConfigService
809func (_mock *MockConfigService) Reload(ctx context.Context) error {
810 ret := _mock.Called(ctx)
811
812 if len(ret) == 0 {
813 panic("no return value specified for Reload")
814 }
815
816 var r0 error
817 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
818 r0 = returnFunc(ctx)
819 } else {
820 r0 = ret.Error(0)
821 }
822 return r0
823}
824
825// MockConfigService_Reload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reload'
826type MockConfigService_Reload_Call struct {
827 *mock.Call
828}
829
830// Reload is a helper method to define mock.On call
831// - ctx context.Context
832func (_e *MockConfigService_Expecter) Reload(ctx interface{}) *MockConfigService_Reload_Call {
833 return &MockConfigService_Reload_Call{Call: _e.mock.On("Reload", ctx)}
834}
835
836func (_c *MockConfigService_Reload_Call) Run(run func(ctx context.Context)) *MockConfigService_Reload_Call {
837 _c.Call.Run(func(args mock.Arguments) {
838 var arg0 context.Context
839 if args[0] != nil {
840 arg0 = args[0].(context.Context)
841 }
842 run(
843 arg0,
844 )
845 })
846 return _c
847}
848
849func (_c *MockConfigService_Reload_Call) Return(err error) *MockConfigService_Reload_Call {
850 _c.Call.Return(err)
851 return _c
852}
853
854func (_c *MockConfigService_Reload_Call) RunAndReturn(run func(ctx context.Context) error) *MockConfigService_Reload_Call {
855 _c.Call.Return(run)
856 return _c
857}
858
859// RemoveAttachment provides a mock function for the type MockConfigService
860func (_mock *MockConfigService) RemoveAttachment(ctx context.Context, domainOrGroup string, image string) error {
861 ret := _mock.Called(ctx, domainOrGroup, image)
862
863 if len(ret) == 0 {
864 panic("no return value specified for RemoveAttachment")
865 }
866
867 var r0 error
868 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
869 r0 = returnFunc(ctx, domainOrGroup, image)
870 } else {
871 r0 = ret.Error(0)
872 }
873 return r0
874}
875
876// MockConfigService_RemoveAttachment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAttachment'
877type MockConfigService_RemoveAttachment_Call struct {
878 *mock.Call
879}
880
881// RemoveAttachment is a helper method to define mock.On call
882// - ctx context.Context
883// - domainOrGroup string
884// - image string
885func (_e *MockConfigService_Expecter) RemoveAttachment(ctx interface{}, domainOrGroup interface{}, image interface{}) *MockConfigService_RemoveAttachment_Call {
886 return &MockConfigService_RemoveAttachment_Call{Call: _e.mock.On("RemoveAttachment", ctx, domainOrGroup, image)}
887}
888
889func (_c *MockConfigService_RemoveAttachment_Call) Run(run func(ctx context.Context, domainOrGroup string, image string)) *MockConfigService_RemoveAttachment_Call {
890 _c.Call.Run(func(args mock.Arguments) {
891 var arg0 context.Context
892 if args[0] != nil {
893 arg0 = args[0].(context.Context)
894 }
895 var arg1 string
896 if args[1] != nil {
897 arg1 = args[1].(string)
898 }
899 var arg2 string
900 if args[2] != nil {
901 arg2 = args[2].(string)
902 }
903 run(
904 arg0,
905 arg1,
906 arg2,
907 )
908 })
909 return _c
910}
911
912func (_c *MockConfigService_RemoveAttachment_Call) Return(err error) *MockConfigService_RemoveAttachment_Call {
913 _c.Call.Return(err)
914 return _c
915}
916
917func (_c *MockConfigService_RemoveAttachment_Call) RunAndReturn(run func(ctx context.Context, domainOrGroup string, image string) error) *MockConfigService_RemoveAttachment_Call {
918 _c.Call.Return(run)
919 return _c
920}
921
922// RemoveRoute provides a mock function for the type MockConfigService
923func (_mock *MockConfigService) RemoveRoute(ctx context.Context, domain1 string) error {
924 ret := _mock.Called(ctx, domain1)
925
926 if len(ret) == 0 {
927 panic("no return value specified for RemoveRoute")
928 }
929
930 var r0 error
931 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
932 r0 = returnFunc(ctx, domain1)
933 } else {
934 r0 = ret.Error(0)
935 }
936 return r0
937}
938
939// MockConfigService_RemoveRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRoute'
940type MockConfigService_RemoveRoute_Call struct {
941 *mock.Call
942}
943
944// RemoveRoute is a helper method to define mock.On call
945// - ctx context.Context
946// - domain1 string
947func (_e *MockConfigService_Expecter) RemoveRoute(ctx interface{}, domain1 interface{}) *MockConfigService_RemoveRoute_Call {
948 return &MockConfigService_RemoveRoute_Call{Call: _e.mock.On("RemoveRoute", ctx, domain1)}
949}
950
951func (_c *MockConfigService_RemoveRoute_Call) Run(run func(ctx context.Context, domain1 string)) *MockConfigService_RemoveRoute_Call {
952 _c.Call.Run(func(args mock.Arguments) {
953 var arg0 context.Context
954 if args[0] != nil {
955 arg0 = args[0].(context.Context)
956 }
957 var arg1 string
958 if args[1] != nil {
959 arg1 = args[1].(string)
960 }
961 run(
962 arg0,
963 arg1,
964 )
965 })
966 return _c
967}
968
969func (_c *MockConfigService_RemoveRoute_Call) Return(err error) *MockConfigService_RemoveRoute_Call {
970 _c.Call.Return(err)
971 return _c
972}
973
974func (_c *MockConfigService_RemoveRoute_Call) RunAndReturn(run func(ctx context.Context, domain1 string) error) *MockConfigService_RemoveRoute_Call {
975 _c.Call.Return(run)
976 return _c
977}
978
979// Save provides a mock function for the type MockConfigService
980func (_mock *MockConfigService) Save(ctx context.Context) error {
981 ret := _mock.Called(ctx)
982
983 if len(ret) == 0 {
984 panic("no return value specified for Save")
985 }
986
987 var r0 error
988 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
989 r0 = returnFunc(ctx)
990 } else {
991 r0 = ret.Error(0)
992 }
993 return r0
994}
995
996// MockConfigService_Save_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Save'
997type MockConfigService_Save_Call struct {
998 *mock.Call
999}
1000
1001// Save is a helper method to define mock.On call
1002// - ctx context.Context
1003func (_e *MockConfigService_Expecter) Save(ctx interface{}) *MockConfigService_Save_Call {
1004 return &MockConfigService_Save_Call{Call: _e.mock.On("Save", ctx)}
1005}
1006
1007func (_c *MockConfigService_Save_Call) Run(run func(ctx context.Context)) *MockConfigService_Save_Call {
1008 _c.Call.Run(func(args mock.Arguments) {
1009 var arg0 context.Context
1010 if args[0] != nil {
1011 arg0 = args[0].(context.Context)
1012 }
1013 run(
1014 arg0,
1015 )
1016 })
1017 return _c
1018}
1019
1020func (_c *MockConfigService_Save_Call) Return(err error) *MockConfigService_Save_Call {
1021 _c.Call.Return(err)
1022 return _c
1023}
1024
1025func (_c *MockConfigService_Save_Call) RunAndReturn(run func(ctx context.Context) error) *MockConfigService_Save_Call {
1026 _c.Call.Return(run)
1027 return _c
1028}
1029
1030// UpdateRoute provides a mock function for the type MockConfigService
1031func (_mock *MockConfigService) UpdateRoute(ctx context.Context, route domain.Route) error {
1032 ret := _mock.Called(ctx, route)
1033
1034 if len(ret) == 0 {
1035 panic("no return value specified for UpdateRoute")
1036 }
1037
1038 var r0 error
1039 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Route) error); ok {
1040 r0 = returnFunc(ctx, route)
1041 } else {
1042 r0 = ret.Error(0)
1043 }
1044 return r0
1045}
1046
1047// MockConfigService_UpdateRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRoute'
1048type MockConfigService_UpdateRoute_Call struct {
1049 *mock.Call
1050}
1051
1052// UpdateRoute is a helper method to define mock.On call
1053// - ctx context.Context
1054// - route domain.Route
1055func (_e *MockConfigService_Expecter) UpdateRoute(ctx interface{}, route interface{}) *MockConfigService_UpdateRoute_Call {
1056 return &MockConfigService_UpdateRoute_Call{Call: _e.mock.On("UpdateRoute", ctx, route)}
1057}
1058
1059func (_c *MockConfigService_UpdateRoute_Call) Run(run func(ctx context.Context, route domain.Route)) *MockConfigService_UpdateRoute_Call {
1060 _c.Call.Run(func(args mock.Arguments) {
1061 var arg0 context.Context
1062 if args[0] != nil {
1063 arg0 = args[0].(context.Context)
1064 }
1065 var arg1 domain.Route
1066 if args[1] != nil {
1067 arg1 = args[1].(domain.Route)
1068 }
1069 run(
1070 arg0,
1071 arg1,
1072 )
1073 })
1074 return _c
1075}
1076
1077func (_c *MockConfigService_UpdateRoute_Call) Return(err error) *MockConfigService_UpdateRoute_Call {
1078 _c.Call.Return(err)
1079 return _c
1080}
1081
1082func (_c *MockConfigService_UpdateRoute_Call) RunAndReturn(run func(ctx context.Context, route domain.Route) error) *MockConfigService_UpdateRoute_Call {
1083 _c.Call.Return(run)
1084 return _c
1085}
1086
1087// Watch provides a mock function for the type MockConfigService
1088func (_mock *MockConfigService) Watch(ctx context.Context, onChange func()) error {
1089 ret := _mock.Called(ctx, onChange)
1090
1091 if len(ret) == 0 {
1092 panic("no return value specified for Watch")
1093 }
1094
1095 var r0 error
1096 if returnFunc, ok := ret.Get(0).(func(context.Context, func()) error); ok {
1097 r0 = returnFunc(ctx, onChange)
1098 } else {
1099 r0 = ret.Error(0)
1100 }
1101 return r0
1102}
1103
1104// MockConfigService_Watch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Watch'
1105type MockConfigService_Watch_Call struct {
1106 *mock.Call
1107}
1108
1109// Watch is a helper method to define mock.On call
1110// - ctx context.Context
1111// - onChange func()
1112func (_e *MockConfigService_Expecter) Watch(ctx interface{}, onChange interface{}) *MockConfigService_Watch_Call {
1113 return &MockConfigService_Watch_Call{Call: _e.mock.On("Watch", ctx, onChange)}
1114}
1115
1116func (_c *MockConfigService_Watch_Call) Run(run func(ctx context.Context, onChange func())) *MockConfigService_Watch_Call {
1117 _c.Call.Run(func(args mock.Arguments) {
1118 var arg0 context.Context
1119 if args[0] != nil {
1120 arg0 = args[0].(context.Context)
1121 }
1122 var arg1 func()
1123 if args[1] != nil {
1124 arg1 = args[1].(func())
1125 }
1126 run(
1127 arg0,
1128 arg1,
1129 )
1130 })
1131 return _c
1132}
1133
1134func (_c *MockConfigService_Watch_Call) Return(err error) *MockConfigService_Watch_Call {
1135 _c.Call.Return(err)
1136 return _c
1137}
1138
1139func (_c *MockConfigService_Watch_Call) RunAndReturn(run func(ctx context.Context, onChange func()) error) *MockConfigService_Watch_Call {
1140 _c.Call.Return(run)
1141 return _c
1142}