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