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// GetRoutes provides a mock function for the type MockConfigService
321func (_mock *MockConfigService) GetRoutes(ctx context.Context) []domain.Route {
322 ret := _mock.Called(ctx)
323
324 if len(ret) == 0 {
325 panic("no return value specified for GetRoutes")
326 }
327
328 var r0 []domain.Route
329 if returnFunc, ok := ret.Get(0).(func(context.Context) []domain.Route); ok {
330 r0 = returnFunc(ctx)
331 } else {
332 if ret.Get(0) != nil {
333 r0 = ret.Get(0).([]domain.Route)
334 }
335 }
336 return r0
337}
338
339// MockConfigService_GetRoutes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRoutes'
340type MockConfigService_GetRoutes_Call struct {
341 *mock.Call
342}
343
344// GetRoutes is a helper method to define mock.On call
345// - ctx context.Context
346func (_e *MockConfigService_Expecter) GetRoutes(ctx interface{}) *MockConfigService_GetRoutes_Call {
347 return &MockConfigService_GetRoutes_Call{Call: _e.mock.On("GetRoutes", ctx)}
348}
349
350func (_c *MockConfigService_GetRoutes_Call) Run(run func(ctx context.Context)) *MockConfigService_GetRoutes_Call {
351 _c.Call.Run(func(args mock.Arguments) {
352 var arg0 context.Context
353 if args[0] != nil {
354 arg0 = args[0].(context.Context)
355 }
356 run(
357 arg0,
358 )
359 })
360 return _c
361}
362
363func (_c *MockConfigService_GetRoutes_Call) Return(routes []domain.Route) *MockConfigService_GetRoutes_Call {
364 _c.Call.Return(routes)
365 return _c
366}
367
368func (_c *MockConfigService_GetRoutes_Call) RunAndReturn(run func(ctx context.Context) []domain.Route) *MockConfigService_GetRoutes_Call {
369 _c.Call.Return(run)
370 return _c
371}
372
373// GetServerPort provides a mock function for the type MockConfigService
374func (_mock *MockConfigService) GetServerPort() int {
375 ret := _mock.Called()
376
377 if len(ret) == 0 {
378 panic("no return value specified for GetServerPort")
379 }
380
381 var r0 int
382 if returnFunc, ok := ret.Get(0).(func() int); ok {
383 r0 = returnFunc()
384 } else {
385 r0 = ret.Get(0).(int)
386 }
387 return r0
388}
389
390// MockConfigService_GetServerPort_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServerPort'
391type MockConfigService_GetServerPort_Call struct {
392 *mock.Call
393}
394
395// GetServerPort is a helper method to define mock.On call
396func (_e *MockConfigService_Expecter) GetServerPort() *MockConfigService_GetServerPort_Call {
397 return &MockConfigService_GetServerPort_Call{Call: _e.mock.On("GetServerPort")}
398}
399
400func (_c *MockConfigService_GetServerPort_Call) Run(run func()) *MockConfigService_GetServerPort_Call {
401 _c.Call.Run(func(args mock.Arguments) {
402 run()
403 })
404 return _c
405}
406
407func (_c *MockConfigService_GetServerPort_Call) Return(n int) *MockConfigService_GetServerPort_Call {
408 _c.Call.Return(n)
409 return _c
410}
411
412func (_c *MockConfigService_GetServerPort_Call) RunAndReturn(run func() int) *MockConfigService_GetServerPort_Call {
413 _c.Call.Return(run)
414 return _c
415}
416
417// IsAutoRouteEnabled provides a mock function for the type MockConfigService
418func (_mock *MockConfigService) IsAutoRouteEnabled() bool {
419 ret := _mock.Called()
420
421 if len(ret) == 0 {
422 panic("no return value specified for IsAutoRouteEnabled")
423 }
424
425 var r0 bool
426 if returnFunc, ok := ret.Get(0).(func() bool); ok {
427 r0 = returnFunc()
428 } else {
429 r0 = ret.Get(0).(bool)
430 }
431 return r0
432}
433
434// MockConfigService_IsAutoRouteEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsAutoRouteEnabled'
435type MockConfigService_IsAutoRouteEnabled_Call struct {
436 *mock.Call
437}
438
439// IsAutoRouteEnabled is a helper method to define mock.On call
440func (_e *MockConfigService_Expecter) IsAutoRouteEnabled() *MockConfigService_IsAutoRouteEnabled_Call {
441 return &MockConfigService_IsAutoRouteEnabled_Call{Call: _e.mock.On("IsAutoRouteEnabled")}
442}
443
444func (_c *MockConfigService_IsAutoRouteEnabled_Call) Run(run func()) *MockConfigService_IsAutoRouteEnabled_Call {
445 _c.Call.Run(func(args mock.Arguments) {
446 run()
447 })
448 return _c
449}
450
451func (_c *MockConfigService_IsAutoRouteEnabled_Call) Return(b bool) *MockConfigService_IsAutoRouteEnabled_Call {
452 _c.Call.Return(b)
453 return _c
454}
455
456func (_c *MockConfigService_IsAutoRouteEnabled_Call) RunAndReturn(run func() bool) *MockConfigService_IsAutoRouteEnabled_Call {
457 _c.Call.Return(run)
458 return _c
459}
460
461// IsNetworkIsolationEnabled provides a mock function for the type MockConfigService
462func (_mock *MockConfigService) IsNetworkIsolationEnabled() bool {
463 ret := _mock.Called()
464
465 if len(ret) == 0 {
466 panic("no return value specified for IsNetworkIsolationEnabled")
467 }
468
469 var r0 bool
470 if returnFunc, ok := ret.Get(0).(func() bool); ok {
471 r0 = returnFunc()
472 } else {
473 r0 = ret.Get(0).(bool)
474 }
475 return r0
476}
477
478// MockConfigService_IsNetworkIsolationEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsNetworkIsolationEnabled'
479type MockConfigService_IsNetworkIsolationEnabled_Call struct {
480 *mock.Call
481}
482
483// IsNetworkIsolationEnabled is a helper method to define mock.On call
484func (_e *MockConfigService_Expecter) IsNetworkIsolationEnabled() *MockConfigService_IsNetworkIsolationEnabled_Call {
485 return &MockConfigService_IsNetworkIsolationEnabled_Call{Call: _e.mock.On("IsNetworkIsolationEnabled")}
486}
487
488func (_c *MockConfigService_IsNetworkIsolationEnabled_Call) Run(run func()) *MockConfigService_IsNetworkIsolationEnabled_Call {
489 _c.Call.Run(func(args mock.Arguments) {
490 run()
491 })
492 return _c
493}
494
495func (_c *MockConfigService_IsNetworkIsolationEnabled_Call) Return(b bool) *MockConfigService_IsNetworkIsolationEnabled_Call {
496 _c.Call.Return(b)
497 return _c
498}
499
500func (_c *MockConfigService_IsNetworkIsolationEnabled_Call) RunAndReturn(run func() bool) *MockConfigService_IsNetworkIsolationEnabled_Call {
501 _c.Call.Return(run)
502 return _c
503}
504
505// Load provides a mock function for the type MockConfigService
506func (_mock *MockConfigService) Load(ctx context.Context) error {
507 ret := _mock.Called(ctx)
508
509 if len(ret) == 0 {
510 panic("no return value specified for Load")
511 }
512
513 var r0 error
514 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
515 r0 = returnFunc(ctx)
516 } else {
517 r0 = ret.Error(0)
518 }
519 return r0
520}
521
522// MockConfigService_Load_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Load'
523type MockConfigService_Load_Call struct {
524 *mock.Call
525}
526
527// Load is a helper method to define mock.On call
528// - ctx context.Context
529func (_e *MockConfigService_Expecter) Load(ctx interface{}) *MockConfigService_Load_Call {
530 return &MockConfigService_Load_Call{Call: _e.mock.On("Load", ctx)}
531}
532
533func (_c *MockConfigService_Load_Call) Run(run func(ctx context.Context)) *MockConfigService_Load_Call {
534 _c.Call.Run(func(args mock.Arguments) {
535 var arg0 context.Context
536 if args[0] != nil {
537 arg0 = args[0].(context.Context)
538 }
539 run(
540 arg0,
541 )
542 })
543 return _c
544}
545
546func (_c *MockConfigService_Load_Call) Return(err error) *MockConfigService_Load_Call {
547 _c.Call.Return(err)
548 return _c
549}
550
551func (_c *MockConfigService_Load_Call) RunAndReturn(run func(ctx context.Context) error) *MockConfigService_Load_Call {
552 _c.Call.Return(run)
553 return _c
554}
555
556// RemoveRoute provides a mock function for the type MockConfigService
557func (_mock *MockConfigService) RemoveRoute(ctx context.Context, domain1 string) error {
558 ret := _mock.Called(ctx, domain1)
559
560 if len(ret) == 0 {
561 panic("no return value specified for RemoveRoute")
562 }
563
564 var r0 error
565 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
566 r0 = returnFunc(ctx, domain1)
567 } else {
568 r0 = ret.Error(0)
569 }
570 return r0
571}
572
573// MockConfigService_RemoveRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRoute'
574type MockConfigService_RemoveRoute_Call struct {
575 *mock.Call
576}
577
578// RemoveRoute is a helper method to define mock.On call
579// - ctx context.Context
580// - domain1 string
581func (_e *MockConfigService_Expecter) RemoveRoute(ctx interface{}, domain1 interface{}) *MockConfigService_RemoveRoute_Call {
582 return &MockConfigService_RemoveRoute_Call{Call: _e.mock.On("RemoveRoute", ctx, domain1)}
583}
584
585func (_c *MockConfigService_RemoveRoute_Call) Run(run func(ctx context.Context, domain1 string)) *MockConfigService_RemoveRoute_Call {
586 _c.Call.Run(func(args mock.Arguments) {
587 var arg0 context.Context
588 if args[0] != nil {
589 arg0 = args[0].(context.Context)
590 }
591 var arg1 string
592 if args[1] != nil {
593 arg1 = args[1].(string)
594 }
595 run(
596 arg0,
597 arg1,
598 )
599 })
600 return _c
601}
602
603func (_c *MockConfigService_RemoveRoute_Call) Return(err error) *MockConfigService_RemoveRoute_Call {
604 _c.Call.Return(err)
605 return _c
606}
607
608func (_c *MockConfigService_RemoveRoute_Call) RunAndReturn(run func(ctx context.Context, domain1 string) error) *MockConfigService_RemoveRoute_Call {
609 _c.Call.Return(run)
610 return _c
611}
612
613// UpdateRoute provides a mock function for the type MockConfigService
614func (_mock *MockConfigService) UpdateRoute(ctx context.Context, route domain.Route) error {
615 ret := _mock.Called(ctx, route)
616
617 if len(ret) == 0 {
618 panic("no return value specified for UpdateRoute")
619 }
620
621 var r0 error
622 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Route) error); ok {
623 r0 = returnFunc(ctx, route)
624 } else {
625 r0 = ret.Error(0)
626 }
627 return r0
628}
629
630// MockConfigService_UpdateRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRoute'
631type MockConfigService_UpdateRoute_Call struct {
632 *mock.Call
633}
634
635// UpdateRoute is a helper method to define mock.On call
636// - ctx context.Context
637// - route domain.Route
638func (_e *MockConfigService_Expecter) UpdateRoute(ctx interface{}, route interface{}) *MockConfigService_UpdateRoute_Call {
639 return &MockConfigService_UpdateRoute_Call{Call: _e.mock.On("UpdateRoute", ctx, route)}
640}
641
642func (_c *MockConfigService_UpdateRoute_Call) Run(run func(ctx context.Context, route domain.Route)) *MockConfigService_UpdateRoute_Call {
643 _c.Call.Run(func(args mock.Arguments) {
644 var arg0 context.Context
645 if args[0] != nil {
646 arg0 = args[0].(context.Context)
647 }
648 var arg1 domain.Route
649 if args[1] != nil {
650 arg1 = args[1].(domain.Route)
651 }
652 run(
653 arg0,
654 arg1,
655 )
656 })
657 return _c
658}
659
660func (_c *MockConfigService_UpdateRoute_Call) Return(err error) *MockConfigService_UpdateRoute_Call {
661 _c.Call.Return(err)
662 return _c
663}
664
665func (_c *MockConfigService_UpdateRoute_Call) RunAndReturn(run func(ctx context.Context, route domain.Route) error) *MockConfigService_UpdateRoute_Call {
666 _c.Call.Return(run)
667 return _c
668}
669
670// Watch provides a mock function for the type MockConfigService
671func (_mock *MockConfigService) Watch(ctx context.Context, onChange func()) error {
672 ret := _mock.Called(ctx, onChange)
673
674 if len(ret) == 0 {
675 panic("no return value specified for Watch")
676 }
677
678 var r0 error
679 if returnFunc, ok := ret.Get(0).(func(context.Context, func()) error); ok {
680 r0 = returnFunc(ctx, onChange)
681 } else {
682 r0 = ret.Error(0)
683 }
684 return r0
685}
686
687// MockConfigService_Watch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Watch'
688type MockConfigService_Watch_Call struct {
689 *mock.Call
690}
691
692// Watch is a helper method to define mock.On call
693// - ctx context.Context
694// - onChange func()
695func (_e *MockConfigService_Expecter) Watch(ctx interface{}, onChange interface{}) *MockConfigService_Watch_Call {
696 return &MockConfigService_Watch_Call{Call: _e.mock.On("Watch", ctx, onChange)}
697}
698
699func (_c *MockConfigService_Watch_Call) Run(run func(ctx context.Context, onChange func())) *MockConfigService_Watch_Call {
700 _c.Call.Run(func(args mock.Arguments) {
701 var arg0 context.Context
702 if args[0] != nil {
703 arg0 = args[0].(context.Context)
704 }
705 var arg1 func()
706 if args[1] != nil {
707 arg1 = args[1].(func())
708 }
709 run(
710 arg0,
711 arg1,
712 )
713 })
714 return _c
715}
716
717func (_c *MockConfigService_Watch_Call) Return(err error) *MockConfigService_Watch_Call {
718 _c.Call.Return(err)
719 return _c
720}
721
722func (_c *MockConfigService_Watch_Call) RunAndReturn(run func(ctx context.Context, onChange func()) error) *MockConfigService_Watch_Call {
723 _c.Call.Return(run)
724 return _c
725}