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// AddAutoRouteAllowedDomain provides a mock function for the type MockConfigService
105func (_mock *MockConfigService) AddAutoRouteAllowedDomain(ctx context.Context, pattern string) error {
106 ret := _mock.Called(ctx, pattern)
107
108 if len(ret) == 0 {
109 panic("no return value specified for AddAutoRouteAllowedDomain")
110 }
111
112 var r0 error
113 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
114 r0 = returnFunc(ctx, pattern)
115 } else {
116 r0 = ret.Error(0)
117 }
118 return r0
119}
120
121// MockConfigService_AddAutoRouteAllowedDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddAutoRouteAllowedDomain'
122type MockConfigService_AddAutoRouteAllowedDomain_Call struct {
123 *mock.Call
124}
125
126// AddAutoRouteAllowedDomain is a helper method to define mock.On call
127// - ctx context.Context
128// - pattern string
129func (_e *MockConfigService_Expecter) AddAutoRouteAllowedDomain(ctx interface{}, pattern interface{}) *MockConfigService_AddAutoRouteAllowedDomain_Call {
130 return &MockConfigService_AddAutoRouteAllowedDomain_Call{Call: _e.mock.On("AddAutoRouteAllowedDomain", ctx, pattern)}
131}
132
133func (_c *MockConfigService_AddAutoRouteAllowedDomain_Call) Run(run func(ctx context.Context, pattern string)) *MockConfigService_AddAutoRouteAllowedDomain_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 string
140 if args[1] != nil {
141 arg1 = args[1].(string)
142 }
143 run(
144 arg0,
145 arg1,
146 )
147 })
148 return _c
149}
150
151func (_c *MockConfigService_AddAutoRouteAllowedDomain_Call) Return(err error) *MockConfigService_AddAutoRouteAllowedDomain_Call {
152 _c.Call.Return(err)
153 return _c
154}
155
156func (_c *MockConfigService_AddAutoRouteAllowedDomain_Call) RunAndReturn(run func(ctx context.Context, pattern string) error) *MockConfigService_AddAutoRouteAllowedDomain_Call {
157 _c.Call.Return(run)
158 return _c
159}
160
161// AddRoute provides a mock function for the type MockConfigService
162func (_mock *MockConfigService) AddRoute(ctx context.Context, route domain.Route) error {
163 ret := _mock.Called(ctx, route)
164
165 if len(ret) == 0 {
166 panic("no return value specified for AddRoute")
167 }
168
169 var r0 error
170 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Route) error); ok {
171 r0 = returnFunc(ctx, route)
172 } else {
173 r0 = ret.Error(0)
174 }
175 return r0
176}
177
178// MockConfigService_AddRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddRoute'
179type MockConfigService_AddRoute_Call struct {
180 *mock.Call
181}
182
183// AddRoute is a helper method to define mock.On call
184// - ctx context.Context
185// - route domain.Route
186func (_e *MockConfigService_Expecter) AddRoute(ctx interface{}, route interface{}) *MockConfigService_AddRoute_Call {
187 return &MockConfigService_AddRoute_Call{Call: _e.mock.On("AddRoute", ctx, route)}
188}
189
190func (_c *MockConfigService_AddRoute_Call) Run(run func(ctx context.Context, route domain.Route)) *MockConfigService_AddRoute_Call {
191 _c.Call.Run(func(args mock.Arguments) {
192 var arg0 context.Context
193 if args[0] != nil {
194 arg0 = args[0].(context.Context)
195 }
196 var arg1 domain.Route
197 if args[1] != nil {
198 arg1 = args[1].(domain.Route)
199 }
200 run(
201 arg0,
202 arg1,
203 )
204 })
205 return _c
206}
207
208func (_c *MockConfigService_AddRoute_Call) Return(err error) *MockConfigService_AddRoute_Call {
209 _c.Call.Return(err)
210 return _c
211}
212
213func (_c *MockConfigService_AddRoute_Call) RunAndReturn(run func(ctx context.Context, route domain.Route) error) *MockConfigService_AddRoute_Call {
214 _c.Call.Return(run)
215 return _c
216}
217
218// FindAttachmentTargetsByImage provides a mock function for the type MockConfigService
219func (_mock *MockConfigService) FindAttachmentTargetsByImage(ctx context.Context, imageName string) []string {
220 ret := _mock.Called(ctx, imageName)
221
222 if len(ret) == 0 {
223 panic("no return value specified for FindAttachmentTargetsByImage")
224 }
225
226 var r0 []string
227 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []string); ok {
228 r0 = returnFunc(ctx, imageName)
229 } else {
230 if ret.Get(0) != nil {
231 r0 = ret.Get(0).([]string)
232 }
233 }
234 return r0
235}
236
237// MockConfigService_FindAttachmentTargetsByImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindAttachmentTargetsByImage'
238type MockConfigService_FindAttachmentTargetsByImage_Call struct {
239 *mock.Call
240}
241
242// FindAttachmentTargetsByImage is a helper method to define mock.On call
243// - ctx context.Context
244// - imageName string
245func (_e *MockConfigService_Expecter) FindAttachmentTargetsByImage(ctx interface{}, imageName interface{}) *MockConfigService_FindAttachmentTargetsByImage_Call {
246 return &MockConfigService_FindAttachmentTargetsByImage_Call{Call: _e.mock.On("FindAttachmentTargetsByImage", ctx, imageName)}
247}
248
249func (_c *MockConfigService_FindAttachmentTargetsByImage_Call) Run(run func(ctx context.Context, imageName string)) *MockConfigService_FindAttachmentTargetsByImage_Call {
250 _c.Call.Run(func(args mock.Arguments) {
251 var arg0 context.Context
252 if args[0] != nil {
253 arg0 = args[0].(context.Context)
254 }
255 var arg1 string
256 if args[1] != nil {
257 arg1 = args[1].(string)
258 }
259 run(
260 arg0,
261 arg1,
262 )
263 })
264 return _c
265}
266
267func (_c *MockConfigService_FindAttachmentTargetsByImage_Call) Return(strings []string) *MockConfigService_FindAttachmentTargetsByImage_Call {
268 _c.Call.Return(strings)
269 return _c
270}
271
272func (_c *MockConfigService_FindAttachmentTargetsByImage_Call) RunAndReturn(run func(ctx context.Context, imageName string) []string) *MockConfigService_FindAttachmentTargetsByImage_Call {
273 _c.Call.Return(run)
274 return _c
275}
276
277// FindRoutesByImage provides a mock function for the type MockConfigService
278func (_mock *MockConfigService) FindRoutesByImage(ctx context.Context, imageName string) []domain.Route {
279 ret := _mock.Called(ctx, imageName)
280
281 if len(ret) == 0 {
282 panic("no return value specified for FindRoutesByImage")
283 }
284
285 var r0 []domain.Route
286 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []domain.Route); ok {
287 r0 = returnFunc(ctx, imageName)
288 } else {
289 if ret.Get(0) != nil {
290 r0 = ret.Get(0).([]domain.Route)
291 }
292 }
293 return r0
294}
295
296// MockConfigService_FindRoutesByImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindRoutesByImage'
297type MockConfigService_FindRoutesByImage_Call struct {
298 *mock.Call
299}
300
301// FindRoutesByImage is a helper method to define mock.On call
302// - ctx context.Context
303// - imageName string
304func (_e *MockConfigService_Expecter) FindRoutesByImage(ctx interface{}, imageName interface{}) *MockConfigService_FindRoutesByImage_Call {
305 return &MockConfigService_FindRoutesByImage_Call{Call: _e.mock.On("FindRoutesByImage", ctx, imageName)}
306}
307
308func (_c *MockConfigService_FindRoutesByImage_Call) Run(run func(ctx context.Context, imageName string)) *MockConfigService_FindRoutesByImage_Call {
309 _c.Call.Run(func(args mock.Arguments) {
310 var arg0 context.Context
311 if args[0] != nil {
312 arg0 = args[0].(context.Context)
313 }
314 var arg1 string
315 if args[1] != nil {
316 arg1 = args[1].(string)
317 }
318 run(
319 arg0,
320 arg1,
321 )
322 })
323 return _c
324}
325
326func (_c *MockConfigService_FindRoutesByImage_Call) Return(routes []domain.Route) *MockConfigService_FindRoutesByImage_Call {
327 _c.Call.Return(routes)
328 return _c
329}
330
331func (_c *MockConfigService_FindRoutesByImage_Call) RunAndReturn(run func(ctx context.Context, imageName string) []domain.Route) *MockConfigService_FindRoutesByImage_Call {
332 _c.Call.Return(run)
333 return _c
334}
335
336// GetAllAttachments provides a mock function for the type MockConfigService
337func (_mock *MockConfigService) GetAllAttachments(ctx context.Context) map[string][]string {
338 ret := _mock.Called(ctx)
339
340 if len(ret) == 0 {
341 panic("no return value specified for GetAllAttachments")
342 }
343
344 var r0 map[string][]string
345 if returnFunc, ok := ret.Get(0).(func(context.Context) map[string][]string); ok {
346 r0 = returnFunc(ctx)
347 } else {
348 if ret.Get(0) != nil {
349 r0 = ret.Get(0).(map[string][]string)
350 }
351 }
352 return r0
353}
354
355// MockConfigService_GetAllAttachments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllAttachments'
356type MockConfigService_GetAllAttachments_Call struct {
357 *mock.Call
358}
359
360// GetAllAttachments is a helper method to define mock.On call
361// - ctx context.Context
362func (_e *MockConfigService_Expecter) GetAllAttachments(ctx interface{}) *MockConfigService_GetAllAttachments_Call {
363 return &MockConfigService_GetAllAttachments_Call{Call: _e.mock.On("GetAllAttachments", ctx)}
364}
365
366func (_c *MockConfigService_GetAllAttachments_Call) Run(run func(ctx context.Context)) *MockConfigService_GetAllAttachments_Call {
367 _c.Call.Run(func(args mock.Arguments) {
368 var arg0 context.Context
369 if args[0] != nil {
370 arg0 = args[0].(context.Context)
371 }
372 run(
373 arg0,
374 )
375 })
376 return _c
377}
378
379func (_c *MockConfigService_GetAllAttachments_Call) Return(stringToStrings map[string][]string) *MockConfigService_GetAllAttachments_Call {
380 _c.Call.Return(stringToStrings)
381 return _c
382}
383
384func (_c *MockConfigService_GetAllAttachments_Call) RunAndReturn(run func(ctx context.Context) map[string][]string) *MockConfigService_GetAllAttachments_Call {
385 _c.Call.Return(run)
386 return _c
387}
388
389// GetAllowedDomains provides a mock function for the type MockConfigService
390func (_mock *MockConfigService) GetAllowedDomains() []string {
391 ret := _mock.Called()
392
393 if len(ret) == 0 {
394 panic("no return value specified for GetAllowedDomains")
395 }
396
397 var r0 []string
398 if returnFunc, ok := ret.Get(0).(func() []string); ok {
399 r0 = returnFunc()
400 } else {
401 if ret.Get(0) != nil {
402 r0 = ret.Get(0).([]string)
403 }
404 }
405 return r0
406}
407
408// MockConfigService_GetAllowedDomains_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllowedDomains'
409type MockConfigService_GetAllowedDomains_Call struct {
410 *mock.Call
411}
412
413// GetAllowedDomains is a helper method to define mock.On call
414func (_e *MockConfigService_Expecter) GetAllowedDomains() *MockConfigService_GetAllowedDomains_Call {
415 return &MockConfigService_GetAllowedDomains_Call{Call: _e.mock.On("GetAllowedDomains")}
416}
417
418func (_c *MockConfigService_GetAllowedDomains_Call) Run(run func()) *MockConfigService_GetAllowedDomains_Call {
419 _c.Call.Run(func(args mock.Arguments) {
420 run()
421 })
422 return _c
423}
424
425func (_c *MockConfigService_GetAllowedDomains_Call) Return(strings []string) *MockConfigService_GetAllowedDomains_Call {
426 _c.Call.Return(strings)
427 return _c
428}
429
430func (_c *MockConfigService_GetAllowedDomains_Call) RunAndReturn(run func() []string) *MockConfigService_GetAllowedDomains_Call {
431 _c.Call.Return(run)
432 return _c
433}
434
435// GetAttachmentsFor provides a mock function for the type MockConfigService
436func (_mock *MockConfigService) GetAttachmentsFor(ctx context.Context, domainOrGroup string) ([]string, error) {
437 ret := _mock.Called(ctx, domainOrGroup)
438
439 if len(ret) == 0 {
440 panic("no return value specified for GetAttachmentsFor")
441 }
442
443 var r0 []string
444 var r1 error
445 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]string, error)); ok {
446 return returnFunc(ctx, domainOrGroup)
447 }
448 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []string); ok {
449 r0 = returnFunc(ctx, domainOrGroup)
450 } else {
451 if ret.Get(0) != nil {
452 r0 = ret.Get(0).([]string)
453 }
454 }
455 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
456 r1 = returnFunc(ctx, domainOrGroup)
457 } else {
458 r1 = ret.Error(1)
459 }
460 return r0, r1
461}
462
463// MockConfigService_GetAttachmentsFor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAttachmentsFor'
464type MockConfigService_GetAttachmentsFor_Call struct {
465 *mock.Call
466}
467
468// GetAttachmentsFor is a helper method to define mock.On call
469// - ctx context.Context
470// - domainOrGroup string
471func (_e *MockConfigService_Expecter) GetAttachmentsFor(ctx interface{}, domainOrGroup interface{}) *MockConfigService_GetAttachmentsFor_Call {
472 return &MockConfigService_GetAttachmentsFor_Call{Call: _e.mock.On("GetAttachmentsFor", ctx, domainOrGroup)}
473}
474
475func (_c *MockConfigService_GetAttachmentsFor_Call) Run(run func(ctx context.Context, domainOrGroup string)) *MockConfigService_GetAttachmentsFor_Call {
476 _c.Call.Run(func(args mock.Arguments) {
477 var arg0 context.Context
478 if args[0] != nil {
479 arg0 = args[0].(context.Context)
480 }
481 var arg1 string
482 if args[1] != nil {
483 arg1 = args[1].(string)
484 }
485 run(
486 arg0,
487 arg1,
488 )
489 })
490 return _c
491}
492
493func (_c *MockConfigService_GetAttachmentsFor_Call) Return(strings []string, err error) *MockConfigService_GetAttachmentsFor_Call {
494 _c.Call.Return(strings, err)
495 return _c
496}
497
498func (_c *MockConfigService_GetAttachmentsFor_Call) RunAndReturn(run func(ctx context.Context, domainOrGroup string) ([]string, error)) *MockConfigService_GetAttachmentsFor_Call {
499 _c.Call.Return(run)
500 return _c
501}
502
503// GetAutoRouteAllowedDomains provides a mock function for the type MockConfigService
504func (_mock *MockConfigService) GetAutoRouteAllowedDomains(ctx context.Context) ([]string, error) {
505 ret := _mock.Called(ctx)
506
507 if len(ret) == 0 {
508 panic("no return value specified for GetAutoRouteAllowedDomains")
509 }
510
511 var r0 []string
512 var r1 error
513 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]string, error)); ok {
514 return returnFunc(ctx)
515 }
516 if returnFunc, ok := ret.Get(0).(func(context.Context) []string); ok {
517 r0 = returnFunc(ctx)
518 } else {
519 if ret.Get(0) != nil {
520 r0 = ret.Get(0).([]string)
521 }
522 }
523 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
524 r1 = returnFunc(ctx)
525 } else {
526 r1 = ret.Error(1)
527 }
528 return r0, r1
529}
530
531// MockConfigService_GetAutoRouteAllowedDomains_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAutoRouteAllowedDomains'
532type MockConfigService_GetAutoRouteAllowedDomains_Call struct {
533 *mock.Call
534}
535
536// GetAutoRouteAllowedDomains is a helper method to define mock.On call
537// - ctx context.Context
538func (_e *MockConfigService_Expecter) GetAutoRouteAllowedDomains(ctx interface{}) *MockConfigService_GetAutoRouteAllowedDomains_Call {
539 return &MockConfigService_GetAutoRouteAllowedDomains_Call{Call: _e.mock.On("GetAutoRouteAllowedDomains", ctx)}
540}
541
542func (_c *MockConfigService_GetAutoRouteAllowedDomains_Call) Run(run func(ctx context.Context)) *MockConfigService_GetAutoRouteAllowedDomains_Call {
543 _c.Call.Run(func(args mock.Arguments) {
544 var arg0 context.Context
545 if args[0] != nil {
546 arg0 = args[0].(context.Context)
547 }
548 run(
549 arg0,
550 )
551 })
552 return _c
553}
554
555func (_c *MockConfigService_GetAutoRouteAllowedDomains_Call) Return(strings []string, err error) *MockConfigService_GetAutoRouteAllowedDomains_Call {
556 _c.Call.Return(strings, err)
557 return _c
558}
559
560func (_c *MockConfigService_GetAutoRouteAllowedDomains_Call) RunAndReturn(run func(ctx context.Context) ([]string, error)) *MockConfigService_GetAutoRouteAllowedDomains_Call {
561 _c.Call.Return(run)
562 return _c
563}
564
565// GetDataDir provides a mock function for the type MockConfigService
566func (_mock *MockConfigService) GetDataDir() string {
567 ret := _mock.Called()
568
569 if len(ret) == 0 {
570 panic("no return value specified for GetDataDir")
571 }
572
573 var r0 string
574 if returnFunc, ok := ret.Get(0).(func() string); ok {
575 r0 = returnFunc()
576 } else {
577 r0 = ret.Get(0).(string)
578 }
579 return r0
580}
581
582// MockConfigService_GetDataDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDataDir'
583type MockConfigService_GetDataDir_Call struct {
584 *mock.Call
585}
586
587// GetDataDir is a helper method to define mock.On call
588func (_e *MockConfigService_Expecter) GetDataDir() *MockConfigService_GetDataDir_Call {
589 return &MockConfigService_GetDataDir_Call{Call: _e.mock.On("GetDataDir")}
590}
591
592func (_c *MockConfigService_GetDataDir_Call) Run(run func()) *MockConfigService_GetDataDir_Call {
593 _c.Call.Run(func(args mock.Arguments) {
594 run()
595 })
596 return _c
597}
598
599func (_c *MockConfigService_GetDataDir_Call) Return(s string) *MockConfigService_GetDataDir_Call {
600 _c.Call.Return(s)
601 return _c
602}
603
604func (_c *MockConfigService_GetDataDir_Call) RunAndReturn(run func() string) *MockConfigService_GetDataDir_Call {
605 _c.Call.Return(run)
606 return _c
607}
608
609// GetExternalRoutes provides a mock function for the type MockConfigService
610func (_mock *MockConfigService) GetExternalRoutes() map[string]string {
611 ret := _mock.Called()
612
613 if len(ret) == 0 {
614 panic("no return value specified for GetExternalRoutes")
615 }
616
617 var r0 map[string]string
618 if returnFunc, ok := ret.Get(0).(func() map[string]string); ok {
619 r0 = returnFunc()
620 } else {
621 if ret.Get(0) != nil {
622 r0 = ret.Get(0).(map[string]string)
623 }
624 }
625 return r0
626}
627
628// MockConfigService_GetExternalRoutes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetExternalRoutes'
629type MockConfigService_GetExternalRoutes_Call struct {
630 *mock.Call
631}
632
633// GetExternalRoutes is a helper method to define mock.On call
634func (_e *MockConfigService_Expecter) GetExternalRoutes() *MockConfigService_GetExternalRoutes_Call {
635 return &MockConfigService_GetExternalRoutes_Call{Call: _e.mock.On("GetExternalRoutes")}
636}
637
638func (_c *MockConfigService_GetExternalRoutes_Call) Run(run func()) *MockConfigService_GetExternalRoutes_Call {
639 _c.Call.Run(func(args mock.Arguments) {
640 run()
641 })
642 return _c
643}
644
645func (_c *MockConfigService_GetExternalRoutes_Call) Return(stringToString map[string]string) *MockConfigService_GetExternalRoutes_Call {
646 _c.Call.Return(stringToString)
647 return _c
648}
649
650func (_c *MockConfigService_GetExternalRoutes_Call) RunAndReturn(run func() map[string]string) *MockConfigService_GetExternalRoutes_Call {
651 _c.Call.Return(run)
652 return _c
653}
654
655// GetNetworkPrefix provides a mock function for the type MockConfigService
656func (_mock *MockConfigService) GetNetworkPrefix() string {
657 ret := _mock.Called()
658
659 if len(ret) == 0 {
660 panic("no return value specified for GetNetworkPrefix")
661 }
662
663 var r0 string
664 if returnFunc, ok := ret.Get(0).(func() string); ok {
665 r0 = returnFunc()
666 } else {
667 r0 = ret.Get(0).(string)
668 }
669 return r0
670}
671
672// MockConfigService_GetNetworkPrefix_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNetworkPrefix'
673type MockConfigService_GetNetworkPrefix_Call struct {
674 *mock.Call
675}
676
677// GetNetworkPrefix is a helper method to define mock.On call
678func (_e *MockConfigService_Expecter) GetNetworkPrefix() *MockConfigService_GetNetworkPrefix_Call {
679 return &MockConfigService_GetNetworkPrefix_Call{Call: _e.mock.On("GetNetworkPrefix")}
680}
681
682func (_c *MockConfigService_GetNetworkPrefix_Call) Run(run func()) *MockConfigService_GetNetworkPrefix_Call {
683 _c.Call.Run(func(args mock.Arguments) {
684 run()
685 })
686 return _c
687}
688
689func (_c *MockConfigService_GetNetworkPrefix_Call) Return(s string) *MockConfigService_GetNetworkPrefix_Call {
690 _c.Call.Return(s)
691 return _c
692}
693
694func (_c *MockConfigService_GetNetworkPrefix_Call) RunAndReturn(run func() string) *MockConfigService_GetNetworkPrefix_Call {
695 _c.Call.Return(run)
696 return _c
697}
698
699// GetPreviewConfig provides a mock function for the type MockConfigService
700func (_mock *MockConfigService) GetPreviewConfig() domain.PreviewConfig {
701 ret := _mock.Called()
702
703 if len(ret) == 0 {
704 panic("no return value specified for GetPreviewConfig")
705 }
706
707 var r0 domain.PreviewConfig
708 if returnFunc, ok := ret.Get(0).(func() domain.PreviewConfig); ok {
709 r0 = returnFunc()
710 } else {
711 r0 = ret.Get(0).(domain.PreviewConfig)
712 }
713 return r0
714}
715
716// MockConfigService_GetPreviewConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPreviewConfig'
717type MockConfigService_GetPreviewConfig_Call struct {
718 *mock.Call
719}
720
721// GetPreviewConfig is a helper method to define mock.On call
722func (_e *MockConfigService_Expecter) GetPreviewConfig() *MockConfigService_GetPreviewConfig_Call {
723 return &MockConfigService_GetPreviewConfig_Call{Call: _e.mock.On("GetPreviewConfig")}
724}
725
726func (_c *MockConfigService_GetPreviewConfig_Call) Run(run func()) *MockConfigService_GetPreviewConfig_Call {
727 _c.Call.Run(func(args mock.Arguments) {
728 run()
729 })
730 return _c
731}
732
733func (_c *MockConfigService_GetPreviewConfig_Call) Return(previewConfig domain.PreviewConfig) *MockConfigService_GetPreviewConfig_Call {
734 _c.Call.Return(previewConfig)
735 return _c
736}
737
738func (_c *MockConfigService_GetPreviewConfig_Call) RunAndReturn(run func() domain.PreviewConfig) *MockConfigService_GetPreviewConfig_Call {
739 _c.Call.Return(run)
740 return _c
741}
742
743// GetPreviewTagPatterns provides a mock function for the type MockConfigService
744func (_mock *MockConfigService) GetPreviewTagPatterns() []string {
745 ret := _mock.Called()
746
747 if len(ret) == 0 {
748 panic("no return value specified for GetPreviewTagPatterns")
749 }
750
751 var r0 []string
752 if returnFunc, ok := ret.Get(0).(func() []string); ok {
753 r0 = returnFunc()
754 } else {
755 if ret.Get(0) != nil {
756 r0 = ret.Get(0).([]string)
757 }
758 }
759 return r0
760}
761
762// MockConfigService_GetPreviewTagPatterns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPreviewTagPatterns'
763type MockConfigService_GetPreviewTagPatterns_Call struct {
764 *mock.Call
765}
766
767// GetPreviewTagPatterns is a helper method to define mock.On call
768func (_e *MockConfigService_Expecter) GetPreviewTagPatterns() *MockConfigService_GetPreviewTagPatterns_Call {
769 return &MockConfigService_GetPreviewTagPatterns_Call{Call: _e.mock.On("GetPreviewTagPatterns")}
770}
771
772func (_c *MockConfigService_GetPreviewTagPatterns_Call) Run(run func()) *MockConfigService_GetPreviewTagPatterns_Call {
773 _c.Call.Run(func(args mock.Arguments) {
774 run()
775 })
776 return _c
777}
778
779func (_c *MockConfigService_GetPreviewTagPatterns_Call) Return(strings []string) *MockConfigService_GetPreviewTagPatterns_Call {
780 _c.Call.Return(strings)
781 return _c
782}
783
784func (_c *MockConfigService_GetPreviewTagPatterns_Call) RunAndReturn(run func() []string) *MockConfigService_GetPreviewTagPatterns_Call {
785 _c.Call.Return(run)
786 return _c
787}
788
789// GetRegistryDomain provides a mock function for the type MockConfigService
790func (_mock *MockConfigService) GetRegistryDomain() string {
791 ret := _mock.Called()
792
793 if len(ret) == 0 {
794 panic("no return value specified for GetRegistryDomain")
795 }
796
797 var r0 string
798 if returnFunc, ok := ret.Get(0).(func() string); ok {
799 r0 = returnFunc()
800 } else {
801 r0 = ret.Get(0).(string)
802 }
803 return r0
804}
805
806// MockConfigService_GetRegistryDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRegistryDomain'
807type MockConfigService_GetRegistryDomain_Call struct {
808 *mock.Call
809}
810
811// GetRegistryDomain is a helper method to define mock.On call
812func (_e *MockConfigService_Expecter) GetRegistryDomain() *MockConfigService_GetRegistryDomain_Call {
813 return &MockConfigService_GetRegistryDomain_Call{Call: _e.mock.On("GetRegistryDomain")}
814}
815
816func (_c *MockConfigService_GetRegistryDomain_Call) Run(run func()) *MockConfigService_GetRegistryDomain_Call {
817 _c.Call.Run(func(args mock.Arguments) {
818 run()
819 })
820 return _c
821}
822
823func (_c *MockConfigService_GetRegistryDomain_Call) Return(s string) *MockConfigService_GetRegistryDomain_Call {
824 _c.Call.Return(s)
825 return _c
826}
827
828func (_c *MockConfigService_GetRegistryDomain_Call) RunAndReturn(run func() string) *MockConfigService_GetRegistryDomain_Call {
829 _c.Call.Return(run)
830 return _c
831}
832
833// GetRegistryPort provides a mock function for the type MockConfigService
834func (_mock *MockConfigService) GetRegistryPort() int {
835 ret := _mock.Called()
836
837 if len(ret) == 0 {
838 panic("no return value specified for GetRegistryPort")
839 }
840
841 var r0 int
842 if returnFunc, ok := ret.Get(0).(func() int); ok {
843 r0 = returnFunc()
844 } else {
845 r0 = ret.Get(0).(int)
846 }
847 return r0
848}
849
850// MockConfigService_GetRegistryPort_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRegistryPort'
851type MockConfigService_GetRegistryPort_Call struct {
852 *mock.Call
853}
854
855// GetRegistryPort is a helper method to define mock.On call
856func (_e *MockConfigService_Expecter) GetRegistryPort() *MockConfigService_GetRegistryPort_Call {
857 return &MockConfigService_GetRegistryPort_Call{Call: _e.mock.On("GetRegistryPort")}
858}
859
860func (_c *MockConfigService_GetRegistryPort_Call) Run(run func()) *MockConfigService_GetRegistryPort_Call {
861 _c.Call.Run(func(args mock.Arguments) {
862 run()
863 })
864 return _c
865}
866
867func (_c *MockConfigService_GetRegistryPort_Call) Return(n int) *MockConfigService_GetRegistryPort_Call {
868 _c.Call.Return(n)
869 return _c
870}
871
872func (_c *MockConfigService_GetRegistryPort_Call) RunAndReturn(run func() int) *MockConfigService_GetRegistryPort_Call {
873 _c.Call.Return(run)
874 return _c
875}
876
877// GetRoute provides a mock function for the type MockConfigService
878func (_mock *MockConfigService) GetRoute(ctx context.Context, domain1 string) (*domain.Route, error) {
879 ret := _mock.Called(ctx, domain1)
880
881 if len(ret) == 0 {
882 panic("no return value specified for GetRoute")
883 }
884
885 var r0 *domain.Route
886 var r1 error
887 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*domain.Route, error)); ok {
888 return returnFunc(ctx, domain1)
889 }
890 if returnFunc, ok := ret.Get(0).(func(context.Context, string) *domain.Route); ok {
891 r0 = returnFunc(ctx, domain1)
892 } else {
893 if ret.Get(0) != nil {
894 r0 = ret.Get(0).(*domain.Route)
895 }
896 }
897 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
898 r1 = returnFunc(ctx, domain1)
899 } else {
900 r1 = ret.Error(1)
901 }
902 return r0, r1
903}
904
905// MockConfigService_GetRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRoute'
906type MockConfigService_GetRoute_Call struct {
907 *mock.Call
908}
909
910// GetRoute is a helper method to define mock.On call
911// - ctx context.Context
912// - domain1 string
913func (_e *MockConfigService_Expecter) GetRoute(ctx interface{}, domain1 interface{}) *MockConfigService_GetRoute_Call {
914 return &MockConfigService_GetRoute_Call{Call: _e.mock.On("GetRoute", ctx, domain1)}
915}
916
917func (_c *MockConfigService_GetRoute_Call) Run(run func(ctx context.Context, domain1 string)) *MockConfigService_GetRoute_Call {
918 _c.Call.Run(func(args mock.Arguments) {
919 var arg0 context.Context
920 if args[0] != nil {
921 arg0 = args[0].(context.Context)
922 }
923 var arg1 string
924 if args[1] != nil {
925 arg1 = args[1].(string)
926 }
927 run(
928 arg0,
929 arg1,
930 )
931 })
932 return _c
933}
934
935func (_c *MockConfigService_GetRoute_Call) Return(route *domain.Route, err error) *MockConfigService_GetRoute_Call {
936 _c.Call.Return(route, err)
937 return _c
938}
939
940func (_c *MockConfigService_GetRoute_Call) RunAndReturn(run func(ctx context.Context, domain1 string) (*domain.Route, error)) *MockConfigService_GetRoute_Call {
941 _c.Call.Return(run)
942 return _c
943}
944
945// GetRoutes provides a mock function for the type MockConfigService
946func (_mock *MockConfigService) GetRoutes(ctx context.Context) []domain.Route {
947 ret := _mock.Called(ctx)
948
949 if len(ret) == 0 {
950 panic("no return value specified for GetRoutes")
951 }
952
953 var r0 []domain.Route
954 if returnFunc, ok := ret.Get(0).(func(context.Context) []domain.Route); ok {
955 r0 = returnFunc(ctx)
956 } else {
957 if ret.Get(0) != nil {
958 r0 = ret.Get(0).([]domain.Route)
959 }
960 }
961 return r0
962}
963
964// MockConfigService_GetRoutes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRoutes'
965type MockConfigService_GetRoutes_Call struct {
966 *mock.Call
967}
968
969// GetRoutes is a helper method to define mock.On call
970// - ctx context.Context
971func (_e *MockConfigService_Expecter) GetRoutes(ctx interface{}) *MockConfigService_GetRoutes_Call {
972 return &MockConfigService_GetRoutes_Call{Call: _e.mock.On("GetRoutes", ctx)}
973}
974
975func (_c *MockConfigService_GetRoutes_Call) Run(run func(ctx context.Context)) *MockConfigService_GetRoutes_Call {
976 _c.Call.Run(func(args mock.Arguments) {
977 var arg0 context.Context
978 if args[0] != nil {
979 arg0 = args[0].(context.Context)
980 }
981 run(
982 arg0,
983 )
984 })
985 return _c
986}
987
988func (_c *MockConfigService_GetRoutes_Call) Return(routes []domain.Route) *MockConfigService_GetRoutes_Call {
989 _c.Call.Return(routes)
990 return _c
991}
992
993func (_c *MockConfigService_GetRoutes_Call) RunAndReturn(run func(ctx context.Context) []domain.Route) *MockConfigService_GetRoutes_Call {
994 _c.Call.Return(run)
995 return _c
996}
997
998// GetServerPort provides a mock function for the type MockConfigService
999func (_mock *MockConfigService) GetServerPort() int {
1000 ret := _mock.Called()
1001
1002 if len(ret) == 0 {
1003 panic("no return value specified for GetServerPort")
1004 }
1005
1006 var r0 int
1007 if returnFunc, ok := ret.Get(0).(func() int); ok {
1008 r0 = returnFunc()
1009 } else {
1010 r0 = ret.Get(0).(int)
1011 }
1012 return r0
1013}
1014
1015// MockConfigService_GetServerPort_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServerPort'
1016type MockConfigService_GetServerPort_Call struct {
1017 *mock.Call
1018}
1019
1020// GetServerPort is a helper method to define mock.On call
1021func (_e *MockConfigService_Expecter) GetServerPort() *MockConfigService_GetServerPort_Call {
1022 return &MockConfigService_GetServerPort_Call{Call: _e.mock.On("GetServerPort")}
1023}
1024
1025func (_c *MockConfigService_GetServerPort_Call) Run(run func()) *MockConfigService_GetServerPort_Call {
1026 _c.Call.Run(func(args mock.Arguments) {
1027 run()
1028 })
1029 return _c
1030}
1031
1032func (_c *MockConfigService_GetServerPort_Call) Return(n int) *MockConfigService_GetServerPort_Call {
1033 _c.Call.Return(n)
1034 return _c
1035}
1036
1037func (_c *MockConfigService_GetServerPort_Call) RunAndReturn(run func() int) *MockConfigService_GetServerPort_Call {
1038 _c.Call.Return(run)
1039 return _c
1040}
1041
1042// IsAutoEnabled provides a mock function for the type MockConfigService
1043func (_mock *MockConfigService) IsAutoEnabled() bool {
1044 ret := _mock.Called()
1045
1046 if len(ret) == 0 {
1047 panic("no return value specified for IsAutoEnabled")
1048 }
1049
1050 var r0 bool
1051 if returnFunc, ok := ret.Get(0).(func() bool); ok {
1052 r0 = returnFunc()
1053 } else {
1054 r0 = ret.Get(0).(bool)
1055 }
1056 return r0
1057}
1058
1059// MockConfigService_IsAutoEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsAutoEnabled'
1060type MockConfigService_IsAutoEnabled_Call struct {
1061 *mock.Call
1062}
1063
1064// IsAutoEnabled is a helper method to define mock.On call
1065func (_e *MockConfigService_Expecter) IsAutoEnabled() *MockConfigService_IsAutoEnabled_Call {
1066 return &MockConfigService_IsAutoEnabled_Call{Call: _e.mock.On("IsAutoEnabled")}
1067}
1068
1069func (_c *MockConfigService_IsAutoEnabled_Call) Run(run func()) *MockConfigService_IsAutoEnabled_Call {
1070 _c.Call.Run(func(args mock.Arguments) {
1071 run()
1072 })
1073 return _c
1074}
1075
1076func (_c *MockConfigService_IsAutoEnabled_Call) Return(b bool) *MockConfigService_IsAutoEnabled_Call {
1077 _c.Call.Return(b)
1078 return _c
1079}
1080
1081func (_c *MockConfigService_IsAutoEnabled_Call) RunAndReturn(run func() bool) *MockConfigService_IsAutoEnabled_Call {
1082 _c.Call.Return(run)
1083 return _c
1084}
1085
1086// IsAutoRouteEnabled provides a mock function for the type MockConfigService
1087func (_mock *MockConfigService) IsAutoRouteEnabled() bool {
1088 ret := _mock.Called()
1089
1090 if len(ret) == 0 {
1091 panic("no return value specified for IsAutoRouteEnabled")
1092 }
1093
1094 var r0 bool
1095 if returnFunc, ok := ret.Get(0).(func() bool); ok {
1096 r0 = returnFunc()
1097 } else {
1098 r0 = ret.Get(0).(bool)
1099 }
1100 return r0
1101}
1102
1103// MockConfigService_IsAutoRouteEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsAutoRouteEnabled'
1104type MockConfigService_IsAutoRouteEnabled_Call struct {
1105 *mock.Call
1106}
1107
1108// IsAutoRouteEnabled is a helper method to define mock.On call
1109func (_e *MockConfigService_Expecter) IsAutoRouteEnabled() *MockConfigService_IsAutoRouteEnabled_Call {
1110 return &MockConfigService_IsAutoRouteEnabled_Call{Call: _e.mock.On("IsAutoRouteEnabled")}
1111}
1112
1113func (_c *MockConfigService_IsAutoRouteEnabled_Call) Run(run func()) *MockConfigService_IsAutoRouteEnabled_Call {
1114 _c.Call.Run(func(args mock.Arguments) {
1115 run()
1116 })
1117 return _c
1118}
1119
1120func (_c *MockConfigService_IsAutoRouteEnabled_Call) Return(b bool) *MockConfigService_IsAutoRouteEnabled_Call {
1121 _c.Call.Return(b)
1122 return _c
1123}
1124
1125func (_c *MockConfigService_IsAutoRouteEnabled_Call) RunAndReturn(run func() bool) *MockConfigService_IsAutoRouteEnabled_Call {
1126 _c.Call.Return(run)
1127 return _c
1128}
1129
1130// IsNetworkIsolationEnabled provides a mock function for the type MockConfigService
1131func (_mock *MockConfigService) IsNetworkIsolationEnabled() bool {
1132 ret := _mock.Called()
1133
1134 if len(ret) == 0 {
1135 panic("no return value specified for IsNetworkIsolationEnabled")
1136 }
1137
1138 var r0 bool
1139 if returnFunc, ok := ret.Get(0).(func() bool); ok {
1140 r0 = returnFunc()
1141 } else {
1142 r0 = ret.Get(0).(bool)
1143 }
1144 return r0
1145}
1146
1147// MockConfigService_IsNetworkIsolationEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsNetworkIsolationEnabled'
1148type MockConfigService_IsNetworkIsolationEnabled_Call struct {
1149 *mock.Call
1150}
1151
1152// IsNetworkIsolationEnabled is a helper method to define mock.On call
1153func (_e *MockConfigService_Expecter) IsNetworkIsolationEnabled() *MockConfigService_IsNetworkIsolationEnabled_Call {
1154 return &MockConfigService_IsNetworkIsolationEnabled_Call{Call: _e.mock.On("IsNetworkIsolationEnabled")}
1155}
1156
1157func (_c *MockConfigService_IsNetworkIsolationEnabled_Call) Run(run func()) *MockConfigService_IsNetworkIsolationEnabled_Call {
1158 _c.Call.Run(func(args mock.Arguments) {
1159 run()
1160 })
1161 return _c
1162}
1163
1164func (_c *MockConfigService_IsNetworkIsolationEnabled_Call) Return(b bool) *MockConfigService_IsNetworkIsolationEnabled_Call {
1165 _c.Call.Return(b)
1166 return _c
1167}
1168
1169func (_c *MockConfigService_IsNetworkIsolationEnabled_Call) RunAndReturn(run func() bool) *MockConfigService_IsNetworkIsolationEnabled_Call {
1170 _c.Call.Return(run)
1171 return _c
1172}
1173
1174// IsPreviewEnabled provides a mock function for the type MockConfigService
1175func (_mock *MockConfigService) IsPreviewEnabled() bool {
1176 ret := _mock.Called()
1177
1178 if len(ret) == 0 {
1179 panic("no return value specified for IsPreviewEnabled")
1180 }
1181
1182 var r0 bool
1183 if returnFunc, ok := ret.Get(0).(func() bool); ok {
1184 r0 = returnFunc()
1185 } else {
1186 r0 = ret.Get(0).(bool)
1187 }
1188 return r0
1189}
1190
1191// MockConfigService_IsPreviewEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsPreviewEnabled'
1192type MockConfigService_IsPreviewEnabled_Call struct {
1193 *mock.Call
1194}
1195
1196// IsPreviewEnabled is a helper method to define mock.On call
1197func (_e *MockConfigService_Expecter) IsPreviewEnabled() *MockConfigService_IsPreviewEnabled_Call {
1198 return &MockConfigService_IsPreviewEnabled_Call{Call: _e.mock.On("IsPreviewEnabled")}
1199}
1200
1201func (_c *MockConfigService_IsPreviewEnabled_Call) Run(run func()) *MockConfigService_IsPreviewEnabled_Call {
1202 _c.Call.Run(func(args mock.Arguments) {
1203 run()
1204 })
1205 return _c
1206}
1207
1208func (_c *MockConfigService_IsPreviewEnabled_Call) Return(b bool) *MockConfigService_IsPreviewEnabled_Call {
1209 _c.Call.Return(b)
1210 return _c
1211}
1212
1213func (_c *MockConfigService_IsPreviewEnabled_Call) RunAndReturn(run func() bool) *MockConfigService_IsPreviewEnabled_Call {
1214 _c.Call.Return(run)
1215 return _c
1216}
1217
1218// Load provides a mock function for the type MockConfigService
1219func (_mock *MockConfigService) Load(ctx context.Context) error {
1220 ret := _mock.Called(ctx)
1221
1222 if len(ret) == 0 {
1223 panic("no return value specified for Load")
1224 }
1225
1226 var r0 error
1227 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1228 r0 = returnFunc(ctx)
1229 } else {
1230 r0 = ret.Error(0)
1231 }
1232 return r0
1233}
1234
1235// MockConfigService_Load_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Load'
1236type MockConfigService_Load_Call struct {
1237 *mock.Call
1238}
1239
1240// Load is a helper method to define mock.On call
1241// - ctx context.Context
1242func (_e *MockConfigService_Expecter) Load(ctx interface{}) *MockConfigService_Load_Call {
1243 return &MockConfigService_Load_Call{Call: _e.mock.On("Load", ctx)}
1244}
1245
1246func (_c *MockConfigService_Load_Call) Run(run func(ctx context.Context)) *MockConfigService_Load_Call {
1247 _c.Call.Run(func(args mock.Arguments) {
1248 var arg0 context.Context
1249 if args[0] != nil {
1250 arg0 = args[0].(context.Context)
1251 }
1252 run(
1253 arg0,
1254 )
1255 })
1256 return _c
1257}
1258
1259func (_c *MockConfigService_Load_Call) Return(err error) *MockConfigService_Load_Call {
1260 _c.Call.Return(err)
1261 return _c
1262}
1263
1264func (_c *MockConfigService_Load_Call) RunAndReturn(run func(ctx context.Context) error) *MockConfigService_Load_Call {
1265 _c.Call.Return(run)
1266 return _c
1267}
1268
1269// Reload provides a mock function for the type MockConfigService
1270func (_mock *MockConfigService) Reload(ctx context.Context) error {
1271 ret := _mock.Called(ctx)
1272
1273 if len(ret) == 0 {
1274 panic("no return value specified for Reload")
1275 }
1276
1277 var r0 error
1278 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1279 r0 = returnFunc(ctx)
1280 } else {
1281 r0 = ret.Error(0)
1282 }
1283 return r0
1284}
1285
1286// MockConfigService_Reload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reload'
1287type MockConfigService_Reload_Call struct {
1288 *mock.Call
1289}
1290
1291// Reload is a helper method to define mock.On call
1292// - ctx context.Context
1293func (_e *MockConfigService_Expecter) Reload(ctx interface{}) *MockConfigService_Reload_Call {
1294 return &MockConfigService_Reload_Call{Call: _e.mock.On("Reload", ctx)}
1295}
1296
1297func (_c *MockConfigService_Reload_Call) Run(run func(ctx context.Context)) *MockConfigService_Reload_Call {
1298 _c.Call.Run(func(args mock.Arguments) {
1299 var arg0 context.Context
1300 if args[0] != nil {
1301 arg0 = args[0].(context.Context)
1302 }
1303 run(
1304 arg0,
1305 )
1306 })
1307 return _c
1308}
1309
1310func (_c *MockConfigService_Reload_Call) Return(err error) *MockConfigService_Reload_Call {
1311 _c.Call.Return(err)
1312 return _c
1313}
1314
1315func (_c *MockConfigService_Reload_Call) RunAndReturn(run func(ctx context.Context) error) *MockConfigService_Reload_Call {
1316 _c.Call.Return(run)
1317 return _c
1318}
1319
1320// RemoveAttachment provides a mock function for the type MockConfigService
1321func (_mock *MockConfigService) RemoveAttachment(ctx context.Context, domainOrGroup string, image string) error {
1322 ret := _mock.Called(ctx, domainOrGroup, image)
1323
1324 if len(ret) == 0 {
1325 panic("no return value specified for RemoveAttachment")
1326 }
1327
1328 var r0 error
1329 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
1330 r0 = returnFunc(ctx, domainOrGroup, image)
1331 } else {
1332 r0 = ret.Error(0)
1333 }
1334 return r0
1335}
1336
1337// MockConfigService_RemoveAttachment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAttachment'
1338type MockConfigService_RemoveAttachment_Call struct {
1339 *mock.Call
1340}
1341
1342// RemoveAttachment is a helper method to define mock.On call
1343// - ctx context.Context
1344// - domainOrGroup string
1345// - image string
1346func (_e *MockConfigService_Expecter) RemoveAttachment(ctx interface{}, domainOrGroup interface{}, image interface{}) *MockConfigService_RemoveAttachment_Call {
1347 return &MockConfigService_RemoveAttachment_Call{Call: _e.mock.On("RemoveAttachment", ctx, domainOrGroup, image)}
1348}
1349
1350func (_c *MockConfigService_RemoveAttachment_Call) Run(run func(ctx context.Context, domainOrGroup string, image string)) *MockConfigService_RemoveAttachment_Call {
1351 _c.Call.Run(func(args mock.Arguments) {
1352 var arg0 context.Context
1353 if args[0] != nil {
1354 arg0 = args[0].(context.Context)
1355 }
1356 var arg1 string
1357 if args[1] != nil {
1358 arg1 = args[1].(string)
1359 }
1360 var arg2 string
1361 if args[2] != nil {
1362 arg2 = args[2].(string)
1363 }
1364 run(
1365 arg0,
1366 arg1,
1367 arg2,
1368 )
1369 })
1370 return _c
1371}
1372
1373func (_c *MockConfigService_RemoveAttachment_Call) Return(err error) *MockConfigService_RemoveAttachment_Call {
1374 _c.Call.Return(err)
1375 return _c
1376}
1377
1378func (_c *MockConfigService_RemoveAttachment_Call) RunAndReturn(run func(ctx context.Context, domainOrGroup string, image string) error) *MockConfigService_RemoveAttachment_Call {
1379 _c.Call.Return(run)
1380 return _c
1381}
1382
1383// RemoveAutoRouteAllowedDomain provides a mock function for the type MockConfigService
1384func (_mock *MockConfigService) RemoveAutoRouteAllowedDomain(ctx context.Context, pattern string) error {
1385 ret := _mock.Called(ctx, pattern)
1386
1387 if len(ret) == 0 {
1388 panic("no return value specified for RemoveAutoRouteAllowedDomain")
1389 }
1390
1391 var r0 error
1392 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
1393 r0 = returnFunc(ctx, pattern)
1394 } else {
1395 r0 = ret.Error(0)
1396 }
1397 return r0
1398}
1399
1400// MockConfigService_RemoveAutoRouteAllowedDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAutoRouteAllowedDomain'
1401type MockConfigService_RemoveAutoRouteAllowedDomain_Call struct {
1402 *mock.Call
1403}
1404
1405// RemoveAutoRouteAllowedDomain is a helper method to define mock.On call
1406// - ctx context.Context
1407// - pattern string
1408func (_e *MockConfigService_Expecter) RemoveAutoRouteAllowedDomain(ctx interface{}, pattern interface{}) *MockConfigService_RemoveAutoRouteAllowedDomain_Call {
1409 return &MockConfigService_RemoveAutoRouteAllowedDomain_Call{Call: _e.mock.On("RemoveAutoRouteAllowedDomain", ctx, pattern)}
1410}
1411
1412func (_c *MockConfigService_RemoveAutoRouteAllowedDomain_Call) Run(run func(ctx context.Context, pattern string)) *MockConfigService_RemoveAutoRouteAllowedDomain_Call {
1413 _c.Call.Run(func(args mock.Arguments) {
1414 var arg0 context.Context
1415 if args[0] != nil {
1416 arg0 = args[0].(context.Context)
1417 }
1418 var arg1 string
1419 if args[1] != nil {
1420 arg1 = args[1].(string)
1421 }
1422 run(
1423 arg0,
1424 arg1,
1425 )
1426 })
1427 return _c
1428}
1429
1430func (_c *MockConfigService_RemoveAutoRouteAllowedDomain_Call) Return(err error) *MockConfigService_RemoveAutoRouteAllowedDomain_Call {
1431 _c.Call.Return(err)
1432 return _c
1433}
1434
1435func (_c *MockConfigService_RemoveAutoRouteAllowedDomain_Call) RunAndReturn(run func(ctx context.Context, pattern string) error) *MockConfigService_RemoveAutoRouteAllowedDomain_Call {
1436 _c.Call.Return(run)
1437 return _c
1438}
1439
1440// RemoveRoute provides a mock function for the type MockConfigService
1441func (_mock *MockConfigService) RemoveRoute(ctx context.Context, domain1 string) error {
1442 ret := _mock.Called(ctx, domain1)
1443
1444 if len(ret) == 0 {
1445 panic("no return value specified for RemoveRoute")
1446 }
1447
1448 var r0 error
1449 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
1450 r0 = returnFunc(ctx, domain1)
1451 } else {
1452 r0 = ret.Error(0)
1453 }
1454 return r0
1455}
1456
1457// MockConfigService_RemoveRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRoute'
1458type MockConfigService_RemoveRoute_Call struct {
1459 *mock.Call
1460}
1461
1462// RemoveRoute is a helper method to define mock.On call
1463// - ctx context.Context
1464// - domain1 string
1465func (_e *MockConfigService_Expecter) RemoveRoute(ctx interface{}, domain1 interface{}) *MockConfigService_RemoveRoute_Call {
1466 return &MockConfigService_RemoveRoute_Call{Call: _e.mock.On("RemoveRoute", ctx, domain1)}
1467}
1468
1469func (_c *MockConfigService_RemoveRoute_Call) Run(run func(ctx context.Context, domain1 string)) *MockConfigService_RemoveRoute_Call {
1470 _c.Call.Run(func(args mock.Arguments) {
1471 var arg0 context.Context
1472 if args[0] != nil {
1473 arg0 = args[0].(context.Context)
1474 }
1475 var arg1 string
1476 if args[1] != nil {
1477 arg1 = args[1].(string)
1478 }
1479 run(
1480 arg0,
1481 arg1,
1482 )
1483 })
1484 return _c
1485}
1486
1487func (_c *MockConfigService_RemoveRoute_Call) Return(err error) *MockConfigService_RemoveRoute_Call {
1488 _c.Call.Return(err)
1489 return _c
1490}
1491
1492func (_c *MockConfigService_RemoveRoute_Call) RunAndReturn(run func(ctx context.Context, domain1 string) error) *MockConfigService_RemoveRoute_Call {
1493 _c.Call.Return(run)
1494 return _c
1495}
1496
1497// Save provides a mock function for the type MockConfigService
1498func (_mock *MockConfigService) Save(ctx context.Context) error {
1499 ret := _mock.Called(ctx)
1500
1501 if len(ret) == 0 {
1502 panic("no return value specified for Save")
1503 }
1504
1505 var r0 error
1506 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1507 r0 = returnFunc(ctx)
1508 } else {
1509 r0 = ret.Error(0)
1510 }
1511 return r0
1512}
1513
1514// MockConfigService_Save_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Save'
1515type MockConfigService_Save_Call struct {
1516 *mock.Call
1517}
1518
1519// Save is a helper method to define mock.On call
1520// - ctx context.Context
1521func (_e *MockConfigService_Expecter) Save(ctx interface{}) *MockConfigService_Save_Call {
1522 return &MockConfigService_Save_Call{Call: _e.mock.On("Save", ctx)}
1523}
1524
1525func (_c *MockConfigService_Save_Call) Run(run func(ctx context.Context)) *MockConfigService_Save_Call {
1526 _c.Call.Run(func(args mock.Arguments) {
1527 var arg0 context.Context
1528 if args[0] != nil {
1529 arg0 = args[0].(context.Context)
1530 }
1531 run(
1532 arg0,
1533 )
1534 })
1535 return _c
1536}
1537
1538func (_c *MockConfigService_Save_Call) Return(err error) *MockConfigService_Save_Call {
1539 _c.Call.Return(err)
1540 return _c
1541}
1542
1543func (_c *MockConfigService_Save_Call) RunAndReturn(run func(ctx context.Context) error) *MockConfigService_Save_Call {
1544 _c.Call.Return(run)
1545 return _c
1546}
1547
1548// UpdateRoute provides a mock function for the type MockConfigService
1549func (_mock *MockConfigService) UpdateRoute(ctx context.Context, route domain.Route) error {
1550 ret := _mock.Called(ctx, route)
1551
1552 if len(ret) == 0 {
1553 panic("no return value specified for UpdateRoute")
1554 }
1555
1556 var r0 error
1557 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Route) error); ok {
1558 r0 = returnFunc(ctx, route)
1559 } else {
1560 r0 = ret.Error(0)
1561 }
1562 return r0
1563}
1564
1565// MockConfigService_UpdateRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRoute'
1566type MockConfigService_UpdateRoute_Call struct {
1567 *mock.Call
1568}
1569
1570// UpdateRoute is a helper method to define mock.On call
1571// - ctx context.Context
1572// - route domain.Route
1573func (_e *MockConfigService_Expecter) UpdateRoute(ctx interface{}, route interface{}) *MockConfigService_UpdateRoute_Call {
1574 return &MockConfigService_UpdateRoute_Call{Call: _e.mock.On("UpdateRoute", ctx, route)}
1575}
1576
1577func (_c *MockConfigService_UpdateRoute_Call) Run(run func(ctx context.Context, route domain.Route)) *MockConfigService_UpdateRoute_Call {
1578 _c.Call.Run(func(args mock.Arguments) {
1579 var arg0 context.Context
1580 if args[0] != nil {
1581 arg0 = args[0].(context.Context)
1582 }
1583 var arg1 domain.Route
1584 if args[1] != nil {
1585 arg1 = args[1].(domain.Route)
1586 }
1587 run(
1588 arg0,
1589 arg1,
1590 )
1591 })
1592 return _c
1593}
1594
1595func (_c *MockConfigService_UpdateRoute_Call) Return(err error) *MockConfigService_UpdateRoute_Call {
1596 _c.Call.Return(err)
1597 return _c
1598}
1599
1600func (_c *MockConfigService_UpdateRoute_Call) RunAndReturn(run func(ctx context.Context, route domain.Route) error) *MockConfigService_UpdateRoute_Call {
1601 _c.Call.Return(run)
1602 return _c
1603}
1604
1605// Watch provides a mock function for the type MockConfigService
1606func (_mock *MockConfigService) Watch(ctx context.Context, onChange func()) error {
1607 ret := _mock.Called(ctx, onChange)
1608
1609 if len(ret) == 0 {
1610 panic("no return value specified for Watch")
1611 }
1612
1613 var r0 error
1614 if returnFunc, ok := ret.Get(0).(func(context.Context, func()) error); ok {
1615 r0 = returnFunc(ctx, onChange)
1616 } else {
1617 r0 = ret.Error(0)
1618 }
1619 return r0
1620}
1621
1622// MockConfigService_Watch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Watch'
1623type MockConfigService_Watch_Call struct {
1624 *mock.Call
1625}
1626
1627// Watch is a helper method to define mock.On call
1628// - ctx context.Context
1629// - onChange func()
1630func (_e *MockConfigService_Expecter) Watch(ctx interface{}, onChange interface{}) *MockConfigService_Watch_Call {
1631 return &MockConfigService_Watch_Call{Call: _e.mock.On("Watch", ctx, onChange)}
1632}
1633
1634func (_c *MockConfigService_Watch_Call) Run(run func(ctx context.Context, onChange func())) *MockConfigService_Watch_Call {
1635 _c.Call.Run(func(args mock.Arguments) {
1636 var arg0 context.Context
1637 if args[0] != nil {
1638 arg0 = args[0].(context.Context)
1639 }
1640 var arg1 func()
1641 if args[1] != nil {
1642 arg1 = args[1].(func())
1643 }
1644 run(
1645 arg0,
1646 arg1,
1647 )
1648 })
1649 return _c
1650}
1651
1652func (_c *MockConfigService_Watch_Call) Return(err error) *MockConfigService_Watch_Call {
1653 _c.Call.Return(err)
1654 return _c
1655}
1656
1657func (_c *MockConfigService_Watch_Call) RunAndReturn(run func(ctx context.Context, onChange func()) error) *MockConfigService_Watch_Call {
1658 _c.Call.Return(run)
1659 return _c
1660}