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/boundaries/in"
11 "github.com/bnema/gordon/internal/domain"
12 mock "github.com/stretchr/testify/mock"
13)
14
15// NewMockProxyService creates a new instance of MockProxyService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
16// The first argument is typically a *testing.T value.
17func NewMockProxyService(t interface {
18 mock.TestingT
19 Cleanup(func())
20}) *MockProxyService {
21 mock := &MockProxyService{}
22 mock.Mock.Test(t)
23
24 t.Cleanup(func() { mock.AssertExpectations(t) })
25
26 return mock
27}
28
29// MockProxyService is an autogenerated mock type for the ProxyService type
30type MockProxyService struct {
31 mock.Mock
32}
33
34type MockProxyService_Expecter struct {
35 mock *mock.Mock
36}
37
38func (_m *MockProxyService) EXPECT() *MockProxyService_Expecter {
39 return &MockProxyService_Expecter{mock: &_m.Mock}
40}
41
42// GetTarget provides a mock function for the type MockProxyService
43func (_mock *MockProxyService) GetTarget(ctx context.Context, domain1 string) (*domain.ProxyTarget, error) {
44 ret := _mock.Called(ctx, domain1)
45
46 if len(ret) == 0 {
47 panic("no return value specified for GetTarget")
48 }
49
50 var r0 *domain.ProxyTarget
51 var r1 error
52 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*domain.ProxyTarget, error)); ok {
53 return returnFunc(ctx, domain1)
54 }
55 if returnFunc, ok := ret.Get(0).(func(context.Context, string) *domain.ProxyTarget); ok {
56 r0 = returnFunc(ctx, domain1)
57 } else {
58 if ret.Get(0) != nil {
59 r0 = ret.Get(0).(*domain.ProxyTarget)
60 }
61 }
62 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
63 r1 = returnFunc(ctx, domain1)
64 } else {
65 r1 = ret.Error(1)
66 }
67 return r0, r1
68}
69
70// MockProxyService_GetTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTarget'
71type MockProxyService_GetTarget_Call struct {
72 *mock.Call
73}
74
75// GetTarget is a helper method to define mock.On call
76// - ctx context.Context
77// - domain1 string
78func (_e *MockProxyService_Expecter) GetTarget(ctx interface{}, domain1 interface{}) *MockProxyService_GetTarget_Call {
79 return &MockProxyService_GetTarget_Call{Call: _e.mock.On("GetTarget", ctx, domain1)}
80}
81
82func (_c *MockProxyService_GetTarget_Call) Run(run func(ctx context.Context, domain1 string)) *MockProxyService_GetTarget_Call {
83 _c.Call.Run(func(args mock.Arguments) {
84 var arg0 context.Context
85 if args[0] != nil {
86 arg0 = args[0].(context.Context)
87 }
88 var arg1 string
89 if args[1] != nil {
90 arg1 = args[1].(string)
91 }
92 run(
93 arg0,
94 arg1,
95 )
96 })
97 return _c
98}
99
100func (_c *MockProxyService_GetTarget_Call) Return(proxyTarget *domain.ProxyTarget, err error) *MockProxyService_GetTarget_Call {
101 _c.Call.Return(proxyTarget, err)
102 return _c
103}
104
105func (_c *MockProxyService_GetTarget_Call) RunAndReturn(run func(ctx context.Context, domain1 string) (*domain.ProxyTarget, error)) *MockProxyService_GetTarget_Call {
106 _c.Call.Return(run)
107 return _c
108}
109
110// IsKnownHost provides a mock function for the type MockProxyService
111func (_mock *MockProxyService) IsKnownHost(ctx context.Context, host string) bool {
112 ret := _mock.Called(ctx, host)
113
114 if len(ret) == 0 {
115 panic("no return value specified for IsKnownHost")
116 }
117
118 var r0 bool
119 if returnFunc, ok := ret.Get(0).(func(context.Context, string) bool); ok {
120 r0 = returnFunc(ctx, host)
121 } else {
122 r0 = ret.Get(0).(bool)
123 }
124 return r0
125}
126
127// MockProxyService_IsKnownHost_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsKnownHost'
128type MockProxyService_IsKnownHost_Call struct {
129 *mock.Call
130}
131
132// IsKnownHost is a helper method to define mock.On call
133// - ctx context.Context
134// - host string
135func (_e *MockProxyService_Expecter) IsKnownHost(ctx interface{}, host interface{}) *MockProxyService_IsKnownHost_Call {
136 return &MockProxyService_IsKnownHost_Call{Call: _e.mock.On("IsKnownHost", ctx, host)}
137}
138
139func (_c *MockProxyService_IsKnownHost_Call) Run(run func(ctx context.Context, host string)) *MockProxyService_IsKnownHost_Call {
140 _c.Call.Run(func(args mock.Arguments) {
141 var arg0 context.Context
142 if args[0] != nil {
143 arg0 = args[0].(context.Context)
144 }
145 var arg1 string
146 if args[1] != nil {
147 arg1 = args[1].(string)
148 }
149 run(
150 arg0,
151 arg1,
152 )
153 })
154 return _c
155}
156
157func (_c *MockProxyService_IsKnownHost_Call) Return(b bool) *MockProxyService_IsKnownHost_Call {
158 _c.Call.Return(b)
159 return _c
160}
161
162func (_c *MockProxyService_IsKnownHost_Call) RunAndReturn(run func(ctx context.Context, host string) bool) *MockProxyService_IsKnownHost_Call {
163 _c.Call.Return(run)
164 return _c
165}
166
167// IsRegistryDomain provides a mock function for the type MockProxyService
168func (_mock *MockProxyService) IsRegistryDomain(host string) bool {
169 ret := _mock.Called(host)
170
171 if len(ret) == 0 {
172 panic("no return value specified for IsRegistryDomain")
173 }
174
175 var r0 bool
176 if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
177 r0 = returnFunc(host)
178 } else {
179 r0 = ret.Get(0).(bool)
180 }
181 return r0
182}
183
184// MockProxyService_IsRegistryDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsRegistryDomain'
185type MockProxyService_IsRegistryDomain_Call struct {
186 *mock.Call
187}
188
189// IsRegistryDomain is a helper method to define mock.On call
190// - host string
191func (_e *MockProxyService_Expecter) IsRegistryDomain(host interface{}) *MockProxyService_IsRegistryDomain_Call {
192 return &MockProxyService_IsRegistryDomain_Call{Call: _e.mock.On("IsRegistryDomain", host)}
193}
194
195func (_c *MockProxyService_IsRegistryDomain_Call) Run(run func(host string)) *MockProxyService_IsRegistryDomain_Call {
196 _c.Call.Run(func(args mock.Arguments) {
197 var arg0 string
198 if args[0] != nil {
199 arg0 = args[0].(string)
200 }
201 run(
202 arg0,
203 )
204 })
205 return _c
206}
207
208func (_c *MockProxyService_IsRegistryDomain_Call) Return(b bool) *MockProxyService_IsRegistryDomain_Call {
209 _c.Call.Return(b)
210 return _c
211}
212
213func (_c *MockProxyService_IsRegistryDomain_Call) RunAndReturn(run func(host string) bool) *MockProxyService_IsRegistryDomain_Call {
214 _c.Call.Return(run)
215 return _c
216}
217
218// ProxyConfig provides a mock function for the type MockProxyService
219func (_mock *MockProxyService) ProxyConfig() in.ProxyServiceConfig {
220 ret := _mock.Called()
221
222 if len(ret) == 0 {
223 panic("no return value specified for ProxyConfig")
224 }
225
226 var r0 in.ProxyServiceConfig
227 if returnFunc, ok := ret.Get(0).(func() in.ProxyServiceConfig); ok {
228 r0 = returnFunc()
229 } else {
230 r0 = ret.Get(0).(in.ProxyServiceConfig)
231 }
232 return r0
233}
234
235// MockProxyService_ProxyConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProxyConfig'
236type MockProxyService_ProxyConfig_Call struct {
237 *mock.Call
238}
239
240// ProxyConfig is a helper method to define mock.On call
241func (_e *MockProxyService_Expecter) ProxyConfig() *MockProxyService_ProxyConfig_Call {
242 return &MockProxyService_ProxyConfig_Call{Call: _e.mock.On("ProxyConfig")}
243}
244
245func (_c *MockProxyService_ProxyConfig_Call) Run(run func()) *MockProxyService_ProxyConfig_Call {
246 _c.Call.Run(func(args mock.Arguments) {
247 run()
248 })
249 return _c
250}
251
252func (_c *MockProxyService_ProxyConfig_Call) Return(proxyServiceConfig in.ProxyServiceConfig) *MockProxyService_ProxyConfig_Call {
253 _c.Call.Return(proxyServiceConfig)
254 return _c
255}
256
257func (_c *MockProxyService_ProxyConfig_Call) RunAndReturn(run func() in.ProxyServiceConfig) *MockProxyService_ProxyConfig_Call {
258 _c.Call.Return(run)
259 return _c
260}
261
262// RefreshTargets provides a mock function for the type MockProxyService
263func (_mock *MockProxyService) RefreshTargets(ctx context.Context) error {
264 ret := _mock.Called(ctx)
265
266 if len(ret) == 0 {
267 panic("no return value specified for RefreshTargets")
268 }
269
270 var r0 error
271 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
272 r0 = returnFunc(ctx)
273 } else {
274 r0 = ret.Error(0)
275 }
276 return r0
277}
278
279// MockProxyService_RefreshTargets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RefreshTargets'
280type MockProxyService_RefreshTargets_Call struct {
281 *mock.Call
282}
283
284// RefreshTargets is a helper method to define mock.On call
285// - ctx context.Context
286func (_e *MockProxyService_Expecter) RefreshTargets(ctx interface{}) *MockProxyService_RefreshTargets_Call {
287 return &MockProxyService_RefreshTargets_Call{Call: _e.mock.On("RefreshTargets", ctx)}
288}
289
290func (_c *MockProxyService_RefreshTargets_Call) Run(run func(ctx context.Context)) *MockProxyService_RefreshTargets_Call {
291 _c.Call.Run(func(args mock.Arguments) {
292 var arg0 context.Context
293 if args[0] != nil {
294 arg0 = args[0].(context.Context)
295 }
296 run(
297 arg0,
298 )
299 })
300 return _c
301}
302
303func (_c *MockProxyService_RefreshTargets_Call) Return(err error) *MockProxyService_RefreshTargets_Call {
304 _c.Call.Return(err)
305 return _c
306}
307
308func (_c *MockProxyService_RefreshTargets_Call) RunAndReturn(run func(ctx context.Context) error) *MockProxyService_RefreshTargets_Call {
309 _c.Call.Return(run)
310 return _c
311}
312
313// RegisterTarget provides a mock function for the type MockProxyService
314func (_mock *MockProxyService) RegisterTarget(ctx context.Context, domain1 string, target *domain.ProxyTarget) error {
315 ret := _mock.Called(ctx, domain1, target)
316
317 if len(ret) == 0 {
318 panic("no return value specified for RegisterTarget")
319 }
320
321 var r0 error
322 if returnFunc, ok := ret.Get(0).(func(context.Context, string, *domain.ProxyTarget) error); ok {
323 r0 = returnFunc(ctx, domain1, target)
324 } else {
325 r0 = ret.Error(0)
326 }
327 return r0
328}
329
330// MockProxyService_RegisterTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterTarget'
331type MockProxyService_RegisterTarget_Call struct {
332 *mock.Call
333}
334
335// RegisterTarget is a helper method to define mock.On call
336// - ctx context.Context
337// - domain1 string
338// - target *domain.ProxyTarget
339func (_e *MockProxyService_Expecter) RegisterTarget(ctx interface{}, domain1 interface{}, target interface{}) *MockProxyService_RegisterTarget_Call {
340 return &MockProxyService_RegisterTarget_Call{Call: _e.mock.On("RegisterTarget", ctx, domain1, target)}
341}
342
343func (_c *MockProxyService_RegisterTarget_Call) Run(run func(ctx context.Context, domain1 string, target *domain.ProxyTarget)) *MockProxyService_RegisterTarget_Call {
344 _c.Call.Run(func(args mock.Arguments) {
345 var arg0 context.Context
346 if args[0] != nil {
347 arg0 = args[0].(context.Context)
348 }
349 var arg1 string
350 if args[1] != nil {
351 arg1 = args[1].(string)
352 }
353 var arg2 *domain.ProxyTarget
354 if args[2] != nil {
355 arg2 = args[2].(*domain.ProxyTarget)
356 }
357 run(
358 arg0,
359 arg1,
360 arg2,
361 )
362 })
363 return _c
364}
365
366func (_c *MockProxyService_RegisterTarget_Call) Return(err error) *MockProxyService_RegisterTarget_Call {
367 _c.Call.Return(err)
368 return _c
369}
370
371func (_c *MockProxyService_RegisterTarget_Call) RunAndReturn(run func(ctx context.Context, domain1 string, target *domain.ProxyTarget) error) *MockProxyService_RegisterTarget_Call {
372 _c.Call.Return(run)
373 return _c
374}
375
376// ReleaseRegistryRequest provides a mock function for the type MockProxyService
377func (_mock *MockProxyService) ReleaseRegistryRequest() {
378 _mock.Called()
379 return
380}
381
382// MockProxyService_ReleaseRegistryRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReleaseRegistryRequest'
383type MockProxyService_ReleaseRegistryRequest_Call struct {
384 *mock.Call
385}
386
387// ReleaseRegistryRequest is a helper method to define mock.On call
388func (_e *MockProxyService_Expecter) ReleaseRegistryRequest() *MockProxyService_ReleaseRegistryRequest_Call {
389 return &MockProxyService_ReleaseRegistryRequest_Call{Call: _e.mock.On("ReleaseRegistryRequest")}
390}
391
392func (_c *MockProxyService_ReleaseRegistryRequest_Call) Run(run func()) *MockProxyService_ReleaseRegistryRequest_Call {
393 _c.Call.Run(func(args mock.Arguments) {
394 run()
395 })
396 return _c
397}
398
399func (_c *MockProxyService_ReleaseRegistryRequest_Call) Return() *MockProxyService_ReleaseRegistryRequest_Call {
400 _c.Call.Return()
401 return _c
402}
403
404func (_c *MockProxyService_ReleaseRegistryRequest_Call) RunAndReturn(run func()) *MockProxyService_ReleaseRegistryRequest_Call {
405 _c.Run(run)
406 return _c
407}
408
409// TrackInFlight provides a mock function for the type MockProxyService
410func (_mock *MockProxyService) TrackInFlight(containerID string) func() {
411 ret := _mock.Called(containerID)
412
413 if len(ret) == 0 {
414 panic("no return value specified for TrackInFlight")
415 }
416
417 var r0 func()
418 if returnFunc, ok := ret.Get(0).(func(string) func()); ok {
419 r0 = returnFunc(containerID)
420 } else {
421 if ret.Get(0) != nil {
422 r0 = ret.Get(0).(func())
423 }
424 }
425 return r0
426}
427
428// MockProxyService_TrackInFlight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TrackInFlight'
429type MockProxyService_TrackInFlight_Call struct {
430 *mock.Call
431}
432
433// TrackInFlight is a helper method to define mock.On call
434// - containerID string
435func (_e *MockProxyService_Expecter) TrackInFlight(containerID interface{}) *MockProxyService_TrackInFlight_Call {
436 return &MockProxyService_TrackInFlight_Call{Call: _e.mock.On("TrackInFlight", containerID)}
437}
438
439func (_c *MockProxyService_TrackInFlight_Call) Run(run func(containerID string)) *MockProxyService_TrackInFlight_Call {
440 _c.Call.Run(func(args mock.Arguments) {
441 var arg0 string
442 if args[0] != nil {
443 arg0 = args[0].(string)
444 }
445 run(
446 arg0,
447 )
448 })
449 return _c
450}
451
452func (_c *MockProxyService_TrackInFlight_Call) Return(fn func()) *MockProxyService_TrackInFlight_Call {
453 _c.Call.Return(fn)
454 return _c
455}
456
457func (_c *MockProxyService_TrackInFlight_Call) RunAndReturn(run func(containerID string) func()) *MockProxyService_TrackInFlight_Call {
458 _c.Call.Return(run)
459 return _c
460}
461
462// TrackRegistryRequest provides a mock function for the type MockProxyService
463func (_mock *MockProxyService) TrackRegistryRequest() {
464 _mock.Called()
465 return
466}
467
468// MockProxyService_TrackRegistryRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TrackRegistryRequest'
469type MockProxyService_TrackRegistryRequest_Call struct {
470 *mock.Call
471}
472
473// TrackRegistryRequest is a helper method to define mock.On call
474func (_e *MockProxyService_Expecter) TrackRegistryRequest() *MockProxyService_TrackRegistryRequest_Call {
475 return &MockProxyService_TrackRegistryRequest_Call{Call: _e.mock.On("TrackRegistryRequest")}
476}
477
478func (_c *MockProxyService_TrackRegistryRequest_Call) Run(run func()) *MockProxyService_TrackRegistryRequest_Call {
479 _c.Call.Run(func(args mock.Arguments) {
480 run()
481 })
482 return _c
483}
484
485func (_c *MockProxyService_TrackRegistryRequest_Call) Return() *MockProxyService_TrackRegistryRequest_Call {
486 _c.Call.Return()
487 return _c
488}
489
490func (_c *MockProxyService_TrackRegistryRequest_Call) RunAndReturn(run func()) *MockProxyService_TrackRegistryRequest_Call {
491 _c.Run(run)
492 return _c
493}
494
495// UnregisterTarget provides a mock function for the type MockProxyService
496func (_mock *MockProxyService) UnregisterTarget(ctx context.Context, domain1 string) error {
497 ret := _mock.Called(ctx, domain1)
498
499 if len(ret) == 0 {
500 panic("no return value specified for UnregisterTarget")
501 }
502
503 var r0 error
504 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
505 r0 = returnFunc(ctx, domain1)
506 } else {
507 r0 = ret.Error(0)
508 }
509 return r0
510}
511
512// MockProxyService_UnregisterTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnregisterTarget'
513type MockProxyService_UnregisterTarget_Call struct {
514 *mock.Call
515}
516
517// UnregisterTarget is a helper method to define mock.On call
518// - ctx context.Context
519// - domain1 string
520func (_e *MockProxyService_Expecter) UnregisterTarget(ctx interface{}, domain1 interface{}) *MockProxyService_UnregisterTarget_Call {
521 return &MockProxyService_UnregisterTarget_Call{Call: _e.mock.On("UnregisterTarget", ctx, domain1)}
522}
523
524func (_c *MockProxyService_UnregisterTarget_Call) Run(run func(ctx context.Context, domain1 string)) *MockProxyService_UnregisterTarget_Call {
525 _c.Call.Run(func(args mock.Arguments) {
526 var arg0 context.Context
527 if args[0] != nil {
528 arg0 = args[0].(context.Context)
529 }
530 var arg1 string
531 if args[1] != nil {
532 arg1 = args[1].(string)
533 }
534 run(
535 arg0,
536 arg1,
537 )
538 })
539 return _c
540}
541
542func (_c *MockProxyService_UnregisterTarget_Call) Return(err error) *MockProxyService_UnregisterTarget_Call {
543 _c.Call.Return(err)
544 return _c
545}
546
547func (_c *MockProxyService_UnregisterTarget_Call) RunAndReturn(run func(ctx context.Context, domain1 string) error) *MockProxyService_UnregisterTarget_Call {
548 _c.Call.Return(run)
549 return _c
550}