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// 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// RemoveAttachment provides a mock function for the type MockConfigService
809func (_mock *MockConfigService) RemoveAttachment(ctx context.Context, domainOrGroup string, image string) error {
810 ret := _mock.Called(ctx, domainOrGroup, image)
811
812 if len(ret) == 0 {
813 panic("no return value specified for RemoveAttachment")
814 }
815
816 var r0 error
817 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
818 r0 = returnFunc(ctx, domainOrGroup, image)
819 } else {
820 r0 = ret.Error(0)
821 }
822 return r0
823}
824
825// MockConfigService_RemoveAttachment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAttachment'
826type MockConfigService_RemoveAttachment_Call struct {
827 *mock.Call
828}
829
830// RemoveAttachment is a helper method to define mock.On call
831// - ctx context.Context
832// - domainOrGroup string
833// - image string
834func (_e *MockConfigService_Expecter) RemoveAttachment(ctx interface{}, domainOrGroup interface{}, image interface{}) *MockConfigService_RemoveAttachment_Call {
835 return &MockConfigService_RemoveAttachment_Call{Call: _e.mock.On("RemoveAttachment", ctx, domainOrGroup, image)}
836}
837
838func (_c *MockConfigService_RemoveAttachment_Call) Run(run func(ctx context.Context, domainOrGroup string, image string)) *MockConfigService_RemoveAttachment_Call {
839 _c.Call.Run(func(args mock.Arguments) {
840 var arg0 context.Context
841 if args[0] != nil {
842 arg0 = args[0].(context.Context)
843 }
844 var arg1 string
845 if args[1] != nil {
846 arg1 = args[1].(string)
847 }
848 var arg2 string
849 if args[2] != nil {
850 arg2 = args[2].(string)
851 }
852 run(
853 arg0,
854 arg1,
855 arg2,
856 )
857 })
858 return _c
859}
860
861func (_c *MockConfigService_RemoveAttachment_Call) Return(err error) *MockConfigService_RemoveAttachment_Call {
862 _c.Call.Return(err)
863 return _c
864}
865
866func (_c *MockConfigService_RemoveAttachment_Call) RunAndReturn(run func(ctx context.Context, domainOrGroup string, image string) error) *MockConfigService_RemoveAttachment_Call {
867 _c.Call.Return(run)
868 return _c
869}
870
871// RemoveRoute provides a mock function for the type MockConfigService
872func (_mock *MockConfigService) RemoveRoute(ctx context.Context, domain1 string) error {
873 ret := _mock.Called(ctx, domain1)
874
875 if len(ret) == 0 {
876 panic("no return value specified for RemoveRoute")
877 }
878
879 var r0 error
880 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
881 r0 = returnFunc(ctx, domain1)
882 } else {
883 r0 = ret.Error(0)
884 }
885 return r0
886}
887
888// MockConfigService_RemoveRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRoute'
889type MockConfigService_RemoveRoute_Call struct {
890 *mock.Call
891}
892
893// RemoveRoute is a helper method to define mock.On call
894// - ctx context.Context
895// - domain1 string
896func (_e *MockConfigService_Expecter) RemoveRoute(ctx interface{}, domain1 interface{}) *MockConfigService_RemoveRoute_Call {
897 return &MockConfigService_RemoveRoute_Call{Call: _e.mock.On("RemoveRoute", ctx, domain1)}
898}
899
900func (_c *MockConfigService_RemoveRoute_Call) Run(run func(ctx context.Context, domain1 string)) *MockConfigService_RemoveRoute_Call {
901 _c.Call.Run(func(args mock.Arguments) {
902 var arg0 context.Context
903 if args[0] != nil {
904 arg0 = args[0].(context.Context)
905 }
906 var arg1 string
907 if args[1] != nil {
908 arg1 = args[1].(string)
909 }
910 run(
911 arg0,
912 arg1,
913 )
914 })
915 return _c
916}
917
918func (_c *MockConfigService_RemoveRoute_Call) Return(err error) *MockConfigService_RemoveRoute_Call {
919 _c.Call.Return(err)
920 return _c
921}
922
923func (_c *MockConfigService_RemoveRoute_Call) RunAndReturn(run func(ctx context.Context, domain1 string) error) *MockConfigService_RemoveRoute_Call {
924 _c.Call.Return(run)
925 return _c
926}
927
928// Save provides a mock function for the type MockConfigService
929func (_mock *MockConfigService) Save(ctx context.Context) error {
930 ret := _mock.Called(ctx)
931
932 if len(ret) == 0 {
933 panic("no return value specified for Save")
934 }
935
936 var r0 error
937 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
938 r0 = returnFunc(ctx)
939 } else {
940 r0 = ret.Error(0)
941 }
942 return r0
943}
944
945// MockConfigService_Save_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Save'
946type MockConfigService_Save_Call struct {
947 *mock.Call
948}
949
950// Save is a helper method to define mock.On call
951// - ctx context.Context
952func (_e *MockConfigService_Expecter) Save(ctx interface{}) *MockConfigService_Save_Call {
953 return &MockConfigService_Save_Call{Call: _e.mock.On("Save", ctx)}
954}
955
956func (_c *MockConfigService_Save_Call) Run(run func(ctx context.Context)) *MockConfigService_Save_Call {
957 _c.Call.Run(func(args mock.Arguments) {
958 var arg0 context.Context
959 if args[0] != nil {
960 arg0 = args[0].(context.Context)
961 }
962 run(
963 arg0,
964 )
965 })
966 return _c
967}
968
969func (_c *MockConfigService_Save_Call) Return(err error) *MockConfigService_Save_Call {
970 _c.Call.Return(err)
971 return _c
972}
973
974func (_c *MockConfigService_Save_Call) RunAndReturn(run func(ctx context.Context) error) *MockConfigService_Save_Call {
975 _c.Call.Return(run)
976 return _c
977}
978
979// UpdateRoute provides a mock function for the type MockConfigService
980func (_mock *MockConfigService) UpdateRoute(ctx context.Context, route domain.Route) error {
981 ret := _mock.Called(ctx, route)
982
983 if len(ret) == 0 {
984 panic("no return value specified for UpdateRoute")
985 }
986
987 var r0 error
988 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Route) error); ok {
989 r0 = returnFunc(ctx, route)
990 } else {
991 r0 = ret.Error(0)
992 }
993 return r0
994}
995
996// MockConfigService_UpdateRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRoute'
997type MockConfigService_UpdateRoute_Call struct {
998 *mock.Call
999}
1000
1001// UpdateRoute is a helper method to define mock.On call
1002// - ctx context.Context
1003// - route domain.Route
1004func (_e *MockConfigService_Expecter) UpdateRoute(ctx interface{}, route interface{}) *MockConfigService_UpdateRoute_Call {
1005 return &MockConfigService_UpdateRoute_Call{Call: _e.mock.On("UpdateRoute", ctx, route)}
1006}
1007
1008func (_c *MockConfigService_UpdateRoute_Call) Run(run func(ctx context.Context, route domain.Route)) *MockConfigService_UpdateRoute_Call {
1009 _c.Call.Run(func(args mock.Arguments) {
1010 var arg0 context.Context
1011 if args[0] != nil {
1012 arg0 = args[0].(context.Context)
1013 }
1014 var arg1 domain.Route
1015 if args[1] != nil {
1016 arg1 = args[1].(domain.Route)
1017 }
1018 run(
1019 arg0,
1020 arg1,
1021 )
1022 })
1023 return _c
1024}
1025
1026func (_c *MockConfigService_UpdateRoute_Call) Return(err error) *MockConfigService_UpdateRoute_Call {
1027 _c.Call.Return(err)
1028 return _c
1029}
1030
1031func (_c *MockConfigService_UpdateRoute_Call) RunAndReturn(run func(ctx context.Context, route domain.Route) error) *MockConfigService_UpdateRoute_Call {
1032 _c.Call.Return(run)
1033 return _c
1034}
1035
1036// Watch provides a mock function for the type MockConfigService
1037func (_mock *MockConfigService) Watch(ctx context.Context, onChange func()) error {
1038 ret := _mock.Called(ctx, onChange)
1039
1040 if len(ret) == 0 {
1041 panic("no return value specified for Watch")
1042 }
1043
1044 var r0 error
1045 if returnFunc, ok := ret.Get(0).(func(context.Context, func()) error); ok {
1046 r0 = returnFunc(ctx, onChange)
1047 } else {
1048 r0 = ret.Error(0)
1049 }
1050 return r0
1051}
1052
1053// MockConfigService_Watch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Watch'
1054type MockConfigService_Watch_Call struct {
1055 *mock.Call
1056}
1057
1058// Watch is a helper method to define mock.On call
1059// - ctx context.Context
1060// - onChange func()
1061func (_e *MockConfigService_Expecter) Watch(ctx interface{}, onChange interface{}) *MockConfigService_Watch_Call {
1062 return &MockConfigService_Watch_Call{Call: _e.mock.On("Watch", ctx, onChange)}
1063}
1064
1065func (_c *MockConfigService_Watch_Call) Run(run func(ctx context.Context, onChange func())) *MockConfigService_Watch_Call {
1066 _c.Call.Run(func(args mock.Arguments) {
1067 var arg0 context.Context
1068 if args[0] != nil {
1069 arg0 = args[0].(context.Context)
1070 }
1071 var arg1 func()
1072 if args[1] != nil {
1073 arg1 = args[1].(func())
1074 }
1075 run(
1076 arg0,
1077 arg1,
1078 )
1079 })
1080 return _c
1081}
1082
1083func (_c *MockConfigService_Watch_Call) Return(err error) *MockConfigService_Watch_Call {
1084 _c.Call.Return(err)
1085 return _c
1086}
1087
1088func (_c *MockConfigService_Watch_Call) RunAndReturn(run func(ctx context.Context, onChange func()) error) *MockConfigService_Watch_Call {
1089 _c.Call.Return(run)
1090 return _c
1091}