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// IsRegistryDomain provides a mock function for the type MockProxyService
111func (_mock *MockProxyService) IsRegistryDomain(host string) bool {
112 ret := _mock.Called(host)
113
114 if len(ret) == 0 {
115 panic("no return value specified for IsRegistryDomain")
116 }
117
118 var r0 bool
119 if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
120 r0 = returnFunc(host)
121 } else {
122 r0 = ret.Get(0).(bool)
123 }
124 return r0
125}
126
127// MockProxyService_IsRegistryDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsRegistryDomain'
128type MockProxyService_IsRegistryDomain_Call struct {
129 *mock.Call
130}
131
132// IsRegistryDomain is a helper method to define mock.On call
133// - host string
134func (_e *MockProxyService_Expecter) IsRegistryDomain(host interface{}) *MockProxyService_IsRegistryDomain_Call {
135 return &MockProxyService_IsRegistryDomain_Call{Call: _e.mock.On("IsRegistryDomain", host)}
136}
137
138func (_c *MockProxyService_IsRegistryDomain_Call) Run(run func(host string)) *MockProxyService_IsRegistryDomain_Call {
139 _c.Call.Run(func(args mock.Arguments) {
140 var arg0 string
141 if args[0] != nil {
142 arg0 = args[0].(string)
143 }
144 run(
145 arg0,
146 )
147 })
148 return _c
149}
150
151func (_c *MockProxyService_IsRegistryDomain_Call) Return(b bool) *MockProxyService_IsRegistryDomain_Call {
152 _c.Call.Return(b)
153 return _c
154}
155
156func (_c *MockProxyService_IsRegistryDomain_Call) RunAndReturn(run func(host string) bool) *MockProxyService_IsRegistryDomain_Call {
157 _c.Call.Return(run)
158 return _c
159}
160
161// ProxyConfig provides a mock function for the type MockProxyService
162func (_mock *MockProxyService) ProxyConfig() in.ProxyServiceConfig {
163 ret := _mock.Called()
164
165 if len(ret) == 0 {
166 panic("no return value specified for ProxyConfig")
167 }
168
169 var r0 in.ProxyServiceConfig
170 if returnFunc, ok := ret.Get(0).(func() in.ProxyServiceConfig); ok {
171 r0 = returnFunc()
172 } else {
173 r0 = ret.Get(0).(in.ProxyServiceConfig)
174 }
175 return r0
176}
177
178// MockProxyService_ProxyConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProxyConfig'
179type MockProxyService_ProxyConfig_Call struct {
180 *mock.Call
181}
182
183// ProxyConfig is a helper method to define mock.On call
184func (_e *MockProxyService_Expecter) ProxyConfig() *MockProxyService_ProxyConfig_Call {
185 return &MockProxyService_ProxyConfig_Call{Call: _e.mock.On("ProxyConfig")}
186}
187
188func (_c *MockProxyService_ProxyConfig_Call) Run(run func()) *MockProxyService_ProxyConfig_Call {
189 _c.Call.Run(func(args mock.Arguments) {
190 run()
191 })
192 return _c
193}
194
195func (_c *MockProxyService_ProxyConfig_Call) Return(proxyServiceConfig in.ProxyServiceConfig) *MockProxyService_ProxyConfig_Call {
196 _c.Call.Return(proxyServiceConfig)
197 return _c
198}
199
200func (_c *MockProxyService_ProxyConfig_Call) RunAndReturn(run func() in.ProxyServiceConfig) *MockProxyService_ProxyConfig_Call {
201 _c.Call.Return(run)
202 return _c
203}
204
205// RefreshTargets provides a mock function for the type MockProxyService
206func (_mock *MockProxyService) RefreshTargets(ctx context.Context) error {
207 ret := _mock.Called(ctx)
208
209 if len(ret) == 0 {
210 panic("no return value specified for RefreshTargets")
211 }
212
213 var r0 error
214 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
215 r0 = returnFunc(ctx)
216 } else {
217 r0 = ret.Error(0)
218 }
219 return r0
220}
221
222// MockProxyService_RefreshTargets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RefreshTargets'
223type MockProxyService_RefreshTargets_Call struct {
224 *mock.Call
225}
226
227// RefreshTargets is a helper method to define mock.On call
228// - ctx context.Context
229func (_e *MockProxyService_Expecter) RefreshTargets(ctx interface{}) *MockProxyService_RefreshTargets_Call {
230 return &MockProxyService_RefreshTargets_Call{Call: _e.mock.On("RefreshTargets", ctx)}
231}
232
233func (_c *MockProxyService_RefreshTargets_Call) Run(run func(ctx context.Context)) *MockProxyService_RefreshTargets_Call {
234 _c.Call.Run(func(args mock.Arguments) {
235 var arg0 context.Context
236 if args[0] != nil {
237 arg0 = args[0].(context.Context)
238 }
239 run(
240 arg0,
241 )
242 })
243 return _c
244}
245
246func (_c *MockProxyService_RefreshTargets_Call) Return(err error) *MockProxyService_RefreshTargets_Call {
247 _c.Call.Return(err)
248 return _c
249}
250
251func (_c *MockProxyService_RefreshTargets_Call) RunAndReturn(run func(ctx context.Context) error) *MockProxyService_RefreshTargets_Call {
252 _c.Call.Return(run)
253 return _c
254}
255
256// RegisterTarget provides a mock function for the type MockProxyService
257func (_mock *MockProxyService) RegisterTarget(ctx context.Context, domain1 string, target *domain.ProxyTarget) error {
258 ret := _mock.Called(ctx, domain1, target)
259
260 if len(ret) == 0 {
261 panic("no return value specified for RegisterTarget")
262 }
263
264 var r0 error
265 if returnFunc, ok := ret.Get(0).(func(context.Context, string, *domain.ProxyTarget) error); ok {
266 r0 = returnFunc(ctx, domain1, target)
267 } else {
268 r0 = ret.Error(0)
269 }
270 return r0
271}
272
273// MockProxyService_RegisterTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterTarget'
274type MockProxyService_RegisterTarget_Call struct {
275 *mock.Call
276}
277
278// RegisterTarget is a helper method to define mock.On call
279// - ctx context.Context
280// - domain1 string
281// - target *domain.ProxyTarget
282func (_e *MockProxyService_Expecter) RegisterTarget(ctx interface{}, domain1 interface{}, target interface{}) *MockProxyService_RegisterTarget_Call {
283 return &MockProxyService_RegisterTarget_Call{Call: _e.mock.On("RegisterTarget", ctx, domain1, target)}
284}
285
286func (_c *MockProxyService_RegisterTarget_Call) Run(run func(ctx context.Context, domain1 string, target *domain.ProxyTarget)) *MockProxyService_RegisterTarget_Call {
287 _c.Call.Run(func(args mock.Arguments) {
288 var arg0 context.Context
289 if args[0] != nil {
290 arg0 = args[0].(context.Context)
291 }
292 var arg1 string
293 if args[1] != nil {
294 arg1 = args[1].(string)
295 }
296 var arg2 *domain.ProxyTarget
297 if args[2] != nil {
298 arg2 = args[2].(*domain.ProxyTarget)
299 }
300 run(
301 arg0,
302 arg1,
303 arg2,
304 )
305 })
306 return _c
307}
308
309func (_c *MockProxyService_RegisterTarget_Call) Return(err error) *MockProxyService_RegisterTarget_Call {
310 _c.Call.Return(err)
311 return _c
312}
313
314func (_c *MockProxyService_RegisterTarget_Call) RunAndReturn(run func(ctx context.Context, domain1 string, target *domain.ProxyTarget) error) *MockProxyService_RegisterTarget_Call {
315 _c.Call.Return(run)
316 return _c
317}
318
319// ReleaseRegistryRequest provides a mock function for the type MockProxyService
320func (_mock *MockProxyService) ReleaseRegistryRequest() {
321 _mock.Called()
322 return
323}
324
325// MockProxyService_ReleaseRegistryRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReleaseRegistryRequest'
326type MockProxyService_ReleaseRegistryRequest_Call struct {
327 *mock.Call
328}
329
330// ReleaseRegistryRequest is a helper method to define mock.On call
331func (_e *MockProxyService_Expecter) ReleaseRegistryRequest() *MockProxyService_ReleaseRegistryRequest_Call {
332 return &MockProxyService_ReleaseRegistryRequest_Call{Call: _e.mock.On("ReleaseRegistryRequest")}
333}
334
335func (_c *MockProxyService_ReleaseRegistryRequest_Call) Run(run func()) *MockProxyService_ReleaseRegistryRequest_Call {
336 _c.Call.Run(func(args mock.Arguments) {
337 run()
338 })
339 return _c
340}
341
342func (_c *MockProxyService_ReleaseRegistryRequest_Call) Return() *MockProxyService_ReleaseRegistryRequest_Call {
343 _c.Call.Return()
344 return _c
345}
346
347func (_c *MockProxyService_ReleaseRegistryRequest_Call) RunAndReturn(run func()) *MockProxyService_ReleaseRegistryRequest_Call {
348 _c.Run(run)
349 return _c
350}
351
352// TrackInFlight provides a mock function for the type MockProxyService
353func (_mock *MockProxyService) TrackInFlight(containerID string) func() {
354 ret := _mock.Called(containerID)
355
356 if len(ret) == 0 {
357 panic("no return value specified for TrackInFlight")
358 }
359
360 var r0 func()
361 if returnFunc, ok := ret.Get(0).(func(string) func()); ok {
362 r0 = returnFunc(containerID)
363 } else {
364 if ret.Get(0) != nil {
365 r0 = ret.Get(0).(func())
366 }
367 }
368 return r0
369}
370
371// MockProxyService_TrackInFlight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TrackInFlight'
372type MockProxyService_TrackInFlight_Call struct {
373 *mock.Call
374}
375
376// TrackInFlight is a helper method to define mock.On call
377// - containerID string
378func (_e *MockProxyService_Expecter) TrackInFlight(containerID interface{}) *MockProxyService_TrackInFlight_Call {
379 return &MockProxyService_TrackInFlight_Call{Call: _e.mock.On("TrackInFlight", containerID)}
380}
381
382func (_c *MockProxyService_TrackInFlight_Call) Run(run func(containerID string)) *MockProxyService_TrackInFlight_Call {
383 _c.Call.Run(func(args mock.Arguments) {
384 var arg0 string
385 if args[0] != nil {
386 arg0 = args[0].(string)
387 }
388 run(
389 arg0,
390 )
391 })
392 return _c
393}
394
395func (_c *MockProxyService_TrackInFlight_Call) Return(fn func()) *MockProxyService_TrackInFlight_Call {
396 _c.Call.Return(fn)
397 return _c
398}
399
400func (_c *MockProxyService_TrackInFlight_Call) RunAndReturn(run func(containerID string) func()) *MockProxyService_TrackInFlight_Call {
401 _c.Call.Return(run)
402 return _c
403}
404
405// TrackRegistryRequest provides a mock function for the type MockProxyService
406func (_mock *MockProxyService) TrackRegistryRequest() {
407 _mock.Called()
408 return
409}
410
411// MockProxyService_TrackRegistryRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TrackRegistryRequest'
412type MockProxyService_TrackRegistryRequest_Call struct {
413 *mock.Call
414}
415
416// TrackRegistryRequest is a helper method to define mock.On call
417func (_e *MockProxyService_Expecter) TrackRegistryRequest() *MockProxyService_TrackRegistryRequest_Call {
418 return &MockProxyService_TrackRegistryRequest_Call{Call: _e.mock.On("TrackRegistryRequest")}
419}
420
421func (_c *MockProxyService_TrackRegistryRequest_Call) Run(run func()) *MockProxyService_TrackRegistryRequest_Call {
422 _c.Call.Run(func(args mock.Arguments) {
423 run()
424 })
425 return _c
426}
427
428func (_c *MockProxyService_TrackRegistryRequest_Call) Return() *MockProxyService_TrackRegistryRequest_Call {
429 _c.Call.Return()
430 return _c
431}
432
433func (_c *MockProxyService_TrackRegistryRequest_Call) RunAndReturn(run func()) *MockProxyService_TrackRegistryRequest_Call {
434 _c.Run(run)
435 return _c
436}
437
438// UnregisterTarget provides a mock function for the type MockProxyService
439func (_mock *MockProxyService) UnregisterTarget(ctx context.Context, domain1 string) error {
440 ret := _mock.Called(ctx, domain1)
441
442 if len(ret) == 0 {
443 panic("no return value specified for UnregisterTarget")
444 }
445
446 var r0 error
447 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
448 r0 = returnFunc(ctx, domain1)
449 } else {
450 r0 = ret.Error(0)
451 }
452 return r0
453}
454
455// MockProxyService_UnregisterTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnregisterTarget'
456type MockProxyService_UnregisterTarget_Call struct {
457 *mock.Call
458}
459
460// UnregisterTarget is a helper method to define mock.On call
461// - ctx context.Context
462// - domain1 string
463func (_e *MockProxyService_Expecter) UnregisterTarget(ctx interface{}, domain1 interface{}) *MockProxyService_UnregisterTarget_Call {
464 return &MockProxyService_UnregisterTarget_Call{Call: _e.mock.On("UnregisterTarget", ctx, domain1)}
465}
466
467func (_c *MockProxyService_UnregisterTarget_Call) Run(run func(ctx context.Context, domain1 string)) *MockProxyService_UnregisterTarget_Call {
468 _c.Call.Run(func(args mock.Arguments) {
469 var arg0 context.Context
470 if args[0] != nil {
471 arg0 = args[0].(context.Context)
472 }
473 var arg1 string
474 if args[1] != nil {
475 arg1 = args[1].(string)
476 }
477 run(
478 arg0,
479 arg1,
480 )
481 })
482 return _c
483}
484
485func (_c *MockProxyService_UnregisterTarget_Call) Return(err error) *MockProxyService_UnregisterTarget_Call {
486 _c.Call.Return(err)
487 return _c
488}
489
490func (_c *MockProxyService_UnregisterTarget_Call) RunAndReturn(run func(ctx context.Context, domain1 string) error) *MockProxyService_UnregisterTarget_Call {
491 _c.Call.Return(run)
492 return _c
493}