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// AddRoute provides a mock function for the type MockConfigService
42func (_mock *MockConfigService) AddRoute(ctx context.Context, route domain.Route) error {
43 ret := _mock.Called(ctx, route)
44
45 if len(ret) == 0 {
46 panic("no return value specified for AddRoute")
47 }
48
49 var r0 error
50 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Route) error); ok {
51 r0 = returnFunc(ctx, route)
52 } else {
53 r0 = ret.Error(0)
54 }
55 return r0
56}
57
58// MockConfigService_AddRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddRoute'
59type MockConfigService_AddRoute_Call struct {
60 *mock.Call
61}
62
63// AddRoute is a helper method to define mock.On call
64// - ctx context.Context
65// - route domain.Route
66func (_e *MockConfigService_Expecter) AddRoute(ctx interface{}, route interface{}) *MockConfigService_AddRoute_Call {
67 return &MockConfigService_AddRoute_Call{Call: _e.mock.On("AddRoute", ctx, route)}
68}
69
70func (_c *MockConfigService_AddRoute_Call) Run(run func(ctx context.Context, route domain.Route)) *MockConfigService_AddRoute_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 *MockConfigService_AddRoute_Call) Return(err error) *MockConfigService_AddRoute_Call {
89 _c.Call.Return(err)
90 return _c
91}
92
93func (_c *MockConfigService_AddRoute_Call) RunAndReturn(run func(ctx context.Context, route domain.Route) error) *MockConfigService_AddRoute_Call {
94 _c.Call.Return(run)
95 return _c
96}
97
98// GetDataDir provides a mock function for the type MockConfigService
99func (_mock *MockConfigService) GetDataDir() string {
100 ret := _mock.Called()
101
102 if len(ret) == 0 {
103 panic("no return value specified for GetDataDir")
104 }
105
106 var r0 string
107 if returnFunc, ok := ret.Get(0).(func() string); ok {
108 r0 = returnFunc()
109 } else {
110 r0 = ret.Get(0).(string)
111 }
112 return r0
113}
114
115// MockConfigService_GetDataDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDataDir'
116type MockConfigService_GetDataDir_Call struct {
117 *mock.Call
118}
119
120// GetDataDir is a helper method to define mock.On call
121func (_e *MockConfigService_Expecter) GetDataDir() *MockConfigService_GetDataDir_Call {
122 return &MockConfigService_GetDataDir_Call{Call: _e.mock.On("GetDataDir")}
123}
124
125func (_c *MockConfigService_GetDataDir_Call) Run(run func()) *MockConfigService_GetDataDir_Call {
126 _c.Call.Run(func(args mock.Arguments) {
127 run()
128 })
129 return _c
130}
131
132func (_c *MockConfigService_GetDataDir_Call) Return(s string) *MockConfigService_GetDataDir_Call {
133 _c.Call.Return(s)
134 return _c
135}
136
137func (_c *MockConfigService_GetDataDir_Call) RunAndReturn(run func() string) *MockConfigService_GetDataDir_Call {
138 _c.Call.Return(run)
139 return _c
140}
141
142// GetExternalRoutes provides a mock function for the type MockConfigService
143func (_mock *MockConfigService) GetExternalRoutes() map[string]string {
144 ret := _mock.Called()
145
146 if len(ret) == 0 {
147 panic("no return value specified for GetExternalRoutes")
148 }
149
150 var r0 map[string]string
151 if returnFunc, ok := ret.Get(0).(func() map[string]string); ok {
152 r0 = returnFunc()
153 } else {
154 if ret.Get(0) != nil {
155 r0 = ret.Get(0).(map[string]string)
156 }
157 }
158 return r0
159}
160
161// MockConfigService_GetExternalRoutes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetExternalRoutes'
162type MockConfigService_GetExternalRoutes_Call struct {
163 *mock.Call
164}
165
166// GetExternalRoutes is a helper method to define mock.On call
167func (_e *MockConfigService_Expecter) GetExternalRoutes() *MockConfigService_GetExternalRoutes_Call {
168 return &MockConfigService_GetExternalRoutes_Call{Call: _e.mock.On("GetExternalRoutes")}
169}
170
171func (_c *MockConfigService_GetExternalRoutes_Call) Run(run func()) *MockConfigService_GetExternalRoutes_Call {
172 _c.Call.Run(func(args mock.Arguments) {
173 run()
174 })
175 return _c
176}
177
178func (_c *MockConfigService_GetExternalRoutes_Call) Return(stringToString map[string]string) *MockConfigService_GetExternalRoutes_Call {
179 _c.Call.Return(stringToString)
180 return _c
181}
182
183func (_c *MockConfigService_GetExternalRoutes_Call) RunAndReturn(run func() map[string]string) *MockConfigService_GetExternalRoutes_Call {
184 _c.Call.Return(run)
185 return _c
186}
187
188// GetNetworkPrefix provides a mock function for the type MockConfigService
189func (_mock *MockConfigService) GetNetworkPrefix() string {
190 ret := _mock.Called()
191
192 if len(ret) == 0 {
193 panic("no return value specified for GetNetworkPrefix")
194 }
195
196 var r0 string
197 if returnFunc, ok := ret.Get(0).(func() string); ok {
198 r0 = returnFunc()
199 } else {
200 r0 = ret.Get(0).(string)
201 }
202 return r0
203}
204
205// MockConfigService_GetNetworkPrefix_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNetworkPrefix'
206type MockConfigService_GetNetworkPrefix_Call struct {
207 *mock.Call
208}
209
210// GetNetworkPrefix is a helper method to define mock.On call
211func (_e *MockConfigService_Expecter) GetNetworkPrefix() *MockConfigService_GetNetworkPrefix_Call {
212 return &MockConfigService_GetNetworkPrefix_Call{Call: _e.mock.On("GetNetworkPrefix")}
213}
214
215func (_c *MockConfigService_GetNetworkPrefix_Call) Run(run func()) *MockConfigService_GetNetworkPrefix_Call {
216 _c.Call.Run(func(args mock.Arguments) {
217 run()
218 })
219 return _c
220}
221
222func (_c *MockConfigService_GetNetworkPrefix_Call) Return(s string) *MockConfigService_GetNetworkPrefix_Call {
223 _c.Call.Return(s)
224 return _c
225}
226
227func (_c *MockConfigService_GetNetworkPrefix_Call) RunAndReturn(run func() string) *MockConfigService_GetNetworkPrefix_Call {
228 _c.Call.Return(run)
229 return _c
230}
231
232// GetRegistryDomain provides a mock function for the type MockConfigService
233func (_mock *MockConfigService) GetRegistryDomain() string {
234 ret := _mock.Called()
235
236 if len(ret) == 0 {
237 panic("no return value specified for GetRegistryDomain")
238 }
239
240 var r0 string
241 if returnFunc, ok := ret.Get(0).(func() string); ok {
242 r0 = returnFunc()
243 } else {
244 r0 = ret.Get(0).(string)
245 }
246 return r0
247}
248
249// MockConfigService_GetRegistryDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRegistryDomain'
250type MockConfigService_GetRegistryDomain_Call struct {
251 *mock.Call
252}
253
254// GetRegistryDomain is a helper method to define mock.On call
255func (_e *MockConfigService_Expecter) GetRegistryDomain() *MockConfigService_GetRegistryDomain_Call {
256 return &MockConfigService_GetRegistryDomain_Call{Call: _e.mock.On("GetRegistryDomain")}
257}
258
259func (_c *MockConfigService_GetRegistryDomain_Call) Run(run func()) *MockConfigService_GetRegistryDomain_Call {
260 _c.Call.Run(func(args mock.Arguments) {
261 run()
262 })
263 return _c
264}
265
266func (_c *MockConfigService_GetRegistryDomain_Call) Return(s string) *MockConfigService_GetRegistryDomain_Call {
267 _c.Call.Return(s)
268 return _c
269}
270
271func (_c *MockConfigService_GetRegistryDomain_Call) RunAndReturn(run func() string) *MockConfigService_GetRegistryDomain_Call {
272 _c.Call.Return(run)
273 return _c
274}
275
276// GetRegistryPort provides a mock function for the type MockConfigService
277func (_mock *MockConfigService) GetRegistryPort() int {
278 ret := _mock.Called()
279
280 if len(ret) == 0 {
281 panic("no return value specified for GetRegistryPort")
282 }
283
284 var r0 int
285 if returnFunc, ok := ret.Get(0).(func() int); ok {
286 r0 = returnFunc()
287 } else {
288 r0 = ret.Get(0).(int)
289 }
290 return r0
291}
292
293// MockConfigService_GetRegistryPort_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRegistryPort'
294type MockConfigService_GetRegistryPort_Call struct {
295 *mock.Call
296}
297
298// GetRegistryPort is a helper method to define mock.On call
299func (_e *MockConfigService_Expecter) GetRegistryPort() *MockConfigService_GetRegistryPort_Call {
300 return &MockConfigService_GetRegistryPort_Call{Call: _e.mock.On("GetRegistryPort")}
301}
302
303func (_c *MockConfigService_GetRegistryPort_Call) Run(run func()) *MockConfigService_GetRegistryPort_Call {
304 _c.Call.Run(func(args mock.Arguments) {
305 run()
306 })
307 return _c
308}
309
310func (_c *MockConfigService_GetRegistryPort_Call) Return(n int) *MockConfigService_GetRegistryPort_Call {
311 _c.Call.Return(n)
312 return _c
313}
314
315func (_c *MockConfigService_GetRegistryPort_Call) RunAndReturn(run func() int) *MockConfigService_GetRegistryPort_Call {
316 _c.Call.Return(run)
317 return _c
318}
319
320// GetRoute provides a mock function for the type MockConfigService
321func (_mock *MockConfigService) GetRoute(ctx context.Context, domain1 string) (*domain.Route, error) {
322 ret := _mock.Called(ctx, domain1)
323
324 if len(ret) == 0 {
325 panic("no return value specified for GetRoute")
326 }
327
328 var r0 *domain.Route
329 var r1 error
330 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*domain.Route, error)); ok {
331 return returnFunc(ctx, domain1)
332 }
333 if returnFunc, ok := ret.Get(0).(func(context.Context, string) *domain.Route); ok {
334 r0 = returnFunc(ctx, domain1)
335 } else {
336 if ret.Get(0) != nil {
337 r0 = ret.Get(0).(*domain.Route)
338 }
339 }
340 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
341 r1 = returnFunc(ctx, domain1)
342 } else {
343 r1 = ret.Error(1)
344 }
345 return r0, r1
346}
347
348// MockConfigService_GetRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRoute'
349type MockConfigService_GetRoute_Call struct {
350 *mock.Call
351}
352
353// GetRoute is a helper method to define mock.On call
354// - ctx context.Context
355// - domain1 string
356func (_e *MockConfigService_Expecter) GetRoute(ctx interface{}, domain1 interface{}) *MockConfigService_GetRoute_Call {
357 return &MockConfigService_GetRoute_Call{Call: _e.mock.On("GetRoute", ctx, domain1)}
358}
359
360func (_c *MockConfigService_GetRoute_Call) Run(run func(ctx context.Context, domain1 string)) *MockConfigService_GetRoute_Call {
361 _c.Call.Run(func(args mock.Arguments) {
362 var arg0 context.Context
363 if args[0] != nil {
364 arg0 = args[0].(context.Context)
365 }
366 var arg1 string
367 if args[1] != nil {
368 arg1 = args[1].(string)
369 }
370 run(
371 arg0,
372 arg1,
373 )
374 })
375 return _c
376}
377
378func (_c *MockConfigService_GetRoute_Call) Return(route *domain.Route, err error) *MockConfigService_GetRoute_Call {
379 _c.Call.Return(route, err)
380 return _c
381}
382
383func (_c *MockConfigService_GetRoute_Call) RunAndReturn(run func(ctx context.Context, domain1 string) (*domain.Route, error)) *MockConfigService_GetRoute_Call {
384 _c.Call.Return(run)
385 return _c
386}
387
388// GetRoutes provides a mock function for the type MockConfigService
389func (_mock *MockConfigService) GetRoutes(ctx context.Context) []domain.Route {
390 ret := _mock.Called(ctx)
391
392 if len(ret) == 0 {
393 panic("no return value specified for GetRoutes")
394 }
395
396 var r0 []domain.Route
397 if returnFunc, ok := ret.Get(0).(func(context.Context) []domain.Route); ok {
398 r0 = returnFunc(ctx)
399 } else {
400 if ret.Get(0) != nil {
401 r0 = ret.Get(0).([]domain.Route)
402 }
403 }
404 return r0
405}
406
407// MockConfigService_GetRoutes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRoutes'
408type MockConfigService_GetRoutes_Call struct {
409 *mock.Call
410}
411
412// GetRoutes is a helper method to define mock.On call
413// - ctx context.Context
414func (_e *MockConfigService_Expecter) GetRoutes(ctx interface{}) *MockConfigService_GetRoutes_Call {
415 return &MockConfigService_GetRoutes_Call{Call: _e.mock.On("GetRoutes", ctx)}
416}
417
418func (_c *MockConfigService_GetRoutes_Call) Run(run func(ctx context.Context)) *MockConfigService_GetRoutes_Call {
419 _c.Call.Run(func(args mock.Arguments) {
420 var arg0 context.Context
421 if args[0] != nil {
422 arg0 = args[0].(context.Context)
423 }
424 run(
425 arg0,
426 )
427 })
428 return _c
429}
430
431func (_c *MockConfigService_GetRoutes_Call) Return(routes []domain.Route) *MockConfigService_GetRoutes_Call {
432 _c.Call.Return(routes)
433 return _c
434}
435
436func (_c *MockConfigService_GetRoutes_Call) RunAndReturn(run func(ctx context.Context) []domain.Route) *MockConfigService_GetRoutes_Call {
437 _c.Call.Return(run)
438 return _c
439}
440
441// GetServerPort provides a mock function for the type MockConfigService
442func (_mock *MockConfigService) GetServerPort() int {
443 ret := _mock.Called()
444
445 if len(ret) == 0 {
446 panic("no return value specified for GetServerPort")
447 }
448
449 var r0 int
450 if returnFunc, ok := ret.Get(0).(func() int); ok {
451 r0 = returnFunc()
452 } else {
453 r0 = ret.Get(0).(int)
454 }
455 return r0
456}
457
458// MockConfigService_GetServerPort_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServerPort'
459type MockConfigService_GetServerPort_Call struct {
460 *mock.Call
461}
462
463// GetServerPort is a helper method to define mock.On call
464func (_e *MockConfigService_Expecter) GetServerPort() *MockConfigService_GetServerPort_Call {
465 return &MockConfigService_GetServerPort_Call{Call: _e.mock.On("GetServerPort")}
466}
467
468func (_c *MockConfigService_GetServerPort_Call) Run(run func()) *MockConfigService_GetServerPort_Call {
469 _c.Call.Run(func(args mock.Arguments) {
470 run()
471 })
472 return _c
473}
474
475func (_c *MockConfigService_GetServerPort_Call) Return(n int) *MockConfigService_GetServerPort_Call {
476 _c.Call.Return(n)
477 return _c
478}
479
480func (_c *MockConfigService_GetServerPort_Call) RunAndReturn(run func() int) *MockConfigService_GetServerPort_Call {
481 _c.Call.Return(run)
482 return _c
483}
484
485// IsAutoRouteEnabled provides a mock function for the type MockConfigService
486func (_mock *MockConfigService) IsAutoRouteEnabled() bool {
487 ret := _mock.Called()
488
489 if len(ret) == 0 {
490 panic("no return value specified for IsAutoRouteEnabled")
491 }
492
493 var r0 bool
494 if returnFunc, ok := ret.Get(0).(func() bool); ok {
495 r0 = returnFunc()
496 } else {
497 r0 = ret.Get(0).(bool)
498 }
499 return r0
500}
501
502// MockConfigService_IsAutoRouteEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsAutoRouteEnabled'
503type MockConfigService_IsAutoRouteEnabled_Call struct {
504 *mock.Call
505}
506
507// IsAutoRouteEnabled is a helper method to define mock.On call
508func (_e *MockConfigService_Expecter) IsAutoRouteEnabled() *MockConfigService_IsAutoRouteEnabled_Call {
509 return &MockConfigService_IsAutoRouteEnabled_Call{Call: _e.mock.On("IsAutoRouteEnabled")}
510}
511
512func (_c *MockConfigService_IsAutoRouteEnabled_Call) Run(run func()) *MockConfigService_IsAutoRouteEnabled_Call {
513 _c.Call.Run(func(args mock.Arguments) {
514 run()
515 })
516 return _c
517}
518
519func (_c *MockConfigService_IsAutoRouteEnabled_Call) Return(b bool) *MockConfigService_IsAutoRouteEnabled_Call {
520 _c.Call.Return(b)
521 return _c
522}
523
524func (_c *MockConfigService_IsAutoRouteEnabled_Call) RunAndReturn(run func() bool) *MockConfigService_IsAutoRouteEnabled_Call {
525 _c.Call.Return(run)
526 return _c
527}
528
529// IsNetworkIsolationEnabled provides a mock function for the type MockConfigService
530func (_mock *MockConfigService) IsNetworkIsolationEnabled() bool {
531 ret := _mock.Called()
532
533 if len(ret) == 0 {
534 panic("no return value specified for IsNetworkIsolationEnabled")
535 }
536
537 var r0 bool
538 if returnFunc, ok := ret.Get(0).(func() bool); ok {
539 r0 = returnFunc()
540 } else {
541 r0 = ret.Get(0).(bool)
542 }
543 return r0
544}
545
546// MockConfigService_IsNetworkIsolationEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsNetworkIsolationEnabled'
547type MockConfigService_IsNetworkIsolationEnabled_Call struct {
548 *mock.Call
549}
550
551// IsNetworkIsolationEnabled is a helper method to define mock.On call
552func (_e *MockConfigService_Expecter) IsNetworkIsolationEnabled() *MockConfigService_IsNetworkIsolationEnabled_Call {
553 return &MockConfigService_IsNetworkIsolationEnabled_Call{Call: _e.mock.On("IsNetworkIsolationEnabled")}
554}
555
556func (_c *MockConfigService_IsNetworkIsolationEnabled_Call) Run(run func()) *MockConfigService_IsNetworkIsolationEnabled_Call {
557 _c.Call.Run(func(args mock.Arguments) {
558 run()
559 })
560 return _c
561}
562
563func (_c *MockConfigService_IsNetworkIsolationEnabled_Call) Return(b bool) *MockConfigService_IsNetworkIsolationEnabled_Call {
564 _c.Call.Return(b)
565 return _c
566}
567
568func (_c *MockConfigService_IsNetworkIsolationEnabled_Call) RunAndReturn(run func() bool) *MockConfigService_IsNetworkIsolationEnabled_Call {
569 _c.Call.Return(run)
570 return _c
571}
572
573// Load provides a mock function for the type MockConfigService
574func (_mock *MockConfigService) Load(ctx context.Context) error {
575 ret := _mock.Called(ctx)
576
577 if len(ret) == 0 {
578 panic("no return value specified for Load")
579 }
580
581 var r0 error
582 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
583 r0 = returnFunc(ctx)
584 } else {
585 r0 = ret.Error(0)
586 }
587 return r0
588}
589
590// MockConfigService_Load_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Load'
591type MockConfigService_Load_Call struct {
592 *mock.Call
593}
594
595// Load is a helper method to define mock.On call
596// - ctx context.Context
597func (_e *MockConfigService_Expecter) Load(ctx interface{}) *MockConfigService_Load_Call {
598 return &MockConfigService_Load_Call{Call: _e.mock.On("Load", ctx)}
599}
600
601func (_c *MockConfigService_Load_Call) Run(run func(ctx context.Context)) *MockConfigService_Load_Call {
602 _c.Call.Run(func(args mock.Arguments) {
603 var arg0 context.Context
604 if args[0] != nil {
605 arg0 = args[0].(context.Context)
606 }
607 run(
608 arg0,
609 )
610 })
611 return _c
612}
613
614func (_c *MockConfigService_Load_Call) Return(err error) *MockConfigService_Load_Call {
615 _c.Call.Return(err)
616 return _c
617}
618
619func (_c *MockConfigService_Load_Call) RunAndReturn(run func(ctx context.Context) error) *MockConfigService_Load_Call {
620 _c.Call.Return(run)
621 return _c
622}
623
624// RemoveRoute provides a mock function for the type MockConfigService
625func (_mock *MockConfigService) RemoveRoute(ctx context.Context, domain1 string) error {
626 ret := _mock.Called(ctx, domain1)
627
628 if len(ret) == 0 {
629 panic("no return value specified for RemoveRoute")
630 }
631
632 var r0 error
633 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
634 r0 = returnFunc(ctx, domain1)
635 } else {
636 r0 = ret.Error(0)
637 }
638 return r0
639}
640
641// MockConfigService_RemoveRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRoute'
642type MockConfigService_RemoveRoute_Call struct {
643 *mock.Call
644}
645
646// RemoveRoute is a helper method to define mock.On call
647// - ctx context.Context
648// - domain1 string
649func (_e *MockConfigService_Expecter) RemoveRoute(ctx interface{}, domain1 interface{}) *MockConfigService_RemoveRoute_Call {
650 return &MockConfigService_RemoveRoute_Call{Call: _e.mock.On("RemoveRoute", ctx, domain1)}
651}
652
653func (_c *MockConfigService_RemoveRoute_Call) Run(run func(ctx context.Context, domain1 string)) *MockConfigService_RemoveRoute_Call {
654 _c.Call.Run(func(args mock.Arguments) {
655 var arg0 context.Context
656 if args[0] != nil {
657 arg0 = args[0].(context.Context)
658 }
659 var arg1 string
660 if args[1] != nil {
661 arg1 = args[1].(string)
662 }
663 run(
664 arg0,
665 arg1,
666 )
667 })
668 return _c
669}
670
671func (_c *MockConfigService_RemoveRoute_Call) Return(err error) *MockConfigService_RemoveRoute_Call {
672 _c.Call.Return(err)
673 return _c
674}
675
676func (_c *MockConfigService_RemoveRoute_Call) RunAndReturn(run func(ctx context.Context, domain1 string) error) *MockConfigService_RemoveRoute_Call {
677 _c.Call.Return(run)
678 return _c
679}
680
681// Save provides a mock function for the type MockConfigService
682func (_mock *MockConfigService) Save(ctx context.Context) error {
683 ret := _mock.Called(ctx)
684
685 if len(ret) == 0 {
686 panic("no return value specified for Save")
687 }
688
689 var r0 error
690 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
691 r0 = returnFunc(ctx)
692 } else {
693 r0 = ret.Error(0)
694 }
695 return r0
696}
697
698// MockConfigService_Save_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Save'
699type MockConfigService_Save_Call struct {
700 *mock.Call
701}
702
703// Save is a helper method to define mock.On call
704// - ctx context.Context
705func (_e *MockConfigService_Expecter) Save(ctx interface{}) *MockConfigService_Save_Call {
706 return &MockConfigService_Save_Call{Call: _e.mock.On("Save", ctx)}
707}
708
709func (_c *MockConfigService_Save_Call) Run(run func(ctx context.Context)) *MockConfigService_Save_Call {
710 _c.Call.Run(func(args mock.Arguments) {
711 var arg0 context.Context
712 if args[0] != nil {
713 arg0 = args[0].(context.Context)
714 }
715 run(
716 arg0,
717 )
718 })
719 return _c
720}
721
722func (_c *MockConfigService_Save_Call) Return(err error) *MockConfigService_Save_Call {
723 _c.Call.Return(err)
724 return _c
725}
726
727func (_c *MockConfigService_Save_Call) RunAndReturn(run func(ctx context.Context) error) *MockConfigService_Save_Call {
728 _c.Call.Return(run)
729 return _c
730}
731
732// UpdateRoute provides a mock function for the type MockConfigService
733func (_mock *MockConfigService) UpdateRoute(ctx context.Context, route domain.Route) error {
734 ret := _mock.Called(ctx, route)
735
736 if len(ret) == 0 {
737 panic("no return value specified for UpdateRoute")
738 }
739
740 var r0 error
741 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Route) error); ok {
742 r0 = returnFunc(ctx, route)
743 } else {
744 r0 = ret.Error(0)
745 }
746 return r0
747}
748
749// MockConfigService_UpdateRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRoute'
750type MockConfigService_UpdateRoute_Call struct {
751 *mock.Call
752}
753
754// UpdateRoute is a helper method to define mock.On call
755// - ctx context.Context
756// - route domain.Route
757func (_e *MockConfigService_Expecter) UpdateRoute(ctx interface{}, route interface{}) *MockConfigService_UpdateRoute_Call {
758 return &MockConfigService_UpdateRoute_Call{Call: _e.mock.On("UpdateRoute", ctx, route)}
759}
760
761func (_c *MockConfigService_UpdateRoute_Call) Run(run func(ctx context.Context, route domain.Route)) *MockConfigService_UpdateRoute_Call {
762 _c.Call.Run(func(args mock.Arguments) {
763 var arg0 context.Context
764 if args[0] != nil {
765 arg0 = args[0].(context.Context)
766 }
767 var arg1 domain.Route
768 if args[1] != nil {
769 arg1 = args[1].(domain.Route)
770 }
771 run(
772 arg0,
773 arg1,
774 )
775 })
776 return _c
777}
778
779func (_c *MockConfigService_UpdateRoute_Call) Return(err error) *MockConfigService_UpdateRoute_Call {
780 _c.Call.Return(err)
781 return _c
782}
783
784func (_c *MockConfigService_UpdateRoute_Call) RunAndReturn(run func(ctx context.Context, route domain.Route) error) *MockConfigService_UpdateRoute_Call {
785 _c.Call.Return(run)
786 return _c
787}
788
789// Watch provides a mock function for the type MockConfigService
790func (_mock *MockConfigService) Watch(ctx context.Context, onChange func()) error {
791 ret := _mock.Called(ctx, onChange)
792
793 if len(ret) == 0 {
794 panic("no return value specified for Watch")
795 }
796
797 var r0 error
798 if returnFunc, ok := ret.Get(0).(func(context.Context, func()) error); ok {
799 r0 = returnFunc(ctx, onChange)
800 } else {
801 r0 = ret.Error(0)
802 }
803 return r0
804}
805
806// MockConfigService_Watch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Watch'
807type MockConfigService_Watch_Call struct {
808 *mock.Call
809}
810
811// Watch is a helper method to define mock.On call
812// - ctx context.Context
813// - onChange func()
814func (_e *MockConfigService_Expecter) Watch(ctx interface{}, onChange interface{}) *MockConfigService_Watch_Call {
815 return &MockConfigService_Watch_Call{Call: _e.mock.On("Watch", ctx, onChange)}
816}
817
818func (_c *MockConfigService_Watch_Call) Run(run func(ctx context.Context, onChange func())) *MockConfigService_Watch_Call {
819 _c.Call.Run(func(args mock.Arguments) {
820 var arg0 context.Context
821 if args[0] != nil {
822 arg0 = args[0].(context.Context)
823 }
824 var arg1 func()
825 if args[1] != nil {
826 arg1 = args[1].(func())
827 }
828 run(
829 arg0,
830 arg1,
831 )
832 })
833 return _c
834}
835
836func (_c *MockConfigService_Watch_Call) Return(err error) *MockConfigService_Watch_Call {
837 _c.Call.Return(err)
838 return _c
839}
840
841func (_c *MockConfigService_Watch_Call) RunAndReturn(run func(ctx context.Context, onChange func()) error) *MockConfigService_Watch_Call {
842 _c.Call.Return(run)
843 return _c
844}