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/adapters/dto"
11 "github.com/bnema/gordon/internal/adapters/in/cli/remote"
12 "github.com/bnema/gordon/internal/domain"
13 mock "github.com/stretchr/testify/mock"
14)
15
16// NewMockControlPlane creates a new instance of MockControlPlane. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
17// The first argument is typically a *testing.T value.
18func NewMockControlPlane(t interface {
19 mock.TestingT
20 Cleanup(func())
21}) *MockControlPlane {
22 mock := &MockControlPlane{}
23 mock.Mock.Test(t)
24
25 t.Cleanup(func() { mock.AssertExpectations(t) })
26
27 return mock
28}
29
30// MockControlPlane is an autogenerated mock type for the ControlPlane type
31type MockControlPlane struct {
32 mock.Mock
33}
34
35type MockControlPlane_Expecter struct {
36 mock *mock.Mock
37}
38
39func (_m *MockControlPlane) EXPECT() *MockControlPlane_Expecter {
40 return &MockControlPlane_Expecter{mock: &_m.Mock}
41}
42
43// AddAttachment provides a mock function for the type MockControlPlane
44func (_mock *MockControlPlane) AddAttachment(ctx context.Context, domainOrGroup string, image string) error {
45 ret := _mock.Called(ctx, domainOrGroup, image)
46
47 if len(ret) == 0 {
48 panic("no return value specified for AddAttachment")
49 }
50
51 var r0 error
52 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
53 r0 = returnFunc(ctx, domainOrGroup, image)
54 } else {
55 r0 = ret.Error(0)
56 }
57 return r0
58}
59
60// MockControlPlane_AddAttachment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddAttachment'
61type MockControlPlane_AddAttachment_Call struct {
62 *mock.Call
63}
64
65// AddAttachment is a helper method to define mock.On call
66// - ctx context.Context
67// - domainOrGroup string
68// - image string
69func (_e *MockControlPlane_Expecter) AddAttachment(ctx any, domainOrGroup any, image any) *MockControlPlane_AddAttachment_Call {
70 return &MockControlPlane_AddAttachment_Call{Call: _e.mock.On("AddAttachment", ctx, domainOrGroup, image)}
71}
72
73func (_c *MockControlPlane_AddAttachment_Call) Run(run func(ctx context.Context, domainOrGroup string, image string)) *MockControlPlane_AddAttachment_Call {
74 _c.Call.Run(func(args mock.Arguments) {
75 var arg0 context.Context
76 if args[0] != nil {
77 arg0 = args[0].(context.Context)
78 }
79 var arg1 string
80 if args[1] != nil {
81 arg1 = args[1].(string)
82 }
83 var arg2 string
84 if args[2] != nil {
85 arg2 = args[2].(string)
86 }
87 run(
88 arg0,
89 arg1,
90 arg2,
91 )
92 })
93 return _c
94}
95
96func (_c *MockControlPlane_AddAttachment_Call) Return(err error) *MockControlPlane_AddAttachment_Call {
97 _c.Call.Return(err)
98 return _c
99}
100
101func (_c *MockControlPlane_AddAttachment_Call) RunAndReturn(run func(ctx context.Context, domainOrGroup string, image string) error) *MockControlPlane_AddAttachment_Call {
102 _c.Call.Return(run)
103 return _c
104}
105
106// AddAutoRouteAllowedDomain provides a mock function for the type MockControlPlane
107func (_mock *MockControlPlane) AddAutoRouteAllowedDomain(ctx context.Context, pattern string) error {
108 ret := _mock.Called(ctx, pattern)
109
110 if len(ret) == 0 {
111 panic("no return value specified for AddAutoRouteAllowedDomain")
112 }
113
114 var r0 error
115 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
116 r0 = returnFunc(ctx, pattern)
117 } else {
118 r0 = ret.Error(0)
119 }
120 return r0
121}
122
123// MockControlPlane_AddAutoRouteAllowedDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddAutoRouteAllowedDomain'
124type MockControlPlane_AddAutoRouteAllowedDomain_Call struct {
125 *mock.Call
126}
127
128// AddAutoRouteAllowedDomain is a helper method to define mock.On call
129// - ctx context.Context
130// - pattern string
131func (_e *MockControlPlane_Expecter) AddAutoRouteAllowedDomain(ctx any, pattern any) *MockControlPlane_AddAutoRouteAllowedDomain_Call {
132 return &MockControlPlane_AddAutoRouteAllowedDomain_Call{Call: _e.mock.On("AddAutoRouteAllowedDomain", ctx, pattern)}
133}
134
135func (_c *MockControlPlane_AddAutoRouteAllowedDomain_Call) Run(run func(ctx context.Context, pattern string)) *MockControlPlane_AddAutoRouteAllowedDomain_Call {
136 _c.Call.Run(func(args mock.Arguments) {
137 var arg0 context.Context
138 if args[0] != nil {
139 arg0 = args[0].(context.Context)
140 }
141 var arg1 string
142 if args[1] != nil {
143 arg1 = args[1].(string)
144 }
145 run(
146 arg0,
147 arg1,
148 )
149 })
150 return _c
151}
152
153func (_c *MockControlPlane_AddAutoRouteAllowedDomain_Call) Return(err error) *MockControlPlane_AddAutoRouteAllowedDomain_Call {
154 _c.Call.Return(err)
155 return _c
156}
157
158func (_c *MockControlPlane_AddAutoRouteAllowedDomain_Call) RunAndReturn(run func(ctx context.Context, pattern string) error) *MockControlPlane_AddAutoRouteAllowedDomain_Call {
159 _c.Call.Return(run)
160 return _c
161}
162
163// AddRoute provides a mock function for the type MockControlPlane
164func (_mock *MockControlPlane) AddRoute(ctx context.Context, route domain.Route) error {
165 ret := _mock.Called(ctx, route)
166
167 if len(ret) == 0 {
168 panic("no return value specified for AddRoute")
169 }
170
171 var r0 error
172 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Route) error); ok {
173 r0 = returnFunc(ctx, route)
174 } else {
175 r0 = ret.Error(0)
176 }
177 return r0
178}
179
180// MockControlPlane_AddRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddRoute'
181type MockControlPlane_AddRoute_Call struct {
182 *mock.Call
183}
184
185// AddRoute is a helper method to define mock.On call
186// - ctx context.Context
187// - route domain.Route
188func (_e *MockControlPlane_Expecter) AddRoute(ctx any, route any) *MockControlPlane_AddRoute_Call {
189 return &MockControlPlane_AddRoute_Call{Call: _e.mock.On("AddRoute", ctx, route)}
190}
191
192func (_c *MockControlPlane_AddRoute_Call) Run(run func(ctx context.Context, route domain.Route)) *MockControlPlane_AddRoute_Call {
193 _c.Call.Run(func(args mock.Arguments) {
194 var arg0 context.Context
195 if args[0] != nil {
196 arg0 = args[0].(context.Context)
197 }
198 var arg1 domain.Route
199 if args[1] != nil {
200 arg1 = args[1].(domain.Route)
201 }
202 run(
203 arg0,
204 arg1,
205 )
206 })
207 return _c
208}
209
210func (_c *MockControlPlane_AddRoute_Call) Return(err error) *MockControlPlane_AddRoute_Call {
211 _c.Call.Return(err)
212 return _c
213}
214
215func (_c *MockControlPlane_AddRoute_Call) RunAndReturn(run func(ctx context.Context, route domain.Route) error) *MockControlPlane_AddRoute_Call {
216 _c.Call.Return(run)
217 return _c
218}
219
220// BackupStatus provides a mock function for the type MockControlPlane
221func (_mock *MockControlPlane) BackupStatus(ctx context.Context) ([]dto.BackupJob, error) {
222 ret := _mock.Called(ctx)
223
224 if len(ret) == 0 {
225 panic("no return value specified for BackupStatus")
226 }
227
228 var r0 []dto.BackupJob
229 var r1 error
230 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]dto.BackupJob, error)); ok {
231 return returnFunc(ctx)
232 }
233 if returnFunc, ok := ret.Get(0).(func(context.Context) []dto.BackupJob); ok {
234 r0 = returnFunc(ctx)
235 } else {
236 if ret.Get(0) != nil {
237 r0 = ret.Get(0).([]dto.BackupJob)
238 }
239 }
240 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
241 r1 = returnFunc(ctx)
242 } else {
243 r1 = ret.Error(1)
244 }
245 return r0, r1
246}
247
248// MockControlPlane_BackupStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BackupStatus'
249type MockControlPlane_BackupStatus_Call struct {
250 *mock.Call
251}
252
253// BackupStatus is a helper method to define mock.On call
254// - ctx context.Context
255func (_e *MockControlPlane_Expecter) BackupStatus(ctx any) *MockControlPlane_BackupStatus_Call {
256 return &MockControlPlane_BackupStatus_Call{Call: _e.mock.On("BackupStatus", ctx)}
257}
258
259func (_c *MockControlPlane_BackupStatus_Call) Run(run func(ctx context.Context)) *MockControlPlane_BackupStatus_Call {
260 _c.Call.Run(func(args mock.Arguments) {
261 var arg0 context.Context
262 if args[0] != nil {
263 arg0 = args[0].(context.Context)
264 }
265 run(
266 arg0,
267 )
268 })
269 return _c
270}
271
272func (_c *MockControlPlane_BackupStatus_Call) Return(backupJobs []dto.BackupJob, err error) *MockControlPlane_BackupStatus_Call {
273 _c.Call.Return(backupJobs, err)
274 return _c
275}
276
277func (_c *MockControlPlane_BackupStatus_Call) RunAndReturn(run func(ctx context.Context) ([]dto.BackupJob, error)) *MockControlPlane_BackupStatus_Call {
278 _c.Call.Return(run)
279 return _c
280}
281
282// Bootstrap provides a mock function for the type MockControlPlane
283func (_mock *MockControlPlane) Bootstrap(ctx context.Context, req dto.BootstrapRequest) (*dto.BootstrapResponse, error) {
284 ret := _mock.Called(ctx, req)
285
286 if len(ret) == 0 {
287 panic("no return value specified for Bootstrap")
288 }
289
290 var r0 *dto.BootstrapResponse
291 var r1 error
292 if returnFunc, ok := ret.Get(0).(func(context.Context, dto.BootstrapRequest) (*dto.BootstrapResponse, error)); ok {
293 return returnFunc(ctx, req)
294 }
295 if returnFunc, ok := ret.Get(0).(func(context.Context, dto.BootstrapRequest) *dto.BootstrapResponse); ok {
296 r0 = returnFunc(ctx, req)
297 } else {
298 if ret.Get(0) != nil {
299 r0 = ret.Get(0).(*dto.BootstrapResponse)
300 }
301 }
302 if returnFunc, ok := ret.Get(1).(func(context.Context, dto.BootstrapRequest) error); ok {
303 r1 = returnFunc(ctx, req)
304 } else {
305 r1 = ret.Error(1)
306 }
307 return r0, r1
308}
309
310// MockControlPlane_Bootstrap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bootstrap'
311type MockControlPlane_Bootstrap_Call struct {
312 *mock.Call
313}
314
315// Bootstrap is a helper method to define mock.On call
316// - ctx context.Context
317// - req dto.BootstrapRequest
318func (_e *MockControlPlane_Expecter) Bootstrap(ctx any, req any) *MockControlPlane_Bootstrap_Call {
319 return &MockControlPlane_Bootstrap_Call{Call: _e.mock.On("Bootstrap", ctx, req)}
320}
321
322func (_c *MockControlPlane_Bootstrap_Call) Run(run func(ctx context.Context, req dto.BootstrapRequest)) *MockControlPlane_Bootstrap_Call {
323 _c.Call.Run(func(args mock.Arguments) {
324 var arg0 context.Context
325 if args[0] != nil {
326 arg0 = args[0].(context.Context)
327 }
328 var arg1 dto.BootstrapRequest
329 if args[1] != nil {
330 arg1 = args[1].(dto.BootstrapRequest)
331 }
332 run(
333 arg0,
334 arg1,
335 )
336 })
337 return _c
338}
339
340func (_c *MockControlPlane_Bootstrap_Call) Return(bootstrapResponse *dto.BootstrapResponse, err error) *MockControlPlane_Bootstrap_Call {
341 _c.Call.Return(bootstrapResponse, err)
342 return _c
343}
344
345func (_c *MockControlPlane_Bootstrap_Call) RunAndReturn(run func(ctx context.Context, req dto.BootstrapRequest) (*dto.BootstrapResponse, error)) *MockControlPlane_Bootstrap_Call {
346 _c.Call.Return(run)
347 return _c
348}
349
350// CleanupOrphanedAttachments provides a mock function for the type MockControlPlane
351func (_mock *MockControlPlane) CleanupOrphanedAttachments(ctx context.Context, owner string, stop bool) (*domain.CleanupReport, error) {
352 ret := _mock.Called(ctx, owner, stop)
353
354 if len(ret) == 0 {
355 panic("no return value specified for CleanupOrphanedAttachments")
356 }
357
358 var r0 *domain.CleanupReport
359 var r1 error
360 if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) (*domain.CleanupReport, error)); ok {
361 return returnFunc(ctx, owner, stop)
362 }
363 if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) *domain.CleanupReport); ok {
364 r0 = returnFunc(ctx, owner, stop)
365 } else {
366 if ret.Get(0) != nil {
367 r0 = ret.Get(0).(*domain.CleanupReport)
368 }
369 }
370 if returnFunc, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
371 r1 = returnFunc(ctx, owner, stop)
372 } else {
373 r1 = ret.Error(1)
374 }
375 return r0, r1
376}
377
378// MockControlPlane_CleanupOrphanedAttachments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CleanupOrphanedAttachments'
379type MockControlPlane_CleanupOrphanedAttachments_Call struct {
380 *mock.Call
381}
382
383// CleanupOrphanedAttachments is a helper method to define mock.On call
384// - ctx context.Context
385// - owner string
386// - stop bool
387func (_e *MockControlPlane_Expecter) CleanupOrphanedAttachments(ctx any, owner any, stop any) *MockControlPlane_CleanupOrphanedAttachments_Call {
388 return &MockControlPlane_CleanupOrphanedAttachments_Call{Call: _e.mock.On("CleanupOrphanedAttachments", ctx, owner, stop)}
389}
390
391func (_c *MockControlPlane_CleanupOrphanedAttachments_Call) Run(run func(ctx context.Context, owner string, stop bool)) *MockControlPlane_CleanupOrphanedAttachments_Call {
392 _c.Call.Run(func(args mock.Arguments) {
393 var arg0 context.Context
394 if args[0] != nil {
395 arg0 = args[0].(context.Context)
396 }
397 var arg1 string
398 if args[1] != nil {
399 arg1 = args[1].(string)
400 }
401 var arg2 bool
402 if args[2] != nil {
403 arg2 = args[2].(bool)
404 }
405 run(
406 arg0,
407 arg1,
408 arg2,
409 )
410 })
411 return _c
412}
413
414func (_c *MockControlPlane_CleanupOrphanedAttachments_Call) Return(cleanupReport *domain.CleanupReport, err error) *MockControlPlane_CleanupOrphanedAttachments_Call {
415 _c.Call.Return(cleanupReport, err)
416 return _c
417}
418
419func (_c *MockControlPlane_CleanupOrphanedAttachments_Call) RunAndReturn(run func(ctx context.Context, owner string, stop bool) (*domain.CleanupReport, error)) *MockControlPlane_CleanupOrphanedAttachments_Call {
420 _c.Call.Return(run)
421 return _c
422}
423
424// DeleteAttachmentSecret provides a mock function for the type MockControlPlane
425func (_mock *MockControlPlane) DeleteAttachmentSecret(ctx context.Context, domain1 string, service string, key string) error {
426 ret := _mock.Called(ctx, domain1, service, key)
427
428 if len(ret) == 0 {
429 panic("no return value specified for DeleteAttachmentSecret")
430 }
431
432 var r0 error
433 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
434 r0 = returnFunc(ctx, domain1, service, key)
435 } else {
436 r0 = ret.Error(0)
437 }
438 return r0
439}
440
441// MockControlPlane_DeleteAttachmentSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAttachmentSecret'
442type MockControlPlane_DeleteAttachmentSecret_Call struct {
443 *mock.Call
444}
445
446// DeleteAttachmentSecret is a helper method to define mock.On call
447// - ctx context.Context
448// - domain1 string
449// - service string
450// - key string
451func (_e *MockControlPlane_Expecter) DeleteAttachmentSecret(ctx any, domain1 any, service any, key any) *MockControlPlane_DeleteAttachmentSecret_Call {
452 return &MockControlPlane_DeleteAttachmentSecret_Call{Call: _e.mock.On("DeleteAttachmentSecret", ctx, domain1, service, key)}
453}
454
455func (_c *MockControlPlane_DeleteAttachmentSecret_Call) Run(run func(ctx context.Context, domain1 string, service string, key string)) *MockControlPlane_DeleteAttachmentSecret_Call {
456 _c.Call.Run(func(args mock.Arguments) {
457 var arg0 context.Context
458 if args[0] != nil {
459 arg0 = args[0].(context.Context)
460 }
461 var arg1 string
462 if args[1] != nil {
463 arg1 = args[1].(string)
464 }
465 var arg2 string
466 if args[2] != nil {
467 arg2 = args[2].(string)
468 }
469 var arg3 string
470 if args[3] != nil {
471 arg3 = args[3].(string)
472 }
473 run(
474 arg0,
475 arg1,
476 arg2,
477 arg3,
478 )
479 })
480 return _c
481}
482
483func (_c *MockControlPlane_DeleteAttachmentSecret_Call) Return(err error) *MockControlPlane_DeleteAttachmentSecret_Call {
484 _c.Call.Return(err)
485 return _c
486}
487
488func (_c *MockControlPlane_DeleteAttachmentSecret_Call) RunAndReturn(run func(ctx context.Context, domain1 string, service string, key string) error) *MockControlPlane_DeleteAttachmentSecret_Call {
489 _c.Call.Return(run)
490 return _c
491}
492
493// DeleteSecret provides a mock function for the type MockControlPlane
494func (_mock *MockControlPlane) DeleteSecret(ctx context.Context, secretDomain string, key string) error {
495 ret := _mock.Called(ctx, secretDomain, key)
496
497 if len(ret) == 0 {
498 panic("no return value specified for DeleteSecret")
499 }
500
501 var r0 error
502 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
503 r0 = returnFunc(ctx, secretDomain, key)
504 } else {
505 r0 = ret.Error(0)
506 }
507 return r0
508}
509
510// MockControlPlane_DeleteSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSecret'
511type MockControlPlane_DeleteSecret_Call struct {
512 *mock.Call
513}
514
515// DeleteSecret is a helper method to define mock.On call
516// - ctx context.Context
517// - secretDomain string
518// - key string
519func (_e *MockControlPlane_Expecter) DeleteSecret(ctx any, secretDomain any, key any) *MockControlPlane_DeleteSecret_Call {
520 return &MockControlPlane_DeleteSecret_Call{Call: _e.mock.On("DeleteSecret", ctx, secretDomain, key)}
521}
522
523func (_c *MockControlPlane_DeleteSecret_Call) Run(run func(ctx context.Context, secretDomain string, key string)) *MockControlPlane_DeleteSecret_Call {
524 _c.Call.Run(func(args mock.Arguments) {
525 var arg0 context.Context
526 if args[0] != nil {
527 arg0 = args[0].(context.Context)
528 }
529 var arg1 string
530 if args[1] != nil {
531 arg1 = args[1].(string)
532 }
533 var arg2 string
534 if args[2] != nil {
535 arg2 = args[2].(string)
536 }
537 run(
538 arg0,
539 arg1,
540 arg2,
541 )
542 })
543 return _c
544}
545
546func (_c *MockControlPlane_DeleteSecret_Call) Return(err error) *MockControlPlane_DeleteSecret_Call {
547 _c.Call.Return(err)
548 return _c
549}
550
551func (_c *MockControlPlane_DeleteSecret_Call) RunAndReturn(run func(ctx context.Context, secretDomain string, key string) error) *MockControlPlane_DeleteSecret_Call {
552 _c.Call.Return(run)
553 return _c
554}
555
556// Deploy provides a mock function for the type MockControlPlane
557func (_mock *MockControlPlane) Deploy(ctx context.Context, deployDomain string) (*remote.DeployResult, error) {
558 ret := _mock.Called(ctx, deployDomain)
559
560 if len(ret) == 0 {
561 panic("no return value specified for Deploy")
562 }
563
564 var r0 *remote.DeployResult
565 var r1 error
566 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*remote.DeployResult, error)); ok {
567 return returnFunc(ctx, deployDomain)
568 }
569 if returnFunc, ok := ret.Get(0).(func(context.Context, string) *remote.DeployResult); ok {
570 r0 = returnFunc(ctx, deployDomain)
571 } else {
572 if ret.Get(0) != nil {
573 r0 = ret.Get(0).(*remote.DeployResult)
574 }
575 }
576 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
577 r1 = returnFunc(ctx, deployDomain)
578 } else {
579 r1 = ret.Error(1)
580 }
581 return r0, r1
582}
583
584// MockControlPlane_Deploy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Deploy'
585type MockControlPlane_Deploy_Call struct {
586 *mock.Call
587}
588
589// Deploy is a helper method to define mock.On call
590// - ctx context.Context
591// - deployDomain string
592func (_e *MockControlPlane_Expecter) Deploy(ctx any, deployDomain any) *MockControlPlane_Deploy_Call {
593 return &MockControlPlane_Deploy_Call{Call: _e.mock.On("Deploy", ctx, deployDomain)}
594}
595
596func (_c *MockControlPlane_Deploy_Call) Run(run func(ctx context.Context, deployDomain string)) *MockControlPlane_Deploy_Call {
597 _c.Call.Run(func(args mock.Arguments) {
598 var arg0 context.Context
599 if args[0] != nil {
600 arg0 = args[0].(context.Context)
601 }
602 var arg1 string
603 if args[1] != nil {
604 arg1 = args[1].(string)
605 }
606 run(
607 arg0,
608 arg1,
609 )
610 })
611 return _c
612}
613
614func (_c *MockControlPlane_Deploy_Call) Return(deployResult *remote.DeployResult, err error) *MockControlPlane_Deploy_Call {
615 _c.Call.Return(deployResult, err)
616 return _c
617}
618
619func (_c *MockControlPlane_Deploy_Call) RunAndReturn(run func(ctx context.Context, deployDomain string) (*remote.DeployResult, error)) *MockControlPlane_Deploy_Call {
620 _c.Call.Return(run)
621 return _c
622}
623
624// DeployIntent provides a mock function for the type MockControlPlane
625func (_mock *MockControlPlane) DeployIntent(ctx context.Context, imageName string) error {
626 ret := _mock.Called(ctx, imageName)
627
628 if len(ret) == 0 {
629 panic("no return value specified for DeployIntent")
630 }
631
632 var r0 error
633 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
634 r0 = returnFunc(ctx, imageName)
635 } else {
636 r0 = ret.Error(0)
637 }
638 return r0
639}
640
641// MockControlPlane_DeployIntent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeployIntent'
642type MockControlPlane_DeployIntent_Call struct {
643 *mock.Call
644}
645
646// DeployIntent is a helper method to define mock.On call
647// - ctx context.Context
648// - imageName string
649func (_e *MockControlPlane_Expecter) DeployIntent(ctx any, imageName any) *MockControlPlane_DeployIntent_Call {
650 return &MockControlPlane_DeployIntent_Call{Call: _e.mock.On("DeployIntent", ctx, imageName)}
651}
652
653func (_c *MockControlPlane_DeployIntent_Call) Run(run func(ctx context.Context, imageName string)) *MockControlPlane_DeployIntent_Call {
654 _c.Call.Run(func(args mock.Arguments) {
655 var arg0 context.Context
656 if args[0] != nil {
657 arg0 = args[0].(context.Context)
658 }
659 var arg1 string
660 if args[1] != nil {
661 arg1 = args[1].(string)
662 }
663 run(
664 arg0,
665 arg1,
666 )
667 })
668 return _c
669}
670
671func (_c *MockControlPlane_DeployIntent_Call) Return(err error) *MockControlPlane_DeployIntent_Call {
672 _c.Call.Return(err)
673 return _c
674}
675
676func (_c *MockControlPlane_DeployIntent_Call) RunAndReturn(run func(ctx context.Context, imageName string) error) *MockControlPlane_DeployIntent_Call {
677 _c.Call.Return(run)
678 return _c
679}
680
681// DetectDatabases provides a mock function for the type MockControlPlane
682func (_mock *MockControlPlane) DetectDatabases(ctx context.Context, backupDomain string) ([]dto.DatabaseInfo, error) {
683 ret := _mock.Called(ctx, backupDomain)
684
685 if len(ret) == 0 {
686 panic("no return value specified for DetectDatabases")
687 }
688
689 var r0 []dto.DatabaseInfo
690 var r1 error
691 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]dto.DatabaseInfo, error)); ok {
692 return returnFunc(ctx, backupDomain)
693 }
694 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []dto.DatabaseInfo); ok {
695 r0 = returnFunc(ctx, backupDomain)
696 } else {
697 if ret.Get(0) != nil {
698 r0 = ret.Get(0).([]dto.DatabaseInfo)
699 }
700 }
701 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
702 r1 = returnFunc(ctx, backupDomain)
703 } else {
704 r1 = ret.Error(1)
705 }
706 return r0, r1
707}
708
709// MockControlPlane_DetectDatabases_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DetectDatabases'
710type MockControlPlane_DetectDatabases_Call struct {
711 *mock.Call
712}
713
714// DetectDatabases is a helper method to define mock.On call
715// - ctx context.Context
716// - backupDomain string
717func (_e *MockControlPlane_Expecter) DetectDatabases(ctx any, backupDomain any) *MockControlPlane_DetectDatabases_Call {
718 return &MockControlPlane_DetectDatabases_Call{Call: _e.mock.On("DetectDatabases", ctx, backupDomain)}
719}
720
721func (_c *MockControlPlane_DetectDatabases_Call) Run(run func(ctx context.Context, backupDomain string)) *MockControlPlane_DetectDatabases_Call {
722 _c.Call.Run(func(args mock.Arguments) {
723 var arg0 context.Context
724 if args[0] != nil {
725 arg0 = args[0].(context.Context)
726 }
727 var arg1 string
728 if args[1] != nil {
729 arg1 = args[1].(string)
730 }
731 run(
732 arg0,
733 arg1,
734 )
735 })
736 return _c
737}
738
739func (_c *MockControlPlane_DetectDatabases_Call) Return(databaseInfos []dto.DatabaseInfo, err error) *MockControlPlane_DetectDatabases_Call {
740 _c.Call.Return(databaseInfos, err)
741 return _c
742}
743
744func (_c *MockControlPlane_DetectDatabases_Call) RunAndReturn(run func(ctx context.Context, backupDomain string) ([]dto.DatabaseInfo, error)) *MockControlPlane_DetectDatabases_Call {
745 _c.Call.Return(run)
746 return _c
747}
748
749// FindAttachmentTargetsByImage provides a mock function for the type MockControlPlane
750func (_mock *MockControlPlane) FindAttachmentTargetsByImage(ctx context.Context, imageName string) ([]string, error) {
751 ret := _mock.Called(ctx, imageName)
752
753 if len(ret) == 0 {
754 panic("no return value specified for FindAttachmentTargetsByImage")
755 }
756
757 var r0 []string
758 var r1 error
759 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]string, error)); ok {
760 return returnFunc(ctx, imageName)
761 }
762 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []string); ok {
763 r0 = returnFunc(ctx, imageName)
764 } else {
765 if ret.Get(0) != nil {
766 r0 = ret.Get(0).([]string)
767 }
768 }
769 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
770 r1 = returnFunc(ctx, imageName)
771 } else {
772 r1 = ret.Error(1)
773 }
774 return r0, r1
775}
776
777// MockControlPlane_FindAttachmentTargetsByImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindAttachmentTargetsByImage'
778type MockControlPlane_FindAttachmentTargetsByImage_Call struct {
779 *mock.Call
780}
781
782// FindAttachmentTargetsByImage is a helper method to define mock.On call
783// - ctx context.Context
784// - imageName string
785func (_e *MockControlPlane_Expecter) FindAttachmentTargetsByImage(ctx any, imageName any) *MockControlPlane_FindAttachmentTargetsByImage_Call {
786 return &MockControlPlane_FindAttachmentTargetsByImage_Call{Call: _e.mock.On("FindAttachmentTargetsByImage", ctx, imageName)}
787}
788
789func (_c *MockControlPlane_FindAttachmentTargetsByImage_Call) Run(run func(ctx context.Context, imageName string)) *MockControlPlane_FindAttachmentTargetsByImage_Call {
790 _c.Call.Run(func(args mock.Arguments) {
791 var arg0 context.Context
792 if args[0] != nil {
793 arg0 = args[0].(context.Context)
794 }
795 var arg1 string
796 if args[1] != nil {
797 arg1 = args[1].(string)
798 }
799 run(
800 arg0,
801 arg1,
802 )
803 })
804 return _c
805}
806
807func (_c *MockControlPlane_FindAttachmentTargetsByImage_Call) Return(strings []string, err error) *MockControlPlane_FindAttachmentTargetsByImage_Call {
808 _c.Call.Return(strings, err)
809 return _c
810}
811
812func (_c *MockControlPlane_FindAttachmentTargetsByImage_Call) RunAndReturn(run func(ctx context.Context, imageName string) ([]string, error)) *MockControlPlane_FindAttachmentTargetsByImage_Call {
813 _c.Call.Return(run)
814 return _c
815}
816
817// FindRoutesByImage provides a mock function for the type MockControlPlane
818func (_mock *MockControlPlane) FindRoutesByImage(ctx context.Context, imageName string) ([]domain.Route, error) {
819 ret := _mock.Called(ctx, imageName)
820
821 if len(ret) == 0 {
822 panic("no return value specified for FindRoutesByImage")
823 }
824
825 var r0 []domain.Route
826 var r1 error
827 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]domain.Route, error)); ok {
828 return returnFunc(ctx, imageName)
829 }
830 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []domain.Route); ok {
831 r0 = returnFunc(ctx, imageName)
832 } else {
833 if ret.Get(0) != nil {
834 r0 = ret.Get(0).([]domain.Route)
835 }
836 }
837 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
838 r1 = returnFunc(ctx, imageName)
839 } else {
840 r1 = ret.Error(1)
841 }
842 return r0, r1
843}
844
845// MockControlPlane_FindRoutesByImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindRoutesByImage'
846type MockControlPlane_FindRoutesByImage_Call struct {
847 *mock.Call
848}
849
850// FindRoutesByImage is a helper method to define mock.On call
851// - ctx context.Context
852// - imageName string
853func (_e *MockControlPlane_Expecter) FindRoutesByImage(ctx any, imageName any) *MockControlPlane_FindRoutesByImage_Call {
854 return &MockControlPlane_FindRoutesByImage_Call{Call: _e.mock.On("FindRoutesByImage", ctx, imageName)}
855}
856
857func (_c *MockControlPlane_FindRoutesByImage_Call) Run(run func(ctx context.Context, imageName string)) *MockControlPlane_FindRoutesByImage_Call {
858 _c.Call.Run(func(args mock.Arguments) {
859 var arg0 context.Context
860 if args[0] != nil {
861 arg0 = args[0].(context.Context)
862 }
863 var arg1 string
864 if args[1] != nil {
865 arg1 = args[1].(string)
866 }
867 run(
868 arg0,
869 arg1,
870 )
871 })
872 return _c
873}
874
875func (_c *MockControlPlane_FindRoutesByImage_Call) Return(routes []domain.Route, err error) *MockControlPlane_FindRoutesByImage_Call {
876 _c.Call.Return(routes, err)
877 return _c
878}
879
880func (_c *MockControlPlane_FindRoutesByImage_Call) RunAndReturn(run func(ctx context.Context, imageName string) ([]domain.Route, error)) *MockControlPlane_FindRoutesByImage_Call {
881 _c.Call.Return(run)
882 return _c
883}
884
885// GetAllAttachmentsConfig provides a mock function for the type MockControlPlane
886func (_mock *MockControlPlane) GetAllAttachmentsConfig(ctx context.Context) (map[string][]string, error) {
887 ret := _mock.Called(ctx)
888
889 if len(ret) == 0 {
890 panic("no return value specified for GetAllAttachmentsConfig")
891 }
892
893 var r0 map[string][]string
894 var r1 error
895 if returnFunc, ok := ret.Get(0).(func(context.Context) (map[string][]string, error)); ok {
896 return returnFunc(ctx)
897 }
898 if returnFunc, ok := ret.Get(0).(func(context.Context) map[string][]string); ok {
899 r0 = returnFunc(ctx)
900 } else {
901 if ret.Get(0) != nil {
902 r0 = ret.Get(0).(map[string][]string)
903 }
904 }
905 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
906 r1 = returnFunc(ctx)
907 } else {
908 r1 = ret.Error(1)
909 }
910 return r0, r1
911}
912
913// MockControlPlane_GetAllAttachmentsConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllAttachmentsConfig'
914type MockControlPlane_GetAllAttachmentsConfig_Call struct {
915 *mock.Call
916}
917
918// GetAllAttachmentsConfig is a helper method to define mock.On call
919// - ctx context.Context
920func (_e *MockControlPlane_Expecter) GetAllAttachmentsConfig(ctx any) *MockControlPlane_GetAllAttachmentsConfig_Call {
921 return &MockControlPlane_GetAllAttachmentsConfig_Call{Call: _e.mock.On("GetAllAttachmentsConfig", ctx)}
922}
923
924func (_c *MockControlPlane_GetAllAttachmentsConfig_Call) Run(run func(ctx context.Context)) *MockControlPlane_GetAllAttachmentsConfig_Call {
925 _c.Call.Run(func(args mock.Arguments) {
926 var arg0 context.Context
927 if args[0] != nil {
928 arg0 = args[0].(context.Context)
929 }
930 run(
931 arg0,
932 )
933 })
934 return _c
935}
936
937func (_c *MockControlPlane_GetAllAttachmentsConfig_Call) Return(stringToStrings map[string][]string, err error) *MockControlPlane_GetAllAttachmentsConfig_Call {
938 _c.Call.Return(stringToStrings, err)
939 return _c
940}
941
942func (_c *MockControlPlane_GetAllAttachmentsConfig_Call) RunAndReturn(run func(ctx context.Context) (map[string][]string, error)) *MockControlPlane_GetAllAttachmentsConfig_Call {
943 _c.Call.Return(run)
944 return _c
945}
946
947// GetAttachmentsConfig provides a mock function for the type MockControlPlane
948func (_mock *MockControlPlane) GetAttachmentsConfig(ctx context.Context, domainOrGroup string) ([]string, error) {
949 ret := _mock.Called(ctx, domainOrGroup)
950
951 if len(ret) == 0 {
952 panic("no return value specified for GetAttachmentsConfig")
953 }
954
955 var r0 []string
956 var r1 error
957 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]string, error)); ok {
958 return returnFunc(ctx, domainOrGroup)
959 }
960 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []string); ok {
961 r0 = returnFunc(ctx, domainOrGroup)
962 } else {
963 if ret.Get(0) != nil {
964 r0 = ret.Get(0).([]string)
965 }
966 }
967 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
968 r1 = returnFunc(ctx, domainOrGroup)
969 } else {
970 r1 = ret.Error(1)
971 }
972 return r0, r1
973}
974
975// MockControlPlane_GetAttachmentsConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAttachmentsConfig'
976type MockControlPlane_GetAttachmentsConfig_Call struct {
977 *mock.Call
978}
979
980// GetAttachmentsConfig is a helper method to define mock.On call
981// - ctx context.Context
982// - domainOrGroup string
983func (_e *MockControlPlane_Expecter) GetAttachmentsConfig(ctx any, domainOrGroup any) *MockControlPlane_GetAttachmentsConfig_Call {
984 return &MockControlPlane_GetAttachmentsConfig_Call{Call: _e.mock.On("GetAttachmentsConfig", ctx, domainOrGroup)}
985}
986
987func (_c *MockControlPlane_GetAttachmentsConfig_Call) Run(run func(ctx context.Context, domainOrGroup string)) *MockControlPlane_GetAttachmentsConfig_Call {
988 _c.Call.Run(func(args mock.Arguments) {
989 var arg0 context.Context
990 if args[0] != nil {
991 arg0 = args[0].(context.Context)
992 }
993 var arg1 string
994 if args[1] != nil {
995 arg1 = args[1].(string)
996 }
997 run(
998 arg0,
999 arg1,
1000 )
1001 })
1002 return _c
1003}
1004
1005func (_c *MockControlPlane_GetAttachmentsConfig_Call) Return(strings []string, err error) *MockControlPlane_GetAttachmentsConfig_Call {
1006 _c.Call.Return(strings, err)
1007 return _c
1008}
1009
1010func (_c *MockControlPlane_GetAttachmentsConfig_Call) RunAndReturn(run func(ctx context.Context, domainOrGroup string) ([]string, error)) *MockControlPlane_GetAttachmentsConfig_Call {
1011 _c.Call.Return(run)
1012 return _c
1013}
1014
1015// GetAutoRouteAllowedDomains provides a mock function for the type MockControlPlane
1016func (_mock *MockControlPlane) GetAutoRouteAllowedDomains(ctx context.Context) ([]string, error) {
1017 ret := _mock.Called(ctx)
1018
1019 if len(ret) == 0 {
1020 panic("no return value specified for GetAutoRouteAllowedDomains")
1021 }
1022
1023 var r0 []string
1024 var r1 error
1025 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]string, error)); ok {
1026 return returnFunc(ctx)
1027 }
1028 if returnFunc, ok := ret.Get(0).(func(context.Context) []string); ok {
1029 r0 = returnFunc(ctx)
1030 } else {
1031 if ret.Get(0) != nil {
1032 r0 = ret.Get(0).([]string)
1033 }
1034 }
1035 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1036 r1 = returnFunc(ctx)
1037 } else {
1038 r1 = ret.Error(1)
1039 }
1040 return r0, r1
1041}
1042
1043// MockControlPlane_GetAutoRouteAllowedDomains_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAutoRouteAllowedDomains'
1044type MockControlPlane_GetAutoRouteAllowedDomains_Call struct {
1045 *mock.Call
1046}
1047
1048// GetAutoRouteAllowedDomains is a helper method to define mock.On call
1049// - ctx context.Context
1050func (_e *MockControlPlane_Expecter) GetAutoRouteAllowedDomains(ctx any) *MockControlPlane_GetAutoRouteAllowedDomains_Call {
1051 return &MockControlPlane_GetAutoRouteAllowedDomains_Call{Call: _e.mock.On("GetAutoRouteAllowedDomains", ctx)}
1052}
1053
1054func (_c *MockControlPlane_GetAutoRouteAllowedDomains_Call) Run(run func(ctx context.Context)) *MockControlPlane_GetAutoRouteAllowedDomains_Call {
1055 _c.Call.Run(func(args mock.Arguments) {
1056 var arg0 context.Context
1057 if args[0] != nil {
1058 arg0 = args[0].(context.Context)
1059 }
1060 run(
1061 arg0,
1062 )
1063 })
1064 return _c
1065}
1066
1067func (_c *MockControlPlane_GetAutoRouteAllowedDomains_Call) Return(strings []string, err error) *MockControlPlane_GetAutoRouteAllowedDomains_Call {
1068 _c.Call.Return(strings, err)
1069 return _c
1070}
1071
1072func (_c *MockControlPlane_GetAutoRouteAllowedDomains_Call) RunAndReturn(run func(ctx context.Context) ([]string, error)) *MockControlPlane_GetAutoRouteAllowedDomains_Call {
1073 _c.Call.Return(run)
1074 return _c
1075}
1076
1077// GetConfig provides a mock function for the type MockControlPlane
1078func (_mock *MockControlPlane) GetConfig(ctx context.Context) (*remote.Config, error) {
1079 ret := _mock.Called(ctx)
1080
1081 if len(ret) == 0 {
1082 panic("no return value specified for GetConfig")
1083 }
1084
1085 var r0 *remote.Config
1086 var r1 error
1087 if returnFunc, ok := ret.Get(0).(func(context.Context) (*remote.Config, error)); ok {
1088 return returnFunc(ctx)
1089 }
1090 if returnFunc, ok := ret.Get(0).(func(context.Context) *remote.Config); ok {
1091 r0 = returnFunc(ctx)
1092 } else {
1093 if ret.Get(0) != nil {
1094 r0 = ret.Get(0).(*remote.Config)
1095 }
1096 }
1097 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1098 r1 = returnFunc(ctx)
1099 } else {
1100 r1 = ret.Error(1)
1101 }
1102 return r0, r1
1103}
1104
1105// MockControlPlane_GetConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConfig'
1106type MockControlPlane_GetConfig_Call struct {
1107 *mock.Call
1108}
1109
1110// GetConfig is a helper method to define mock.On call
1111// - ctx context.Context
1112func (_e *MockControlPlane_Expecter) GetConfig(ctx any) *MockControlPlane_GetConfig_Call {
1113 return &MockControlPlane_GetConfig_Call{Call: _e.mock.On("GetConfig", ctx)}
1114}
1115
1116func (_c *MockControlPlane_GetConfig_Call) Run(run func(ctx context.Context)) *MockControlPlane_GetConfig_Call {
1117 _c.Call.Run(func(args mock.Arguments) {
1118 var arg0 context.Context
1119 if args[0] != nil {
1120 arg0 = args[0].(context.Context)
1121 }
1122 run(
1123 arg0,
1124 )
1125 })
1126 return _c
1127}
1128
1129func (_c *MockControlPlane_GetConfig_Call) Return(config *remote.Config, err error) *MockControlPlane_GetConfig_Call {
1130 _c.Call.Return(config, err)
1131 return _c
1132}
1133
1134func (_c *MockControlPlane_GetConfig_Call) RunAndReturn(run func(ctx context.Context) (*remote.Config, error)) *MockControlPlane_GetConfig_Call {
1135 _c.Call.Return(run)
1136 return _c
1137}
1138
1139// GetContainerLogs provides a mock function for the type MockControlPlane
1140func (_mock *MockControlPlane) GetContainerLogs(ctx context.Context, logDomain string, lines int) ([]string, error) {
1141 ret := _mock.Called(ctx, logDomain, lines)
1142
1143 if len(ret) == 0 {
1144 panic("no return value specified for GetContainerLogs")
1145 }
1146
1147 var r0 []string
1148 var r1 error
1149 if returnFunc, ok := ret.Get(0).(func(context.Context, string, int) ([]string, error)); ok {
1150 return returnFunc(ctx, logDomain, lines)
1151 }
1152 if returnFunc, ok := ret.Get(0).(func(context.Context, string, int) []string); ok {
1153 r0 = returnFunc(ctx, logDomain, lines)
1154 } else {
1155 if ret.Get(0) != nil {
1156 r0 = ret.Get(0).([]string)
1157 }
1158 }
1159 if returnFunc, ok := ret.Get(1).(func(context.Context, string, int) error); ok {
1160 r1 = returnFunc(ctx, logDomain, lines)
1161 } else {
1162 r1 = ret.Error(1)
1163 }
1164 return r0, r1
1165}
1166
1167// MockControlPlane_GetContainerLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetContainerLogs'
1168type MockControlPlane_GetContainerLogs_Call struct {
1169 *mock.Call
1170}
1171
1172// GetContainerLogs is a helper method to define mock.On call
1173// - ctx context.Context
1174// - logDomain string
1175// - lines int
1176func (_e *MockControlPlane_Expecter) GetContainerLogs(ctx any, logDomain any, lines any) *MockControlPlane_GetContainerLogs_Call {
1177 return &MockControlPlane_GetContainerLogs_Call{Call: _e.mock.On("GetContainerLogs", ctx, logDomain, lines)}
1178}
1179
1180func (_c *MockControlPlane_GetContainerLogs_Call) Run(run func(ctx context.Context, logDomain string, lines int)) *MockControlPlane_GetContainerLogs_Call {
1181 _c.Call.Run(func(args mock.Arguments) {
1182 var arg0 context.Context
1183 if args[0] != nil {
1184 arg0 = args[0].(context.Context)
1185 }
1186 var arg1 string
1187 if args[1] != nil {
1188 arg1 = args[1].(string)
1189 }
1190 var arg2 int
1191 if args[2] != nil {
1192 arg2 = args[2].(int)
1193 }
1194 run(
1195 arg0,
1196 arg1,
1197 arg2,
1198 )
1199 })
1200 return _c
1201}
1202
1203func (_c *MockControlPlane_GetContainerLogs_Call) Return(strings []string, err error) *MockControlPlane_GetContainerLogs_Call {
1204 _c.Call.Return(strings, err)
1205 return _c
1206}
1207
1208func (_c *MockControlPlane_GetContainerLogs_Call) RunAndReturn(run func(ctx context.Context, logDomain string, lines int) ([]string, error)) *MockControlPlane_GetContainerLogs_Call {
1209 _c.Call.Return(run)
1210 return _c
1211}
1212
1213// GetHealth provides a mock function for the type MockControlPlane
1214func (_mock *MockControlPlane) GetHealth(ctx context.Context) (map[string]*remote.RouteHealth, error) {
1215 ret := _mock.Called(ctx)
1216
1217 if len(ret) == 0 {
1218 panic("no return value specified for GetHealth")
1219 }
1220
1221 var r0 map[string]*remote.RouteHealth
1222 var r1 error
1223 if returnFunc, ok := ret.Get(0).(func(context.Context) (map[string]*remote.RouteHealth, error)); ok {
1224 return returnFunc(ctx)
1225 }
1226 if returnFunc, ok := ret.Get(0).(func(context.Context) map[string]*remote.RouteHealth); ok {
1227 r0 = returnFunc(ctx)
1228 } else {
1229 if ret.Get(0) != nil {
1230 r0 = ret.Get(0).(map[string]*remote.RouteHealth)
1231 }
1232 }
1233 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1234 r1 = returnFunc(ctx)
1235 } else {
1236 r1 = ret.Error(1)
1237 }
1238 return r0, r1
1239}
1240
1241// MockControlPlane_GetHealth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHealth'
1242type MockControlPlane_GetHealth_Call struct {
1243 *mock.Call
1244}
1245
1246// GetHealth is a helper method to define mock.On call
1247// - ctx context.Context
1248func (_e *MockControlPlane_Expecter) GetHealth(ctx any) *MockControlPlane_GetHealth_Call {
1249 return &MockControlPlane_GetHealth_Call{Call: _e.mock.On("GetHealth", ctx)}
1250}
1251
1252func (_c *MockControlPlane_GetHealth_Call) Run(run func(ctx context.Context)) *MockControlPlane_GetHealth_Call {
1253 _c.Call.Run(func(args mock.Arguments) {
1254 var arg0 context.Context
1255 if args[0] != nil {
1256 arg0 = args[0].(context.Context)
1257 }
1258 run(
1259 arg0,
1260 )
1261 })
1262 return _c
1263}
1264
1265func (_c *MockControlPlane_GetHealth_Call) Return(stringToRouteHealth map[string]*remote.RouteHealth, err error) *MockControlPlane_GetHealth_Call {
1266 _c.Call.Return(stringToRouteHealth, err)
1267 return _c
1268}
1269
1270func (_c *MockControlPlane_GetHealth_Call) RunAndReturn(run func(ctx context.Context) (map[string]*remote.RouteHealth, error)) *MockControlPlane_GetHealth_Call {
1271 _c.Call.Return(run)
1272 return _c
1273}
1274
1275// GetProcessLogs provides a mock function for the type MockControlPlane
1276func (_mock *MockControlPlane) GetProcessLogs(ctx context.Context, lines int) ([]string, error) {
1277 ret := _mock.Called(ctx, lines)
1278
1279 if len(ret) == 0 {
1280 panic("no return value specified for GetProcessLogs")
1281 }
1282
1283 var r0 []string
1284 var r1 error
1285 if returnFunc, ok := ret.Get(0).(func(context.Context, int) ([]string, error)); ok {
1286 return returnFunc(ctx, lines)
1287 }
1288 if returnFunc, ok := ret.Get(0).(func(context.Context, int) []string); ok {
1289 r0 = returnFunc(ctx, lines)
1290 } else {
1291 if ret.Get(0) != nil {
1292 r0 = ret.Get(0).([]string)
1293 }
1294 }
1295 if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
1296 r1 = returnFunc(ctx, lines)
1297 } else {
1298 r1 = ret.Error(1)
1299 }
1300 return r0, r1
1301}
1302
1303// MockControlPlane_GetProcessLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProcessLogs'
1304type MockControlPlane_GetProcessLogs_Call struct {
1305 *mock.Call
1306}
1307
1308// GetProcessLogs is a helper method to define mock.On call
1309// - ctx context.Context
1310// - lines int
1311func (_e *MockControlPlane_Expecter) GetProcessLogs(ctx any, lines any) *MockControlPlane_GetProcessLogs_Call {
1312 return &MockControlPlane_GetProcessLogs_Call{Call: _e.mock.On("GetProcessLogs", ctx, lines)}
1313}
1314
1315func (_c *MockControlPlane_GetProcessLogs_Call) Run(run func(ctx context.Context, lines int)) *MockControlPlane_GetProcessLogs_Call {
1316 _c.Call.Run(func(args mock.Arguments) {
1317 var arg0 context.Context
1318 if args[0] != nil {
1319 arg0 = args[0].(context.Context)
1320 }
1321 var arg1 int
1322 if args[1] != nil {
1323 arg1 = args[1].(int)
1324 }
1325 run(
1326 arg0,
1327 arg1,
1328 )
1329 })
1330 return _c
1331}
1332
1333func (_c *MockControlPlane_GetProcessLogs_Call) Return(strings []string, err error) *MockControlPlane_GetProcessLogs_Call {
1334 _c.Call.Return(strings, err)
1335 return _c
1336}
1337
1338func (_c *MockControlPlane_GetProcessLogs_Call) RunAndReturn(run func(ctx context.Context, lines int) ([]string, error)) *MockControlPlane_GetProcessLogs_Call {
1339 _c.Call.Return(run)
1340 return _c
1341}
1342
1343// GetRoute provides a mock function for the type MockControlPlane
1344func (_mock *MockControlPlane) GetRoute(ctx context.Context, routeDomain string) (*domain.Route, error) {
1345 ret := _mock.Called(ctx, routeDomain)
1346
1347 if len(ret) == 0 {
1348 panic("no return value specified for GetRoute")
1349 }
1350
1351 var r0 *domain.Route
1352 var r1 error
1353 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*domain.Route, error)); ok {
1354 return returnFunc(ctx, routeDomain)
1355 }
1356 if returnFunc, ok := ret.Get(0).(func(context.Context, string) *domain.Route); ok {
1357 r0 = returnFunc(ctx, routeDomain)
1358 } else {
1359 if ret.Get(0) != nil {
1360 r0 = ret.Get(0).(*domain.Route)
1361 }
1362 }
1363 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
1364 r1 = returnFunc(ctx, routeDomain)
1365 } else {
1366 r1 = ret.Error(1)
1367 }
1368 return r0, r1
1369}
1370
1371// MockControlPlane_GetRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRoute'
1372type MockControlPlane_GetRoute_Call struct {
1373 *mock.Call
1374}
1375
1376// GetRoute is a helper method to define mock.On call
1377// - ctx context.Context
1378// - routeDomain string
1379func (_e *MockControlPlane_Expecter) GetRoute(ctx any, routeDomain any) *MockControlPlane_GetRoute_Call {
1380 return &MockControlPlane_GetRoute_Call{Call: _e.mock.On("GetRoute", ctx, routeDomain)}
1381}
1382
1383func (_c *MockControlPlane_GetRoute_Call) Run(run func(ctx context.Context, routeDomain string)) *MockControlPlane_GetRoute_Call {
1384 _c.Call.Run(func(args mock.Arguments) {
1385 var arg0 context.Context
1386 if args[0] != nil {
1387 arg0 = args[0].(context.Context)
1388 }
1389 var arg1 string
1390 if args[1] != nil {
1391 arg1 = args[1].(string)
1392 }
1393 run(
1394 arg0,
1395 arg1,
1396 )
1397 })
1398 return _c
1399}
1400
1401func (_c *MockControlPlane_GetRoute_Call) Return(route *domain.Route, err error) *MockControlPlane_GetRoute_Call {
1402 _c.Call.Return(route, err)
1403 return _c
1404}
1405
1406func (_c *MockControlPlane_GetRoute_Call) RunAndReturn(run func(ctx context.Context, routeDomain string) (*domain.Route, error)) *MockControlPlane_GetRoute_Call {
1407 _c.Call.Return(run)
1408 return _c
1409}
1410
1411// GetStatus provides a mock function for the type MockControlPlane
1412func (_mock *MockControlPlane) GetStatus(ctx context.Context) (*remote.Status, error) {
1413 ret := _mock.Called(ctx)
1414
1415 if len(ret) == 0 {
1416 panic("no return value specified for GetStatus")
1417 }
1418
1419 var r0 *remote.Status
1420 var r1 error
1421 if returnFunc, ok := ret.Get(0).(func(context.Context) (*remote.Status, error)); ok {
1422 return returnFunc(ctx)
1423 }
1424 if returnFunc, ok := ret.Get(0).(func(context.Context) *remote.Status); ok {
1425 r0 = returnFunc(ctx)
1426 } else {
1427 if ret.Get(0) != nil {
1428 r0 = ret.Get(0).(*remote.Status)
1429 }
1430 }
1431 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1432 r1 = returnFunc(ctx)
1433 } else {
1434 r1 = ret.Error(1)
1435 }
1436 return r0, r1
1437}
1438
1439// MockControlPlane_GetStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStatus'
1440type MockControlPlane_GetStatus_Call struct {
1441 *mock.Call
1442}
1443
1444// GetStatus is a helper method to define mock.On call
1445// - ctx context.Context
1446func (_e *MockControlPlane_Expecter) GetStatus(ctx any) *MockControlPlane_GetStatus_Call {
1447 return &MockControlPlane_GetStatus_Call{Call: _e.mock.On("GetStatus", ctx)}
1448}
1449
1450func (_c *MockControlPlane_GetStatus_Call) Run(run func(ctx context.Context)) *MockControlPlane_GetStatus_Call {
1451 _c.Call.Run(func(args mock.Arguments) {
1452 var arg0 context.Context
1453 if args[0] != nil {
1454 arg0 = args[0].(context.Context)
1455 }
1456 run(
1457 arg0,
1458 )
1459 })
1460 return _c
1461}
1462
1463func (_c *MockControlPlane_GetStatus_Call) Return(status *remote.Status, err error) *MockControlPlane_GetStatus_Call {
1464 _c.Call.Return(status, err)
1465 return _c
1466}
1467
1468func (_c *MockControlPlane_GetStatus_Call) RunAndReturn(run func(ctx context.Context) (*remote.Status, error)) *MockControlPlane_GetStatus_Call {
1469 _c.Call.Return(run)
1470 return _c
1471}
1472
1473// GetTLSStatus provides a mock function for the type MockControlPlane
1474func (_mock *MockControlPlane) GetTLSStatus(ctx context.Context) (*dto.TLSStatusResponse, error) {
1475 ret := _mock.Called(ctx)
1476
1477 if len(ret) == 0 {
1478 panic("no return value specified for GetTLSStatus")
1479 }
1480
1481 var r0 *dto.TLSStatusResponse
1482 var r1 error
1483 if returnFunc, ok := ret.Get(0).(func(context.Context) (*dto.TLSStatusResponse, error)); ok {
1484 return returnFunc(ctx)
1485 }
1486 if returnFunc, ok := ret.Get(0).(func(context.Context) *dto.TLSStatusResponse); ok {
1487 r0 = returnFunc(ctx)
1488 } else {
1489 if ret.Get(0) != nil {
1490 r0 = ret.Get(0).(*dto.TLSStatusResponse)
1491 }
1492 }
1493 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1494 r1 = returnFunc(ctx)
1495 } else {
1496 r1 = ret.Error(1)
1497 }
1498 return r0, r1
1499}
1500
1501// MockControlPlane_GetTLSStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTLSStatus'
1502type MockControlPlane_GetTLSStatus_Call struct {
1503 *mock.Call
1504}
1505
1506// GetTLSStatus is a helper method to define mock.On call
1507// - ctx context.Context
1508func (_e *MockControlPlane_Expecter) GetTLSStatus(ctx any) *MockControlPlane_GetTLSStatus_Call {
1509 return &MockControlPlane_GetTLSStatus_Call{Call: _e.mock.On("GetTLSStatus", ctx)}
1510}
1511
1512func (_c *MockControlPlane_GetTLSStatus_Call) Run(run func(ctx context.Context)) *MockControlPlane_GetTLSStatus_Call {
1513 _c.Call.Run(func(args mock.Arguments) {
1514 var arg0 context.Context
1515 if args[0] != nil {
1516 arg0 = args[0].(context.Context)
1517 }
1518 run(
1519 arg0,
1520 )
1521 })
1522 return _c
1523}
1524
1525func (_c *MockControlPlane_GetTLSStatus_Call) Return(tLSStatusResponse *dto.TLSStatusResponse, err error) *MockControlPlane_GetTLSStatus_Call {
1526 _c.Call.Return(tLSStatusResponse, err)
1527 return _c
1528}
1529
1530func (_c *MockControlPlane_GetTLSStatus_Call) RunAndReturn(run func(ctx context.Context) (*dto.TLSStatusResponse, error)) *MockControlPlane_GetTLSStatus_Call {
1531 _c.Call.Return(run)
1532 return _c
1533}
1534
1535// GetTrafficStatus provides a mock function for the type MockControlPlane
1536func (_mock *MockControlPlane) GetTrafficStatus(ctx context.Context) (*dto.TrafficStatusResponse, error) {
1537 ret := _mock.Called(ctx)
1538
1539 if len(ret) == 0 {
1540 panic("no return value specified for GetTrafficStatus")
1541 }
1542
1543 var r0 *dto.TrafficStatusResponse
1544 var r1 error
1545 if returnFunc, ok := ret.Get(0).(func(context.Context) (*dto.TrafficStatusResponse, error)); ok {
1546 return returnFunc(ctx)
1547 }
1548 if returnFunc, ok := ret.Get(0).(func(context.Context) *dto.TrafficStatusResponse); ok {
1549 r0 = returnFunc(ctx)
1550 } else {
1551 if ret.Get(0) != nil {
1552 r0 = ret.Get(0).(*dto.TrafficStatusResponse)
1553 }
1554 }
1555 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1556 r1 = returnFunc(ctx)
1557 } else {
1558 r1 = ret.Error(1)
1559 }
1560 return r0, r1
1561}
1562
1563// MockControlPlane_GetTrafficStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTrafficStatus'
1564type MockControlPlane_GetTrafficStatus_Call struct {
1565 *mock.Call
1566}
1567
1568// GetTrafficStatus is a helper method to define mock.On call
1569// - ctx context.Context
1570func (_e *MockControlPlane_Expecter) GetTrafficStatus(ctx any) *MockControlPlane_GetTrafficStatus_Call {
1571 return &MockControlPlane_GetTrafficStatus_Call{Call: _e.mock.On("GetTrafficStatus", ctx)}
1572}
1573
1574func (_c *MockControlPlane_GetTrafficStatus_Call) Run(run func(ctx context.Context)) *MockControlPlane_GetTrafficStatus_Call {
1575 _c.Call.Run(func(args mock.Arguments) {
1576 var arg0 context.Context
1577 if args[0] != nil {
1578 arg0 = args[0].(context.Context)
1579 }
1580 run(
1581 arg0,
1582 )
1583 })
1584 return _c
1585}
1586
1587func (_c *MockControlPlane_GetTrafficStatus_Call) Return(trafficStatusResponse *dto.TrafficStatusResponse, err error) *MockControlPlane_GetTrafficStatus_Call {
1588 _c.Call.Return(trafficStatusResponse, err)
1589 return _c
1590}
1591
1592func (_c *MockControlPlane_GetTrafficStatus_Call) RunAndReturn(run func(ctx context.Context) (*dto.TrafficStatusResponse, error)) *MockControlPlane_GetTrafficStatus_Call {
1593 _c.Call.Return(run)
1594 return _c
1595}
1596
1597// ListBackups provides a mock function for the type MockControlPlane
1598func (_mock *MockControlPlane) ListBackups(ctx context.Context, backupDomain string) ([]dto.BackupJob, error) {
1599 ret := _mock.Called(ctx, backupDomain)
1600
1601 if len(ret) == 0 {
1602 panic("no return value specified for ListBackups")
1603 }
1604
1605 var r0 []dto.BackupJob
1606 var r1 error
1607 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]dto.BackupJob, error)); ok {
1608 return returnFunc(ctx, backupDomain)
1609 }
1610 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []dto.BackupJob); ok {
1611 r0 = returnFunc(ctx, backupDomain)
1612 } else {
1613 if ret.Get(0) != nil {
1614 r0 = ret.Get(0).([]dto.BackupJob)
1615 }
1616 }
1617 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
1618 r1 = returnFunc(ctx, backupDomain)
1619 } else {
1620 r1 = ret.Error(1)
1621 }
1622 return r0, r1
1623}
1624
1625// MockControlPlane_ListBackups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBackups'
1626type MockControlPlane_ListBackups_Call struct {
1627 *mock.Call
1628}
1629
1630// ListBackups is a helper method to define mock.On call
1631// - ctx context.Context
1632// - backupDomain string
1633func (_e *MockControlPlane_Expecter) ListBackups(ctx any, backupDomain any) *MockControlPlane_ListBackups_Call {
1634 return &MockControlPlane_ListBackups_Call{Call: _e.mock.On("ListBackups", ctx, backupDomain)}
1635}
1636
1637func (_c *MockControlPlane_ListBackups_Call) Run(run func(ctx context.Context, backupDomain string)) *MockControlPlane_ListBackups_Call {
1638 _c.Call.Run(func(args mock.Arguments) {
1639 var arg0 context.Context
1640 if args[0] != nil {
1641 arg0 = args[0].(context.Context)
1642 }
1643 var arg1 string
1644 if args[1] != nil {
1645 arg1 = args[1].(string)
1646 }
1647 run(
1648 arg0,
1649 arg1,
1650 )
1651 })
1652 return _c
1653}
1654
1655func (_c *MockControlPlane_ListBackups_Call) Return(backupJobs []dto.BackupJob, err error) *MockControlPlane_ListBackups_Call {
1656 _c.Call.Return(backupJobs, err)
1657 return _c
1658}
1659
1660func (_c *MockControlPlane_ListBackups_Call) RunAndReturn(run func(ctx context.Context, backupDomain string) ([]dto.BackupJob, error)) *MockControlPlane_ListBackups_Call {
1661 _c.Call.Return(run)
1662 return _c
1663}
1664
1665// ListNetworks provides a mock function for the type MockControlPlane
1666func (_mock *MockControlPlane) ListNetworks(ctx context.Context) ([]*domain.NetworkInfo, error) {
1667 ret := _mock.Called(ctx)
1668
1669 if len(ret) == 0 {
1670 panic("no return value specified for ListNetworks")
1671 }
1672
1673 var r0 []*domain.NetworkInfo
1674 var r1 error
1675 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*domain.NetworkInfo, error)); ok {
1676 return returnFunc(ctx)
1677 }
1678 if returnFunc, ok := ret.Get(0).(func(context.Context) []*domain.NetworkInfo); ok {
1679 r0 = returnFunc(ctx)
1680 } else {
1681 if ret.Get(0) != nil {
1682 r0 = ret.Get(0).([]*domain.NetworkInfo)
1683 }
1684 }
1685 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1686 r1 = returnFunc(ctx)
1687 } else {
1688 r1 = ret.Error(1)
1689 }
1690 return r0, r1
1691}
1692
1693// MockControlPlane_ListNetworks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListNetworks'
1694type MockControlPlane_ListNetworks_Call struct {
1695 *mock.Call
1696}
1697
1698// ListNetworks is a helper method to define mock.On call
1699// - ctx context.Context
1700func (_e *MockControlPlane_Expecter) ListNetworks(ctx any) *MockControlPlane_ListNetworks_Call {
1701 return &MockControlPlane_ListNetworks_Call{Call: _e.mock.On("ListNetworks", ctx)}
1702}
1703
1704func (_c *MockControlPlane_ListNetworks_Call) Run(run func(ctx context.Context)) *MockControlPlane_ListNetworks_Call {
1705 _c.Call.Run(func(args mock.Arguments) {
1706 var arg0 context.Context
1707 if args[0] != nil {
1708 arg0 = args[0].(context.Context)
1709 }
1710 run(
1711 arg0,
1712 )
1713 })
1714 return _c
1715}
1716
1717func (_c *MockControlPlane_ListNetworks_Call) Return(networkInfos []*domain.NetworkInfo, err error) *MockControlPlane_ListNetworks_Call {
1718 _c.Call.Return(networkInfos, err)
1719 return _c
1720}
1721
1722func (_c *MockControlPlane_ListNetworks_Call) RunAndReturn(run func(ctx context.Context) ([]*domain.NetworkInfo, error)) *MockControlPlane_ListNetworks_Call {
1723 _c.Call.Return(run)
1724 return _c
1725}
1726
1727// ListOrphanedAttachments provides a mock function for the type MockControlPlane
1728func (_mock *MockControlPlane) ListOrphanedAttachments(ctx context.Context) ([]domain.CleanupAttachment, error) {
1729 ret := _mock.Called(ctx)
1730
1731 if len(ret) == 0 {
1732 panic("no return value specified for ListOrphanedAttachments")
1733 }
1734
1735 var r0 []domain.CleanupAttachment
1736 var r1 error
1737 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]domain.CleanupAttachment, error)); ok {
1738 return returnFunc(ctx)
1739 }
1740 if returnFunc, ok := ret.Get(0).(func(context.Context) []domain.CleanupAttachment); ok {
1741 r0 = returnFunc(ctx)
1742 } else {
1743 if ret.Get(0) != nil {
1744 r0 = ret.Get(0).([]domain.CleanupAttachment)
1745 }
1746 }
1747 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1748 r1 = returnFunc(ctx)
1749 } else {
1750 r1 = ret.Error(1)
1751 }
1752 return r0, r1
1753}
1754
1755// MockControlPlane_ListOrphanedAttachments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOrphanedAttachments'
1756type MockControlPlane_ListOrphanedAttachments_Call struct {
1757 *mock.Call
1758}
1759
1760// ListOrphanedAttachments is a helper method to define mock.On call
1761// - ctx context.Context
1762func (_e *MockControlPlane_Expecter) ListOrphanedAttachments(ctx any) *MockControlPlane_ListOrphanedAttachments_Call {
1763 return &MockControlPlane_ListOrphanedAttachments_Call{Call: _e.mock.On("ListOrphanedAttachments", ctx)}
1764}
1765
1766func (_c *MockControlPlane_ListOrphanedAttachments_Call) Run(run func(ctx context.Context)) *MockControlPlane_ListOrphanedAttachments_Call {
1767 _c.Call.Run(func(args mock.Arguments) {
1768 var arg0 context.Context
1769 if args[0] != nil {
1770 arg0 = args[0].(context.Context)
1771 }
1772 run(
1773 arg0,
1774 )
1775 })
1776 return _c
1777}
1778
1779func (_c *MockControlPlane_ListOrphanedAttachments_Call) Return(cleanupAttachments []domain.CleanupAttachment, err error) *MockControlPlane_ListOrphanedAttachments_Call {
1780 _c.Call.Return(cleanupAttachments, err)
1781 return _c
1782}
1783
1784func (_c *MockControlPlane_ListOrphanedAttachments_Call) RunAndReturn(run func(ctx context.Context) ([]domain.CleanupAttachment, error)) *MockControlPlane_ListOrphanedAttachments_Call {
1785 _c.Call.Return(run)
1786 return _c
1787}
1788
1789// ListRoutesWithDetails provides a mock function for the type MockControlPlane
1790func (_mock *MockControlPlane) ListRoutesWithDetails(ctx context.Context) ([]remote.RouteInfo, error) {
1791 ret := _mock.Called(ctx)
1792
1793 if len(ret) == 0 {
1794 panic("no return value specified for ListRoutesWithDetails")
1795 }
1796
1797 var r0 []remote.RouteInfo
1798 var r1 error
1799 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]remote.RouteInfo, error)); ok {
1800 return returnFunc(ctx)
1801 }
1802 if returnFunc, ok := ret.Get(0).(func(context.Context) []remote.RouteInfo); ok {
1803 r0 = returnFunc(ctx)
1804 } else {
1805 if ret.Get(0) != nil {
1806 r0 = ret.Get(0).([]remote.RouteInfo)
1807 }
1808 }
1809 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1810 r1 = returnFunc(ctx)
1811 } else {
1812 r1 = ret.Error(1)
1813 }
1814 return r0, r1
1815}
1816
1817// MockControlPlane_ListRoutesWithDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRoutesWithDetails'
1818type MockControlPlane_ListRoutesWithDetails_Call struct {
1819 *mock.Call
1820}
1821
1822// ListRoutesWithDetails is a helper method to define mock.On call
1823// - ctx context.Context
1824func (_e *MockControlPlane_Expecter) ListRoutesWithDetails(ctx any) *MockControlPlane_ListRoutesWithDetails_Call {
1825 return &MockControlPlane_ListRoutesWithDetails_Call{Call: _e.mock.On("ListRoutesWithDetails", ctx)}
1826}
1827
1828func (_c *MockControlPlane_ListRoutesWithDetails_Call) Run(run func(ctx context.Context)) *MockControlPlane_ListRoutesWithDetails_Call {
1829 _c.Call.Run(func(args mock.Arguments) {
1830 var arg0 context.Context
1831 if args[0] != nil {
1832 arg0 = args[0].(context.Context)
1833 }
1834 run(
1835 arg0,
1836 )
1837 })
1838 return _c
1839}
1840
1841func (_c *MockControlPlane_ListRoutesWithDetails_Call) Return(vs []remote.RouteInfo, err error) *MockControlPlane_ListRoutesWithDetails_Call {
1842 _c.Call.Return(vs, err)
1843 return _c
1844}
1845
1846func (_c *MockControlPlane_ListRoutesWithDetails_Call) RunAndReturn(run func(ctx context.Context) ([]remote.RouteInfo, error)) *MockControlPlane_ListRoutesWithDetails_Call {
1847 _c.Call.Return(run)
1848 return _c
1849}
1850
1851// ListSecretsWithAttachments provides a mock function for the type MockControlPlane
1852func (_mock *MockControlPlane) ListSecretsWithAttachments(ctx context.Context, secretDomain string) (*remote.SecretsListResult, error) {
1853 ret := _mock.Called(ctx, secretDomain)
1854
1855 if len(ret) == 0 {
1856 panic("no return value specified for ListSecretsWithAttachments")
1857 }
1858
1859 var r0 *remote.SecretsListResult
1860 var r1 error
1861 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*remote.SecretsListResult, error)); ok {
1862 return returnFunc(ctx, secretDomain)
1863 }
1864 if returnFunc, ok := ret.Get(0).(func(context.Context, string) *remote.SecretsListResult); ok {
1865 r0 = returnFunc(ctx, secretDomain)
1866 } else {
1867 if ret.Get(0) != nil {
1868 r0 = ret.Get(0).(*remote.SecretsListResult)
1869 }
1870 }
1871 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
1872 r1 = returnFunc(ctx, secretDomain)
1873 } else {
1874 r1 = ret.Error(1)
1875 }
1876 return r0, r1
1877}
1878
1879// MockControlPlane_ListSecretsWithAttachments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSecretsWithAttachments'
1880type MockControlPlane_ListSecretsWithAttachments_Call struct {
1881 *mock.Call
1882}
1883
1884// ListSecretsWithAttachments is a helper method to define mock.On call
1885// - ctx context.Context
1886// - secretDomain string
1887func (_e *MockControlPlane_Expecter) ListSecretsWithAttachments(ctx any, secretDomain any) *MockControlPlane_ListSecretsWithAttachments_Call {
1888 return &MockControlPlane_ListSecretsWithAttachments_Call{Call: _e.mock.On("ListSecretsWithAttachments", ctx, secretDomain)}
1889}
1890
1891func (_c *MockControlPlane_ListSecretsWithAttachments_Call) Run(run func(ctx context.Context, secretDomain string)) *MockControlPlane_ListSecretsWithAttachments_Call {
1892 _c.Call.Run(func(args mock.Arguments) {
1893 var arg0 context.Context
1894 if args[0] != nil {
1895 arg0 = args[0].(context.Context)
1896 }
1897 var arg1 string
1898 if args[1] != nil {
1899 arg1 = args[1].(string)
1900 }
1901 run(
1902 arg0,
1903 arg1,
1904 )
1905 })
1906 return _c
1907}
1908
1909func (_c *MockControlPlane_ListSecretsWithAttachments_Call) Return(secretsListResult *remote.SecretsListResult, err error) *MockControlPlane_ListSecretsWithAttachments_Call {
1910 _c.Call.Return(secretsListResult, err)
1911 return _c
1912}
1913
1914func (_c *MockControlPlane_ListSecretsWithAttachments_Call) RunAndReturn(run func(ctx context.Context, secretDomain string) (*remote.SecretsListResult, error)) *MockControlPlane_ListSecretsWithAttachments_Call {
1915 _c.Call.Return(run)
1916 return _c
1917}
1918
1919// ListTags provides a mock function for the type MockControlPlane
1920func (_mock *MockControlPlane) ListTags(ctx context.Context, repository string) ([]string, error) {
1921 ret := _mock.Called(ctx, repository)
1922
1923 if len(ret) == 0 {
1924 panic("no return value specified for ListTags")
1925 }
1926
1927 var r0 []string
1928 var r1 error
1929 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]string, error)); ok {
1930 return returnFunc(ctx, repository)
1931 }
1932 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []string); ok {
1933 r0 = returnFunc(ctx, repository)
1934 } else {
1935 if ret.Get(0) != nil {
1936 r0 = ret.Get(0).([]string)
1937 }
1938 }
1939 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
1940 r1 = returnFunc(ctx, repository)
1941 } else {
1942 r1 = ret.Error(1)
1943 }
1944 return r0, r1
1945}
1946
1947// MockControlPlane_ListTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTags'
1948type MockControlPlane_ListTags_Call struct {
1949 *mock.Call
1950}
1951
1952// ListTags is a helper method to define mock.On call
1953// - ctx context.Context
1954// - repository string
1955func (_e *MockControlPlane_Expecter) ListTags(ctx any, repository any) *MockControlPlane_ListTags_Call {
1956 return &MockControlPlane_ListTags_Call{Call: _e.mock.On("ListTags", ctx, repository)}
1957}
1958
1959func (_c *MockControlPlane_ListTags_Call) Run(run func(ctx context.Context, repository string)) *MockControlPlane_ListTags_Call {
1960 _c.Call.Run(func(args mock.Arguments) {
1961 var arg0 context.Context
1962 if args[0] != nil {
1963 arg0 = args[0].(context.Context)
1964 }
1965 var arg1 string
1966 if args[1] != nil {
1967 arg1 = args[1].(string)
1968 }
1969 run(
1970 arg0,
1971 arg1,
1972 )
1973 })
1974 return _c
1975}
1976
1977func (_c *MockControlPlane_ListTags_Call) Return(strings []string, err error) *MockControlPlane_ListTags_Call {
1978 _c.Call.Return(strings, err)
1979 return _c
1980}
1981
1982func (_c *MockControlPlane_ListTags_Call) RunAndReturn(run func(ctx context.Context, repository string) ([]string, error)) *MockControlPlane_ListTags_Call {
1983 _c.Call.Return(run)
1984 return _c
1985}
1986
1987// ListVolumeBackups provides a mock function for the type MockControlPlane
1988func (_mock *MockControlPlane) ListVolumeBackups(ctx context.Context, backupDomain string) ([]dto.VolumeBackupJob, error) {
1989 ret := _mock.Called(ctx, backupDomain)
1990
1991 if len(ret) == 0 {
1992 panic("no return value specified for ListVolumeBackups")
1993 }
1994
1995 var r0 []dto.VolumeBackupJob
1996 var r1 error
1997 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]dto.VolumeBackupJob, error)); ok {
1998 return returnFunc(ctx, backupDomain)
1999 }
2000 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []dto.VolumeBackupJob); ok {
2001 r0 = returnFunc(ctx, backupDomain)
2002 } else {
2003 if ret.Get(0) != nil {
2004 r0 = ret.Get(0).([]dto.VolumeBackupJob)
2005 }
2006 }
2007 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
2008 r1 = returnFunc(ctx, backupDomain)
2009 } else {
2010 r1 = ret.Error(1)
2011 }
2012 return r0, r1
2013}
2014
2015// MockControlPlane_ListVolumeBackups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVolumeBackups'
2016type MockControlPlane_ListVolumeBackups_Call struct {
2017 *mock.Call
2018}
2019
2020// ListVolumeBackups is a helper method to define mock.On call
2021// - ctx context.Context
2022// - backupDomain string
2023func (_e *MockControlPlane_Expecter) ListVolumeBackups(ctx any, backupDomain any) *MockControlPlane_ListVolumeBackups_Call {
2024 return &MockControlPlane_ListVolumeBackups_Call{Call: _e.mock.On("ListVolumeBackups", ctx, backupDomain)}
2025}
2026
2027func (_c *MockControlPlane_ListVolumeBackups_Call) Run(run func(ctx context.Context, backupDomain string)) *MockControlPlane_ListVolumeBackups_Call {
2028 _c.Call.Run(func(args mock.Arguments) {
2029 var arg0 context.Context
2030 if args[0] != nil {
2031 arg0 = args[0].(context.Context)
2032 }
2033 var arg1 string
2034 if args[1] != nil {
2035 arg1 = args[1].(string)
2036 }
2037 run(
2038 arg0,
2039 arg1,
2040 )
2041 })
2042 return _c
2043}
2044
2045func (_c *MockControlPlane_ListVolumeBackups_Call) Return(volumeBackupJobs []dto.VolumeBackupJob, err error) *MockControlPlane_ListVolumeBackups_Call {
2046 _c.Call.Return(volumeBackupJobs, err)
2047 return _c
2048}
2049
2050func (_c *MockControlPlane_ListVolumeBackups_Call) RunAndReturn(run func(ctx context.Context, backupDomain string) ([]dto.VolumeBackupJob, error)) *MockControlPlane_ListVolumeBackups_Call {
2051 _c.Call.Return(run)
2052 return _c
2053}
2054
2055// ListVolumes provides a mock function for the type MockControlPlane
2056func (_mock *MockControlPlane) ListVolumes(ctx context.Context) ([]dto.Volume, error) {
2057 ret := _mock.Called(ctx)
2058
2059 if len(ret) == 0 {
2060 panic("no return value specified for ListVolumes")
2061 }
2062
2063 var r0 []dto.Volume
2064 var r1 error
2065 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]dto.Volume, error)); ok {
2066 return returnFunc(ctx)
2067 }
2068 if returnFunc, ok := ret.Get(0).(func(context.Context) []dto.Volume); ok {
2069 r0 = returnFunc(ctx)
2070 } else {
2071 if ret.Get(0) != nil {
2072 r0 = ret.Get(0).([]dto.Volume)
2073 }
2074 }
2075 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
2076 r1 = returnFunc(ctx)
2077 } else {
2078 r1 = ret.Error(1)
2079 }
2080 return r0, r1
2081}
2082
2083// MockControlPlane_ListVolumes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVolumes'
2084type MockControlPlane_ListVolumes_Call struct {
2085 *mock.Call
2086}
2087
2088// ListVolumes is a helper method to define mock.On call
2089// - ctx context.Context
2090func (_e *MockControlPlane_Expecter) ListVolumes(ctx any) *MockControlPlane_ListVolumes_Call {
2091 return &MockControlPlane_ListVolumes_Call{Call: _e.mock.On("ListVolumes", ctx)}
2092}
2093
2094func (_c *MockControlPlane_ListVolumes_Call) Run(run func(ctx context.Context)) *MockControlPlane_ListVolumes_Call {
2095 _c.Call.Run(func(args mock.Arguments) {
2096 var arg0 context.Context
2097 if args[0] != nil {
2098 arg0 = args[0].(context.Context)
2099 }
2100 run(
2101 arg0,
2102 )
2103 })
2104 return _c
2105}
2106
2107func (_c *MockControlPlane_ListVolumes_Call) Return(volumes []dto.Volume, err error) *MockControlPlane_ListVolumes_Call {
2108 _c.Call.Return(volumes, err)
2109 return _c
2110}
2111
2112func (_c *MockControlPlane_ListVolumes_Call) RunAndReturn(run func(ctx context.Context) ([]dto.Volume, error)) *MockControlPlane_ListVolumes_Call {
2113 _c.Call.Return(run)
2114 return _c
2115}
2116
2117// PruneVolumes provides a mock function for the type MockControlPlane
2118func (_mock *MockControlPlane) PruneVolumes(ctx context.Context, req dto.VolumePruneRequest) (*dto.VolumePruneResponse, error) {
2119 ret := _mock.Called(ctx, req)
2120
2121 if len(ret) == 0 {
2122 panic("no return value specified for PruneVolumes")
2123 }
2124
2125 var r0 *dto.VolumePruneResponse
2126 var r1 error
2127 if returnFunc, ok := ret.Get(0).(func(context.Context, dto.VolumePruneRequest) (*dto.VolumePruneResponse, error)); ok {
2128 return returnFunc(ctx, req)
2129 }
2130 if returnFunc, ok := ret.Get(0).(func(context.Context, dto.VolumePruneRequest) *dto.VolumePruneResponse); ok {
2131 r0 = returnFunc(ctx, req)
2132 } else {
2133 if ret.Get(0) != nil {
2134 r0 = ret.Get(0).(*dto.VolumePruneResponse)
2135 }
2136 }
2137 if returnFunc, ok := ret.Get(1).(func(context.Context, dto.VolumePruneRequest) error); ok {
2138 r1 = returnFunc(ctx, req)
2139 } else {
2140 r1 = ret.Error(1)
2141 }
2142 return r0, r1
2143}
2144
2145// MockControlPlane_PruneVolumes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PruneVolumes'
2146type MockControlPlane_PruneVolumes_Call struct {
2147 *mock.Call
2148}
2149
2150// PruneVolumes is a helper method to define mock.On call
2151// - ctx context.Context
2152// - req dto.VolumePruneRequest
2153func (_e *MockControlPlane_Expecter) PruneVolumes(ctx any, req any) *MockControlPlane_PruneVolumes_Call {
2154 return &MockControlPlane_PruneVolumes_Call{Call: _e.mock.On("PruneVolumes", ctx, req)}
2155}
2156
2157func (_c *MockControlPlane_PruneVolumes_Call) Run(run func(ctx context.Context, req dto.VolumePruneRequest)) *MockControlPlane_PruneVolumes_Call {
2158 _c.Call.Run(func(args mock.Arguments) {
2159 var arg0 context.Context
2160 if args[0] != nil {
2161 arg0 = args[0].(context.Context)
2162 }
2163 var arg1 dto.VolumePruneRequest
2164 if args[1] != nil {
2165 arg1 = args[1].(dto.VolumePruneRequest)
2166 }
2167 run(
2168 arg0,
2169 arg1,
2170 )
2171 })
2172 return _c
2173}
2174
2175func (_c *MockControlPlane_PruneVolumes_Call) Return(volumePruneResponse *dto.VolumePruneResponse, err error) *MockControlPlane_PruneVolumes_Call {
2176 _c.Call.Return(volumePruneResponse, err)
2177 return _c
2178}
2179
2180func (_c *MockControlPlane_PruneVolumes_Call) RunAndReturn(run func(ctx context.Context, req dto.VolumePruneRequest) (*dto.VolumePruneResponse, error)) *MockControlPlane_PruneVolumes_Call {
2181 _c.Call.Return(run)
2182 return _c
2183}
2184
2185// Reload provides a mock function for the type MockControlPlane
2186func (_mock *MockControlPlane) Reload(ctx context.Context) error {
2187 ret := _mock.Called(ctx)
2188
2189 if len(ret) == 0 {
2190 panic("no return value specified for Reload")
2191 }
2192
2193 var r0 error
2194 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
2195 r0 = returnFunc(ctx)
2196 } else {
2197 r0 = ret.Error(0)
2198 }
2199 return r0
2200}
2201
2202// MockControlPlane_Reload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reload'
2203type MockControlPlane_Reload_Call struct {
2204 *mock.Call
2205}
2206
2207// Reload is a helper method to define mock.On call
2208// - ctx context.Context
2209func (_e *MockControlPlane_Expecter) Reload(ctx any) *MockControlPlane_Reload_Call {
2210 return &MockControlPlane_Reload_Call{Call: _e.mock.On("Reload", ctx)}
2211}
2212
2213func (_c *MockControlPlane_Reload_Call) Run(run func(ctx context.Context)) *MockControlPlane_Reload_Call {
2214 _c.Call.Run(func(args mock.Arguments) {
2215 var arg0 context.Context
2216 if args[0] != nil {
2217 arg0 = args[0].(context.Context)
2218 }
2219 run(
2220 arg0,
2221 )
2222 })
2223 return _c
2224}
2225
2226func (_c *MockControlPlane_Reload_Call) Return(err error) *MockControlPlane_Reload_Call {
2227 _c.Call.Return(err)
2228 return _c
2229}
2230
2231func (_c *MockControlPlane_Reload_Call) RunAndReturn(run func(ctx context.Context) error) *MockControlPlane_Reload_Call {
2232 _c.Call.Return(run)
2233 return _c
2234}
2235
2236// RemoveAttachment provides a mock function for the type MockControlPlane
2237func (_mock *MockControlPlane) RemoveAttachment(ctx context.Context, domainOrGroup string, image string) error {
2238 ret := _mock.Called(ctx, domainOrGroup, image)
2239
2240 if len(ret) == 0 {
2241 panic("no return value specified for RemoveAttachment")
2242 }
2243
2244 var r0 error
2245 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
2246 r0 = returnFunc(ctx, domainOrGroup, image)
2247 } else {
2248 r0 = ret.Error(0)
2249 }
2250 return r0
2251}
2252
2253// MockControlPlane_RemoveAttachment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAttachment'
2254type MockControlPlane_RemoveAttachment_Call struct {
2255 *mock.Call
2256}
2257
2258// RemoveAttachment is a helper method to define mock.On call
2259// - ctx context.Context
2260// - domainOrGroup string
2261// - image string
2262func (_e *MockControlPlane_Expecter) RemoveAttachment(ctx any, domainOrGroup any, image any) *MockControlPlane_RemoveAttachment_Call {
2263 return &MockControlPlane_RemoveAttachment_Call{Call: _e.mock.On("RemoveAttachment", ctx, domainOrGroup, image)}
2264}
2265
2266func (_c *MockControlPlane_RemoveAttachment_Call) Run(run func(ctx context.Context, domainOrGroup string, image string)) *MockControlPlane_RemoveAttachment_Call {
2267 _c.Call.Run(func(args mock.Arguments) {
2268 var arg0 context.Context
2269 if args[0] != nil {
2270 arg0 = args[0].(context.Context)
2271 }
2272 var arg1 string
2273 if args[1] != nil {
2274 arg1 = args[1].(string)
2275 }
2276 var arg2 string
2277 if args[2] != nil {
2278 arg2 = args[2].(string)
2279 }
2280 run(
2281 arg0,
2282 arg1,
2283 arg2,
2284 )
2285 })
2286 return _c
2287}
2288
2289func (_c *MockControlPlane_RemoveAttachment_Call) Return(err error) *MockControlPlane_RemoveAttachment_Call {
2290 _c.Call.Return(err)
2291 return _c
2292}
2293
2294func (_c *MockControlPlane_RemoveAttachment_Call) RunAndReturn(run func(ctx context.Context, domainOrGroup string, image string) error) *MockControlPlane_RemoveAttachment_Call {
2295 _c.Call.Return(run)
2296 return _c
2297}
2298
2299// RemoveAutoRouteAllowedDomain provides a mock function for the type MockControlPlane
2300func (_mock *MockControlPlane) RemoveAutoRouteAllowedDomain(ctx context.Context, pattern string) error {
2301 ret := _mock.Called(ctx, pattern)
2302
2303 if len(ret) == 0 {
2304 panic("no return value specified for RemoveAutoRouteAllowedDomain")
2305 }
2306
2307 var r0 error
2308 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
2309 r0 = returnFunc(ctx, pattern)
2310 } else {
2311 r0 = ret.Error(0)
2312 }
2313 return r0
2314}
2315
2316// MockControlPlane_RemoveAutoRouteAllowedDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAutoRouteAllowedDomain'
2317type MockControlPlane_RemoveAutoRouteAllowedDomain_Call struct {
2318 *mock.Call
2319}
2320
2321// RemoveAutoRouteAllowedDomain is a helper method to define mock.On call
2322// - ctx context.Context
2323// - pattern string
2324func (_e *MockControlPlane_Expecter) RemoveAutoRouteAllowedDomain(ctx any, pattern any) *MockControlPlane_RemoveAutoRouteAllowedDomain_Call {
2325 return &MockControlPlane_RemoveAutoRouteAllowedDomain_Call{Call: _e.mock.On("RemoveAutoRouteAllowedDomain", ctx, pattern)}
2326}
2327
2328func (_c *MockControlPlane_RemoveAutoRouteAllowedDomain_Call) Run(run func(ctx context.Context, pattern string)) *MockControlPlane_RemoveAutoRouteAllowedDomain_Call {
2329 _c.Call.Run(func(args mock.Arguments) {
2330 var arg0 context.Context
2331 if args[0] != nil {
2332 arg0 = args[0].(context.Context)
2333 }
2334 var arg1 string
2335 if args[1] != nil {
2336 arg1 = args[1].(string)
2337 }
2338 run(
2339 arg0,
2340 arg1,
2341 )
2342 })
2343 return _c
2344}
2345
2346func (_c *MockControlPlane_RemoveAutoRouteAllowedDomain_Call) Return(err error) *MockControlPlane_RemoveAutoRouteAllowedDomain_Call {
2347 _c.Call.Return(err)
2348 return _c
2349}
2350
2351func (_c *MockControlPlane_RemoveAutoRouteAllowedDomain_Call) RunAndReturn(run func(ctx context.Context, pattern string) error) *MockControlPlane_RemoveAutoRouteAllowedDomain_Call {
2352 _c.Call.Return(run)
2353 return _c
2354}
2355
2356// RemoveRoute provides a mock function for the type MockControlPlane
2357func (_mock *MockControlPlane) RemoveRoute(ctx context.Context, routeDomain string) error {
2358 ret := _mock.Called(ctx, routeDomain)
2359
2360 if len(ret) == 0 {
2361 panic("no return value specified for RemoveRoute")
2362 }
2363
2364 var r0 error
2365 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
2366 r0 = returnFunc(ctx, routeDomain)
2367 } else {
2368 r0 = ret.Error(0)
2369 }
2370 return r0
2371}
2372
2373// MockControlPlane_RemoveRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRoute'
2374type MockControlPlane_RemoveRoute_Call struct {
2375 *mock.Call
2376}
2377
2378// RemoveRoute is a helper method to define mock.On call
2379// - ctx context.Context
2380// - routeDomain string
2381func (_e *MockControlPlane_Expecter) RemoveRoute(ctx any, routeDomain any) *MockControlPlane_RemoveRoute_Call {
2382 return &MockControlPlane_RemoveRoute_Call{Call: _e.mock.On("RemoveRoute", ctx, routeDomain)}
2383}
2384
2385func (_c *MockControlPlane_RemoveRoute_Call) Run(run func(ctx context.Context, routeDomain string)) *MockControlPlane_RemoveRoute_Call {
2386 _c.Call.Run(func(args mock.Arguments) {
2387 var arg0 context.Context
2388 if args[0] != nil {
2389 arg0 = args[0].(context.Context)
2390 }
2391 var arg1 string
2392 if args[1] != nil {
2393 arg1 = args[1].(string)
2394 }
2395 run(
2396 arg0,
2397 arg1,
2398 )
2399 })
2400 return _c
2401}
2402
2403func (_c *MockControlPlane_RemoveRoute_Call) Return(err error) *MockControlPlane_RemoveRoute_Call {
2404 _c.Call.Return(err)
2405 return _c
2406}
2407
2408func (_c *MockControlPlane_RemoveRoute_Call) RunAndReturn(run func(ctx context.Context, routeDomain string) error) *MockControlPlane_RemoveRoute_Call {
2409 _c.Call.Return(run)
2410 return _c
2411}
2412
2413// Restart provides a mock function for the type MockControlPlane
2414func (_mock *MockControlPlane) Restart(ctx context.Context, restartDomain string, withAttachments bool) (*remote.RestartResult, error) {
2415 ret := _mock.Called(ctx, restartDomain, withAttachments)
2416
2417 if len(ret) == 0 {
2418 panic("no return value specified for Restart")
2419 }
2420
2421 var r0 *remote.RestartResult
2422 var r1 error
2423 if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) (*remote.RestartResult, error)); ok {
2424 return returnFunc(ctx, restartDomain, withAttachments)
2425 }
2426 if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) *remote.RestartResult); ok {
2427 r0 = returnFunc(ctx, restartDomain, withAttachments)
2428 } else {
2429 if ret.Get(0) != nil {
2430 r0 = ret.Get(0).(*remote.RestartResult)
2431 }
2432 }
2433 if returnFunc, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
2434 r1 = returnFunc(ctx, restartDomain, withAttachments)
2435 } else {
2436 r1 = ret.Error(1)
2437 }
2438 return r0, r1
2439}
2440
2441// MockControlPlane_Restart_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Restart'
2442type MockControlPlane_Restart_Call struct {
2443 *mock.Call
2444}
2445
2446// Restart is a helper method to define mock.On call
2447// - ctx context.Context
2448// - restartDomain string
2449// - withAttachments bool
2450func (_e *MockControlPlane_Expecter) Restart(ctx any, restartDomain any, withAttachments any) *MockControlPlane_Restart_Call {
2451 return &MockControlPlane_Restart_Call{Call: _e.mock.On("Restart", ctx, restartDomain, withAttachments)}
2452}
2453
2454func (_c *MockControlPlane_Restart_Call) Run(run func(ctx context.Context, restartDomain string, withAttachments bool)) *MockControlPlane_Restart_Call {
2455 _c.Call.Run(func(args mock.Arguments) {
2456 var arg0 context.Context
2457 if args[0] != nil {
2458 arg0 = args[0].(context.Context)
2459 }
2460 var arg1 string
2461 if args[1] != nil {
2462 arg1 = args[1].(string)
2463 }
2464 var arg2 bool
2465 if args[2] != nil {
2466 arg2 = args[2].(bool)
2467 }
2468 run(
2469 arg0,
2470 arg1,
2471 arg2,
2472 )
2473 })
2474 return _c
2475}
2476
2477func (_c *MockControlPlane_Restart_Call) Return(restartResult *remote.RestartResult, err error) *MockControlPlane_Restart_Call {
2478 _c.Call.Return(restartResult, err)
2479 return _c
2480}
2481
2482func (_c *MockControlPlane_Restart_Call) RunAndReturn(run func(ctx context.Context, restartDomain string, withAttachments bool) (*remote.RestartResult, error)) *MockControlPlane_Restart_Call {
2483 _c.Call.Return(run)
2484 return _c
2485}
2486
2487// RunBackup provides a mock function for the type MockControlPlane
2488func (_mock *MockControlPlane) RunBackup(ctx context.Context, backupDomain string, dbName string) (*dto.BackupRunResponse, error) {
2489 ret := _mock.Called(ctx, backupDomain, dbName)
2490
2491 if len(ret) == 0 {
2492 panic("no return value specified for RunBackup")
2493 }
2494
2495 var r0 *dto.BackupRunResponse
2496 var r1 error
2497 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*dto.BackupRunResponse, error)); ok {
2498 return returnFunc(ctx, backupDomain, dbName)
2499 }
2500 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *dto.BackupRunResponse); ok {
2501 r0 = returnFunc(ctx, backupDomain, dbName)
2502 } else {
2503 if ret.Get(0) != nil {
2504 r0 = ret.Get(0).(*dto.BackupRunResponse)
2505 }
2506 }
2507 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
2508 r1 = returnFunc(ctx, backupDomain, dbName)
2509 } else {
2510 r1 = ret.Error(1)
2511 }
2512 return r0, r1
2513}
2514
2515// MockControlPlane_RunBackup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunBackup'
2516type MockControlPlane_RunBackup_Call struct {
2517 *mock.Call
2518}
2519
2520// RunBackup is a helper method to define mock.On call
2521// - ctx context.Context
2522// - backupDomain string
2523// - dbName string
2524func (_e *MockControlPlane_Expecter) RunBackup(ctx any, backupDomain any, dbName any) *MockControlPlane_RunBackup_Call {
2525 return &MockControlPlane_RunBackup_Call{Call: _e.mock.On("RunBackup", ctx, backupDomain, dbName)}
2526}
2527
2528func (_c *MockControlPlane_RunBackup_Call) Run(run func(ctx context.Context, backupDomain string, dbName string)) *MockControlPlane_RunBackup_Call {
2529 _c.Call.Run(func(args mock.Arguments) {
2530 var arg0 context.Context
2531 if args[0] != nil {
2532 arg0 = args[0].(context.Context)
2533 }
2534 var arg1 string
2535 if args[1] != nil {
2536 arg1 = args[1].(string)
2537 }
2538 var arg2 string
2539 if args[2] != nil {
2540 arg2 = args[2].(string)
2541 }
2542 run(
2543 arg0,
2544 arg1,
2545 arg2,
2546 )
2547 })
2548 return _c
2549}
2550
2551func (_c *MockControlPlane_RunBackup_Call) Return(backupRunResponse *dto.BackupRunResponse, err error) *MockControlPlane_RunBackup_Call {
2552 _c.Call.Return(backupRunResponse, err)
2553 return _c
2554}
2555
2556func (_c *MockControlPlane_RunBackup_Call) RunAndReturn(run func(ctx context.Context, backupDomain string, dbName string) (*dto.BackupRunResponse, error)) *MockControlPlane_RunBackup_Call {
2557 _c.Call.Return(run)
2558 return _c
2559}
2560
2561// RunVolumeBackups provides a mock function for the type MockControlPlane
2562func (_mock *MockControlPlane) RunVolumeBackups(ctx context.Context, backupDomain string, volumeName string) (*dto.VolumeBackupRunResponse, error) {
2563 ret := _mock.Called(ctx, backupDomain, volumeName)
2564
2565 if len(ret) == 0 {
2566 panic("no return value specified for RunVolumeBackups")
2567 }
2568
2569 var r0 *dto.VolumeBackupRunResponse
2570 var r1 error
2571 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*dto.VolumeBackupRunResponse, error)); ok {
2572 return returnFunc(ctx, backupDomain, volumeName)
2573 }
2574 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *dto.VolumeBackupRunResponse); ok {
2575 r0 = returnFunc(ctx, backupDomain, volumeName)
2576 } else {
2577 if ret.Get(0) != nil {
2578 r0 = ret.Get(0).(*dto.VolumeBackupRunResponse)
2579 }
2580 }
2581 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
2582 r1 = returnFunc(ctx, backupDomain, volumeName)
2583 } else {
2584 r1 = ret.Error(1)
2585 }
2586 return r0, r1
2587}
2588
2589// MockControlPlane_RunVolumeBackups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunVolumeBackups'
2590type MockControlPlane_RunVolumeBackups_Call struct {
2591 *mock.Call
2592}
2593
2594// RunVolumeBackups is a helper method to define mock.On call
2595// - ctx context.Context
2596// - backupDomain string
2597// - volumeName string
2598func (_e *MockControlPlane_Expecter) RunVolumeBackups(ctx any, backupDomain any, volumeName any) *MockControlPlane_RunVolumeBackups_Call {
2599 return &MockControlPlane_RunVolumeBackups_Call{Call: _e.mock.On("RunVolumeBackups", ctx, backupDomain, volumeName)}
2600}
2601
2602func (_c *MockControlPlane_RunVolumeBackups_Call) Run(run func(ctx context.Context, backupDomain string, volumeName string)) *MockControlPlane_RunVolumeBackups_Call {
2603 _c.Call.Run(func(args mock.Arguments) {
2604 var arg0 context.Context
2605 if args[0] != nil {
2606 arg0 = args[0].(context.Context)
2607 }
2608 var arg1 string
2609 if args[1] != nil {
2610 arg1 = args[1].(string)
2611 }
2612 var arg2 string
2613 if args[2] != nil {
2614 arg2 = args[2].(string)
2615 }
2616 run(
2617 arg0,
2618 arg1,
2619 arg2,
2620 )
2621 })
2622 return _c
2623}
2624
2625func (_c *MockControlPlane_RunVolumeBackups_Call) Return(volumeBackupRunResponse *dto.VolumeBackupRunResponse, err error) *MockControlPlane_RunVolumeBackups_Call {
2626 _c.Call.Return(volumeBackupRunResponse, err)
2627 return _c
2628}
2629
2630func (_c *MockControlPlane_RunVolumeBackups_Call) RunAndReturn(run func(ctx context.Context, backupDomain string, volumeName string) (*dto.VolumeBackupRunResponse, error)) *MockControlPlane_RunVolumeBackups_Call {
2631 _c.Call.Return(run)
2632 return _c
2633}
2634
2635// SetAttachmentSecrets provides a mock function for the type MockControlPlane
2636func (_mock *MockControlPlane) SetAttachmentSecrets(ctx context.Context, domain1 string, service string, secrets map[string]string) error {
2637 ret := _mock.Called(ctx, domain1, service, secrets)
2638
2639 if len(ret) == 0 {
2640 panic("no return value specified for SetAttachmentSecrets")
2641 }
2642
2643 var r0 error
2644 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, map[string]string) error); ok {
2645 r0 = returnFunc(ctx, domain1, service, secrets)
2646 } else {
2647 r0 = ret.Error(0)
2648 }
2649 return r0
2650}
2651
2652// MockControlPlane_SetAttachmentSecrets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetAttachmentSecrets'
2653type MockControlPlane_SetAttachmentSecrets_Call struct {
2654 *mock.Call
2655}
2656
2657// SetAttachmentSecrets is a helper method to define mock.On call
2658// - ctx context.Context
2659// - domain1 string
2660// - service string
2661// - secrets map[string]string
2662func (_e *MockControlPlane_Expecter) SetAttachmentSecrets(ctx any, domain1 any, service any, secrets any) *MockControlPlane_SetAttachmentSecrets_Call {
2663 return &MockControlPlane_SetAttachmentSecrets_Call{Call: _e.mock.On("SetAttachmentSecrets", ctx, domain1, service, secrets)}
2664}
2665
2666func (_c *MockControlPlane_SetAttachmentSecrets_Call) Run(run func(ctx context.Context, domain1 string, service string, secrets map[string]string)) *MockControlPlane_SetAttachmentSecrets_Call {
2667 _c.Call.Run(func(args mock.Arguments) {
2668 var arg0 context.Context
2669 if args[0] != nil {
2670 arg0 = args[0].(context.Context)
2671 }
2672 var arg1 string
2673 if args[1] != nil {
2674 arg1 = args[1].(string)
2675 }
2676 var arg2 string
2677 if args[2] != nil {
2678 arg2 = args[2].(string)
2679 }
2680 var arg3 map[string]string
2681 if args[3] != nil {
2682 arg3 = args[3].(map[string]string)
2683 }
2684 run(
2685 arg0,
2686 arg1,
2687 arg2,
2688 arg3,
2689 )
2690 })
2691 return _c
2692}
2693
2694func (_c *MockControlPlane_SetAttachmentSecrets_Call) Return(err error) *MockControlPlane_SetAttachmentSecrets_Call {
2695 _c.Call.Return(err)
2696 return _c
2697}
2698
2699func (_c *MockControlPlane_SetAttachmentSecrets_Call) RunAndReturn(run func(ctx context.Context, domain1 string, service string, secrets map[string]string) error) *MockControlPlane_SetAttachmentSecrets_Call {
2700 _c.Call.Return(run)
2701 return _c
2702}
2703
2704// SetSecrets provides a mock function for the type MockControlPlane
2705func (_mock *MockControlPlane) SetSecrets(ctx context.Context, secretDomain string, secrets map[string]string) error {
2706 ret := _mock.Called(ctx, secretDomain, secrets)
2707
2708 if len(ret) == 0 {
2709 panic("no return value specified for SetSecrets")
2710 }
2711
2712 var r0 error
2713 if returnFunc, ok := ret.Get(0).(func(context.Context, string, map[string]string) error); ok {
2714 r0 = returnFunc(ctx, secretDomain, secrets)
2715 } else {
2716 r0 = ret.Error(0)
2717 }
2718 return r0
2719}
2720
2721// MockControlPlane_SetSecrets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSecrets'
2722type MockControlPlane_SetSecrets_Call struct {
2723 *mock.Call
2724}
2725
2726// SetSecrets is a helper method to define mock.On call
2727// - ctx context.Context
2728// - secretDomain string
2729// - secrets map[string]string
2730func (_e *MockControlPlane_Expecter) SetSecrets(ctx any, secretDomain any, secrets any) *MockControlPlane_SetSecrets_Call {
2731 return &MockControlPlane_SetSecrets_Call{Call: _e.mock.On("SetSecrets", ctx, secretDomain, secrets)}
2732}
2733
2734func (_c *MockControlPlane_SetSecrets_Call) Run(run func(ctx context.Context, secretDomain string, secrets map[string]string)) *MockControlPlane_SetSecrets_Call {
2735 _c.Call.Run(func(args mock.Arguments) {
2736 var arg0 context.Context
2737 if args[0] != nil {
2738 arg0 = args[0].(context.Context)
2739 }
2740 var arg1 string
2741 if args[1] != nil {
2742 arg1 = args[1].(string)
2743 }
2744 var arg2 map[string]string
2745 if args[2] != nil {
2746 arg2 = args[2].(map[string]string)
2747 }
2748 run(
2749 arg0,
2750 arg1,
2751 arg2,
2752 )
2753 })
2754 return _c
2755}
2756
2757func (_c *MockControlPlane_SetSecrets_Call) Return(err error) *MockControlPlane_SetSecrets_Call {
2758 _c.Call.Return(err)
2759 return _c
2760}
2761
2762func (_c *MockControlPlane_SetSecrets_Call) RunAndReturn(run func(ctx context.Context, secretDomain string, secrets map[string]string) error) *MockControlPlane_SetSecrets_Call {
2763 _c.Call.Return(run)
2764 return _c
2765}
2766
2767// StreamContainerLogs provides a mock function for the type MockControlPlane
2768func (_mock *MockControlPlane) StreamContainerLogs(ctx context.Context, logDomain string, lines int) (<-chan string, error) {
2769 ret := _mock.Called(ctx, logDomain, lines)
2770
2771 if len(ret) == 0 {
2772 panic("no return value specified for StreamContainerLogs")
2773 }
2774
2775 var r0 <-chan string
2776 var r1 error
2777 if returnFunc, ok := ret.Get(0).(func(context.Context, string, int) (<-chan string, error)); ok {
2778 return returnFunc(ctx, logDomain, lines)
2779 }
2780 if returnFunc, ok := ret.Get(0).(func(context.Context, string, int) <-chan string); ok {
2781 r0 = returnFunc(ctx, logDomain, lines)
2782 } else {
2783 if ret.Get(0) != nil {
2784 r0 = ret.Get(0).(<-chan string)
2785 }
2786 }
2787 if returnFunc, ok := ret.Get(1).(func(context.Context, string, int) error); ok {
2788 r1 = returnFunc(ctx, logDomain, lines)
2789 } else {
2790 r1 = ret.Error(1)
2791 }
2792 return r0, r1
2793}
2794
2795// MockControlPlane_StreamContainerLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StreamContainerLogs'
2796type MockControlPlane_StreamContainerLogs_Call struct {
2797 *mock.Call
2798}
2799
2800// StreamContainerLogs is a helper method to define mock.On call
2801// - ctx context.Context
2802// - logDomain string
2803// - lines int
2804func (_e *MockControlPlane_Expecter) StreamContainerLogs(ctx any, logDomain any, lines any) *MockControlPlane_StreamContainerLogs_Call {
2805 return &MockControlPlane_StreamContainerLogs_Call{Call: _e.mock.On("StreamContainerLogs", ctx, logDomain, lines)}
2806}
2807
2808func (_c *MockControlPlane_StreamContainerLogs_Call) Run(run func(ctx context.Context, logDomain string, lines int)) *MockControlPlane_StreamContainerLogs_Call {
2809 _c.Call.Run(func(args mock.Arguments) {
2810 var arg0 context.Context
2811 if args[0] != nil {
2812 arg0 = args[0].(context.Context)
2813 }
2814 var arg1 string
2815 if args[1] != nil {
2816 arg1 = args[1].(string)
2817 }
2818 var arg2 int
2819 if args[2] != nil {
2820 arg2 = args[2].(int)
2821 }
2822 run(
2823 arg0,
2824 arg1,
2825 arg2,
2826 )
2827 })
2828 return _c
2829}
2830
2831func (_c *MockControlPlane_StreamContainerLogs_Call) Return(stringCh <-chan string, err error) *MockControlPlane_StreamContainerLogs_Call {
2832 _c.Call.Return(stringCh, err)
2833 return _c
2834}
2835
2836func (_c *MockControlPlane_StreamContainerLogs_Call) RunAndReturn(run func(ctx context.Context, logDomain string, lines int) (<-chan string, error)) *MockControlPlane_StreamContainerLogs_Call {
2837 _c.Call.Return(run)
2838 return _c
2839}
2840
2841// StreamProcessLogs provides a mock function for the type MockControlPlane
2842func (_mock *MockControlPlane) StreamProcessLogs(ctx context.Context, lines int) (<-chan string, error) {
2843 ret := _mock.Called(ctx, lines)
2844
2845 if len(ret) == 0 {
2846 panic("no return value specified for StreamProcessLogs")
2847 }
2848
2849 var r0 <-chan string
2850 var r1 error
2851 if returnFunc, ok := ret.Get(0).(func(context.Context, int) (<-chan string, error)); ok {
2852 return returnFunc(ctx, lines)
2853 }
2854 if returnFunc, ok := ret.Get(0).(func(context.Context, int) <-chan string); ok {
2855 r0 = returnFunc(ctx, lines)
2856 } else {
2857 if ret.Get(0) != nil {
2858 r0 = ret.Get(0).(<-chan string)
2859 }
2860 }
2861 if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
2862 r1 = returnFunc(ctx, lines)
2863 } else {
2864 r1 = ret.Error(1)
2865 }
2866 return r0, r1
2867}
2868
2869// MockControlPlane_StreamProcessLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StreamProcessLogs'
2870type MockControlPlane_StreamProcessLogs_Call struct {
2871 *mock.Call
2872}
2873
2874// StreamProcessLogs is a helper method to define mock.On call
2875// - ctx context.Context
2876// - lines int
2877func (_e *MockControlPlane_Expecter) StreamProcessLogs(ctx any, lines any) *MockControlPlane_StreamProcessLogs_Call {
2878 return &MockControlPlane_StreamProcessLogs_Call{Call: _e.mock.On("StreamProcessLogs", ctx, lines)}
2879}
2880
2881func (_c *MockControlPlane_StreamProcessLogs_Call) Run(run func(ctx context.Context, lines int)) *MockControlPlane_StreamProcessLogs_Call {
2882 _c.Call.Run(func(args mock.Arguments) {
2883 var arg0 context.Context
2884 if args[0] != nil {
2885 arg0 = args[0].(context.Context)
2886 }
2887 var arg1 int
2888 if args[1] != nil {
2889 arg1 = args[1].(int)
2890 }
2891 run(
2892 arg0,
2893 arg1,
2894 )
2895 })
2896 return _c
2897}
2898
2899func (_c *MockControlPlane_StreamProcessLogs_Call) Return(stringCh <-chan string, err error) *MockControlPlane_StreamProcessLogs_Call {
2900 _c.Call.Return(stringCh, err)
2901 return _c
2902}
2903
2904func (_c *MockControlPlane_StreamProcessLogs_Call) RunAndReturn(run func(ctx context.Context, lines int) (<-chan string, error)) *MockControlPlane_StreamProcessLogs_Call {
2905 _c.Call.Return(run)
2906 return _c
2907}
2908
2909// UpdateRoute provides a mock function for the type MockControlPlane
2910func (_mock *MockControlPlane) UpdateRoute(ctx context.Context, route domain.Route) error {
2911 ret := _mock.Called(ctx, route)
2912
2913 if len(ret) == 0 {
2914 panic("no return value specified for UpdateRoute")
2915 }
2916
2917 var r0 error
2918 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Route) error); ok {
2919 r0 = returnFunc(ctx, route)
2920 } else {
2921 r0 = ret.Error(0)
2922 }
2923 return r0
2924}
2925
2926// MockControlPlane_UpdateRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRoute'
2927type MockControlPlane_UpdateRoute_Call struct {
2928 *mock.Call
2929}
2930
2931// UpdateRoute is a helper method to define mock.On call
2932// - ctx context.Context
2933// - route domain.Route
2934func (_e *MockControlPlane_Expecter) UpdateRoute(ctx any, route any) *MockControlPlane_UpdateRoute_Call {
2935 return &MockControlPlane_UpdateRoute_Call{Call: _e.mock.On("UpdateRoute", ctx, route)}
2936}
2937
2938func (_c *MockControlPlane_UpdateRoute_Call) Run(run func(ctx context.Context, route domain.Route)) *MockControlPlane_UpdateRoute_Call {
2939 _c.Call.Run(func(args mock.Arguments) {
2940 var arg0 context.Context
2941 if args[0] != nil {
2942 arg0 = args[0].(context.Context)
2943 }
2944 var arg1 domain.Route
2945 if args[1] != nil {
2946 arg1 = args[1].(domain.Route)
2947 }
2948 run(
2949 arg0,
2950 arg1,
2951 )
2952 })
2953 return _c
2954}
2955
2956func (_c *MockControlPlane_UpdateRoute_Call) Return(err error) *MockControlPlane_UpdateRoute_Call {
2957 _c.Call.Return(err)
2958 return _c
2959}
2960
2961func (_c *MockControlPlane_UpdateRoute_Call) RunAndReturn(run func(ctx context.Context, route domain.Route) error) *MockControlPlane_UpdateRoute_Call {
2962 _c.Call.Return(run)
2963 return _c
2964}
2965
2966// VolumeBackupStatus provides a mock function for the type MockControlPlane
2967func (_mock *MockControlPlane) VolumeBackupStatus(ctx context.Context) ([]dto.VolumeBackupJob, error) {
2968 ret := _mock.Called(ctx)
2969
2970 if len(ret) == 0 {
2971 panic("no return value specified for VolumeBackupStatus")
2972 }
2973
2974 var r0 []dto.VolumeBackupJob
2975 var r1 error
2976 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]dto.VolumeBackupJob, error)); ok {
2977 return returnFunc(ctx)
2978 }
2979 if returnFunc, ok := ret.Get(0).(func(context.Context) []dto.VolumeBackupJob); ok {
2980 r0 = returnFunc(ctx)
2981 } else {
2982 if ret.Get(0) != nil {
2983 r0 = ret.Get(0).([]dto.VolumeBackupJob)
2984 }
2985 }
2986 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
2987 r1 = returnFunc(ctx)
2988 } else {
2989 r1 = ret.Error(1)
2990 }
2991 return r0, r1
2992}
2993
2994// MockControlPlane_VolumeBackupStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VolumeBackupStatus'
2995type MockControlPlane_VolumeBackupStatus_Call struct {
2996 *mock.Call
2997}
2998
2999// VolumeBackupStatus is a helper method to define mock.On call
3000// - ctx context.Context
3001func (_e *MockControlPlane_Expecter) VolumeBackupStatus(ctx any) *MockControlPlane_VolumeBackupStatus_Call {
3002 return &MockControlPlane_VolumeBackupStatus_Call{Call: _e.mock.On("VolumeBackupStatus", ctx)}
3003}
3004
3005func (_c *MockControlPlane_VolumeBackupStatus_Call) Run(run func(ctx context.Context)) *MockControlPlane_VolumeBackupStatus_Call {
3006 _c.Call.Run(func(args mock.Arguments) {
3007 var arg0 context.Context
3008 if args[0] != nil {
3009 arg0 = args[0].(context.Context)
3010 }
3011 run(
3012 arg0,
3013 )
3014 })
3015 return _c
3016}
3017
3018func (_c *MockControlPlane_VolumeBackupStatus_Call) Return(volumeBackupJobs []dto.VolumeBackupJob, err error) *MockControlPlane_VolumeBackupStatus_Call {
3019 _c.Call.Return(volumeBackupJobs, err)
3020 return _c
3021}
3022
3023func (_c *MockControlPlane_VolumeBackupStatus_Call) RunAndReturn(run func(ctx context.Context) ([]dto.VolumeBackupJob, error)) *MockControlPlane_VolumeBackupStatus_Call {
3024 _c.Call.Return(run)
3025 return _c
3026}