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 if helper, ok := t.(interface{ Helper() }); ok {
23 helper.Helper()
24 }
25
26 mock := &MockControlPlane{}
27 mock.Mock.Test(t)
28
29 t.Cleanup(func() {
30 if helper, ok := t.(interface{ Helper() }); ok {
31 helper.Helper()
32 }
33 mock.AssertExpectations(t)
34 })
35
36 return mock
37}
38
39// MockControlPlane is an autogenerated mock type for the ControlPlane type
40type MockControlPlane struct {
41 mock.Mock
42}
43
44type MockControlPlane_Expecter struct {
45 mock *mock.Mock
46}
47
48func (_m *MockControlPlane) EXPECT() *MockControlPlane_Expecter {
49 return &MockControlPlane_Expecter{mock: &_m.Mock}
50}
51
52// ApplyApp provides a mock function for the type MockControlPlane
53func (_mock *MockControlPlane) ApplyApp(ctx context.Context, req dto.AppApplyRequest) (*dto.AppApplyResponse, error) {
54 ret := _mock.Called(ctx, req)
55
56 if len(ret) == 0 {
57 panic("no return value specified for ApplyApp")
58 }
59
60 var r0 *dto.AppApplyResponse
61 var r1 error
62 if returnFunc, ok := ret.Get(0).(func(context.Context, dto.AppApplyRequest) (*dto.AppApplyResponse, error)); ok {
63 return returnFunc(ctx, req)
64 }
65 if returnFunc, ok := ret.Get(0).(func(context.Context, dto.AppApplyRequest) *dto.AppApplyResponse); ok {
66 r0 = returnFunc(ctx, req)
67 } else {
68 if ret.Get(0) != nil {
69 r0 = ret.Get(0).(*dto.AppApplyResponse)
70 }
71 }
72 if returnFunc, ok := ret.Get(1).(func(context.Context, dto.AppApplyRequest) error); ok {
73 r1 = returnFunc(ctx, req)
74 } else {
75 r1 = ret.Error(1)
76 }
77 return r0, r1
78}
79
80// MockControlPlane_ApplyApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ApplyApp'
81type MockControlPlane_ApplyApp_Call struct {
82 *mock.Call
83}
84
85// ApplyApp is a helper method to define mock.On call
86// - ctx context.Context
87// - req dto.AppApplyRequest
88func (_e *MockControlPlane_Expecter) ApplyApp(ctx any, req any) *MockControlPlane_ApplyApp_Call {
89 return &MockControlPlane_ApplyApp_Call{Call: _e.mock.On("ApplyApp", ctx, req)}
90}
91
92func (_c *MockControlPlane_ApplyApp_Call) Run(run func(ctx context.Context, req dto.AppApplyRequest)) *MockControlPlane_ApplyApp_Call {
93 _c.Call.Run(func(args mock.Arguments) {
94 var arg0 context.Context
95 if args[0] != nil {
96 arg0 = args[0].(context.Context)
97 }
98 var arg1 dto.AppApplyRequest
99 if args[1] != nil {
100 arg1 = args[1].(dto.AppApplyRequest)
101 }
102 run(
103 arg0,
104 arg1,
105 )
106 })
107 return _c
108}
109
110func (_c *MockControlPlane_ApplyApp_Call) Return(appApplyResponse *dto.AppApplyResponse, err error) *MockControlPlane_ApplyApp_Call {
111 _c.Call.Return(appApplyResponse, err)
112 return _c
113}
114
115func (_c *MockControlPlane_ApplyApp_Call) RunAndReturn(run func(ctx context.Context, req dto.AppApplyRequest) (*dto.AppApplyResponse, error)) *MockControlPlane_ApplyApp_Call {
116 _c.Call.Return(run)
117 return _c
118}
119
120// BackupStatus provides a mock function for the type MockControlPlane
121func (_mock *MockControlPlane) BackupStatus(ctx context.Context) ([]dto.BackupJob, error) {
122 ret := _mock.Called(ctx)
123
124 if len(ret) == 0 {
125 panic("no return value specified for BackupStatus")
126 }
127
128 var r0 []dto.BackupJob
129 var r1 error
130 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]dto.BackupJob, error)); ok {
131 return returnFunc(ctx)
132 }
133 if returnFunc, ok := ret.Get(0).(func(context.Context) []dto.BackupJob); ok {
134 r0 = returnFunc(ctx)
135 } else {
136 if ret.Get(0) != nil {
137 r0 = ret.Get(0).([]dto.BackupJob)
138 }
139 }
140 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
141 r1 = returnFunc(ctx)
142 } else {
143 r1 = ret.Error(1)
144 }
145 return r0, r1
146}
147
148// MockControlPlane_BackupStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BackupStatus'
149type MockControlPlane_BackupStatus_Call struct {
150 *mock.Call
151}
152
153// BackupStatus is a helper method to define mock.On call
154// - ctx context.Context
155func (_e *MockControlPlane_Expecter) BackupStatus(ctx any) *MockControlPlane_BackupStatus_Call {
156 return &MockControlPlane_BackupStatus_Call{Call: _e.mock.On("BackupStatus", ctx)}
157}
158
159func (_c *MockControlPlane_BackupStatus_Call) Run(run func(ctx context.Context)) *MockControlPlane_BackupStatus_Call {
160 _c.Call.Run(func(args mock.Arguments) {
161 var arg0 context.Context
162 if args[0] != nil {
163 arg0 = args[0].(context.Context)
164 }
165 run(
166 arg0,
167 )
168 })
169 return _c
170}
171
172func (_c *MockControlPlane_BackupStatus_Call) Return(backupJobs []dto.BackupJob, err error) *MockControlPlane_BackupStatus_Call {
173 _c.Call.Return(backupJobs, err)
174 return _c
175}
176
177func (_c *MockControlPlane_BackupStatus_Call) RunAndReturn(run func(ctx context.Context) ([]dto.BackupJob, error)) *MockControlPlane_BackupStatus_Call {
178 _c.Call.Return(run)
179 return _c
180}
181
182// DeleteAppSecret provides a mock function for the type MockControlPlane
183func (_mock *MockControlPlane) DeleteAppSecret(ctx context.Context, app string, req dto.AppSecretDeleteRequest) error {
184 ret := _mock.Called(ctx, app, req)
185
186 if len(ret) == 0 {
187 panic("no return value specified for DeleteAppSecret")
188 }
189
190 var r0 error
191 if returnFunc, ok := ret.Get(0).(func(context.Context, string, dto.AppSecretDeleteRequest) error); ok {
192 r0 = returnFunc(ctx, app, req)
193 } else {
194 r0 = ret.Error(0)
195 }
196 return r0
197}
198
199// MockControlPlane_DeleteAppSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAppSecret'
200type MockControlPlane_DeleteAppSecret_Call struct {
201 *mock.Call
202}
203
204// DeleteAppSecret is a helper method to define mock.On call
205// - ctx context.Context
206// - app string
207// - req dto.AppSecretDeleteRequest
208func (_e *MockControlPlane_Expecter) DeleteAppSecret(ctx any, app any, req any) *MockControlPlane_DeleteAppSecret_Call {
209 return &MockControlPlane_DeleteAppSecret_Call{Call: _e.mock.On("DeleteAppSecret", ctx, app, req)}
210}
211
212func (_c *MockControlPlane_DeleteAppSecret_Call) Run(run func(ctx context.Context, app string, req dto.AppSecretDeleteRequest)) *MockControlPlane_DeleteAppSecret_Call {
213 _c.Call.Run(func(args mock.Arguments) {
214 var arg0 context.Context
215 if args[0] != nil {
216 arg0 = args[0].(context.Context)
217 }
218 var arg1 string
219 if args[1] != nil {
220 arg1 = args[1].(string)
221 }
222 var arg2 dto.AppSecretDeleteRequest
223 if args[2] != nil {
224 arg2 = args[2].(dto.AppSecretDeleteRequest)
225 }
226 run(
227 arg0,
228 arg1,
229 arg2,
230 )
231 })
232 return _c
233}
234
235func (_c *MockControlPlane_DeleteAppSecret_Call) Return(err error) *MockControlPlane_DeleteAppSecret_Call {
236 _c.Call.Return(err)
237 return _c
238}
239
240func (_c *MockControlPlane_DeleteAppSecret_Call) RunAndReturn(run func(ctx context.Context, app string, req dto.AppSecretDeleteRequest) error) *MockControlPlane_DeleteAppSecret_Call {
241 _c.Call.Return(run)
242 return _c
243}
244
245// DeployApp provides a mock function for the type MockControlPlane
246func (_mock *MockControlPlane) DeployApp(ctx context.Context, app string, req dto.AppDeployRequest) (*dto.AppDeployResponse, string, error) {
247 ret := _mock.Called(ctx, app, req)
248
249 if len(ret) == 0 {
250 panic("no return value specified for DeployApp")
251 }
252
253 var r0 *dto.AppDeployResponse
254 var r1 string
255 var r2 error
256 if returnFunc, ok := ret.Get(0).(func(context.Context, string, dto.AppDeployRequest) (*dto.AppDeployResponse, string, error)); ok {
257 return returnFunc(ctx, app, req)
258 }
259 if returnFunc, ok := ret.Get(0).(func(context.Context, string, dto.AppDeployRequest) *dto.AppDeployResponse); ok {
260 r0 = returnFunc(ctx, app, req)
261 } else {
262 if ret.Get(0) != nil {
263 r0 = ret.Get(0).(*dto.AppDeployResponse)
264 }
265 }
266 if returnFunc, ok := ret.Get(1).(func(context.Context, string, dto.AppDeployRequest) string); ok {
267 r1 = returnFunc(ctx, app, req)
268 } else {
269 r1 = ret.Get(1).(string)
270 }
271 if returnFunc, ok := ret.Get(2).(func(context.Context, string, dto.AppDeployRequest) error); ok {
272 r2 = returnFunc(ctx, app, req)
273 } else {
274 r2 = ret.Error(2)
275 }
276 return r0, r1, r2
277}
278
279// MockControlPlane_DeployApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeployApp'
280type MockControlPlane_DeployApp_Call struct {
281 *mock.Call
282}
283
284// DeployApp is a helper method to define mock.On call
285// - ctx context.Context
286// - app string
287// - req dto.AppDeployRequest
288func (_e *MockControlPlane_Expecter) DeployApp(ctx any, app any, req any) *MockControlPlane_DeployApp_Call {
289 return &MockControlPlane_DeployApp_Call{Call: _e.mock.On("DeployApp", ctx, app, req)}
290}
291
292func (_c *MockControlPlane_DeployApp_Call) Run(run func(ctx context.Context, app string, req dto.AppDeployRequest)) *MockControlPlane_DeployApp_Call {
293 _c.Call.Run(func(args mock.Arguments) {
294 var arg0 context.Context
295 if args[0] != nil {
296 arg0 = args[0].(context.Context)
297 }
298 var arg1 string
299 if args[1] != nil {
300 arg1 = args[1].(string)
301 }
302 var arg2 dto.AppDeployRequest
303 if args[2] != nil {
304 arg2 = args[2].(dto.AppDeployRequest)
305 }
306 run(
307 arg0,
308 arg1,
309 arg2,
310 )
311 })
312 return _c
313}
314
315func (_c *MockControlPlane_DeployApp_Call) Return(appDeployResponse *dto.AppDeployResponse, s string, err error) *MockControlPlane_DeployApp_Call {
316 _c.Call.Return(appDeployResponse, s, err)
317 return _c
318}
319
320func (_c *MockControlPlane_DeployApp_Call) RunAndReturn(run func(ctx context.Context, app string, req dto.AppDeployRequest) (*dto.AppDeployResponse, string, error)) *MockControlPlane_DeployApp_Call {
321 _c.Call.Return(run)
322 return _c
323}
324
325// DiffApp provides a mock function for the type MockControlPlane
326func (_mock *MockControlPlane) DiffApp(ctx context.Context, app string) (*dto.AppDiffResponse, error) {
327 ret := _mock.Called(ctx, app)
328
329 if len(ret) == 0 {
330 panic("no return value specified for DiffApp")
331 }
332
333 var r0 *dto.AppDiffResponse
334 var r1 error
335 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*dto.AppDiffResponse, error)); ok {
336 return returnFunc(ctx, app)
337 }
338 if returnFunc, ok := ret.Get(0).(func(context.Context, string) *dto.AppDiffResponse); ok {
339 r0 = returnFunc(ctx, app)
340 } else {
341 if ret.Get(0) != nil {
342 r0 = ret.Get(0).(*dto.AppDiffResponse)
343 }
344 }
345 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
346 r1 = returnFunc(ctx, app)
347 } else {
348 r1 = ret.Error(1)
349 }
350 return r0, r1
351}
352
353// MockControlPlane_DiffApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DiffApp'
354type MockControlPlane_DiffApp_Call struct {
355 *mock.Call
356}
357
358// DiffApp is a helper method to define mock.On call
359// - ctx context.Context
360// - app string
361func (_e *MockControlPlane_Expecter) DiffApp(ctx any, app any) *MockControlPlane_DiffApp_Call {
362 return &MockControlPlane_DiffApp_Call{Call: _e.mock.On("DiffApp", ctx, app)}
363}
364
365func (_c *MockControlPlane_DiffApp_Call) Run(run func(ctx context.Context, app string)) *MockControlPlane_DiffApp_Call {
366 _c.Call.Run(func(args mock.Arguments) {
367 var arg0 context.Context
368 if args[0] != nil {
369 arg0 = args[0].(context.Context)
370 }
371 var arg1 string
372 if args[1] != nil {
373 arg1 = args[1].(string)
374 }
375 run(
376 arg0,
377 arg1,
378 )
379 })
380 return _c
381}
382
383func (_c *MockControlPlane_DiffApp_Call) Return(appDiffResponse *dto.AppDiffResponse, err error) *MockControlPlane_DiffApp_Call {
384 _c.Call.Return(appDiffResponse, err)
385 return _c
386}
387
388func (_c *MockControlPlane_DiffApp_Call) RunAndReturn(run func(ctx context.Context, app string) (*dto.AppDiffResponse, error)) *MockControlPlane_DiffApp_Call {
389 _c.Call.Return(run)
390 return _c
391}
392
393// GetCA provides a mock function for the type MockControlPlane
394func (_mock *MockControlPlane) GetCA(ctx context.Context) (*dto.CAResponse, error) {
395 ret := _mock.Called(ctx)
396
397 if len(ret) == 0 {
398 panic("no return value specified for GetCA")
399 }
400
401 var r0 *dto.CAResponse
402 var r1 error
403 if returnFunc, ok := ret.Get(0).(func(context.Context) (*dto.CAResponse, error)); ok {
404 return returnFunc(ctx)
405 }
406 if returnFunc, ok := ret.Get(0).(func(context.Context) *dto.CAResponse); ok {
407 r0 = returnFunc(ctx)
408 } else {
409 if ret.Get(0) != nil {
410 r0 = ret.Get(0).(*dto.CAResponse)
411 }
412 }
413 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
414 r1 = returnFunc(ctx)
415 } else {
416 r1 = ret.Error(1)
417 }
418 return r0, r1
419}
420
421// MockControlPlane_GetCA_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCA'
422type MockControlPlane_GetCA_Call struct {
423 *mock.Call
424}
425
426// GetCA is a helper method to define mock.On call
427// - ctx context.Context
428func (_e *MockControlPlane_Expecter) GetCA(ctx any) *MockControlPlane_GetCA_Call {
429 return &MockControlPlane_GetCA_Call{Call: _e.mock.On("GetCA", ctx)}
430}
431
432func (_c *MockControlPlane_GetCA_Call) Run(run func(ctx context.Context)) *MockControlPlane_GetCA_Call {
433 _c.Call.Run(func(args mock.Arguments) {
434 var arg0 context.Context
435 if args[0] != nil {
436 arg0 = args[0].(context.Context)
437 }
438 run(
439 arg0,
440 )
441 })
442 return _c
443}
444
445func (_c *MockControlPlane_GetCA_Call) Return(cAResponse *dto.CAResponse, err error) *MockControlPlane_GetCA_Call {
446 _c.Call.Return(cAResponse, err)
447 return _c
448}
449
450func (_c *MockControlPlane_GetCA_Call) RunAndReturn(run func(ctx context.Context) (*dto.CAResponse, error)) *MockControlPlane_GetCA_Call {
451 _c.Call.Return(run)
452 return _c
453}
454
455// GetConfig provides a mock function for the type MockControlPlane
456func (_mock *MockControlPlane) GetConfig(ctx context.Context) (*remote.Config, error) {
457 ret := _mock.Called(ctx)
458
459 if len(ret) == 0 {
460 panic("no return value specified for GetConfig")
461 }
462
463 var r0 *remote.Config
464 var r1 error
465 if returnFunc, ok := ret.Get(0).(func(context.Context) (*remote.Config, error)); ok {
466 return returnFunc(ctx)
467 }
468 if returnFunc, ok := ret.Get(0).(func(context.Context) *remote.Config); ok {
469 r0 = returnFunc(ctx)
470 } else {
471 if ret.Get(0) != nil {
472 r0 = ret.Get(0).(*remote.Config)
473 }
474 }
475 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
476 r1 = returnFunc(ctx)
477 } else {
478 r1 = ret.Error(1)
479 }
480 return r0, r1
481}
482
483// MockControlPlane_GetConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConfig'
484type MockControlPlane_GetConfig_Call struct {
485 *mock.Call
486}
487
488// GetConfig is a helper method to define mock.On call
489// - ctx context.Context
490func (_e *MockControlPlane_Expecter) GetConfig(ctx any) *MockControlPlane_GetConfig_Call {
491 return &MockControlPlane_GetConfig_Call{Call: _e.mock.On("GetConfig", ctx)}
492}
493
494func (_c *MockControlPlane_GetConfig_Call) Run(run func(ctx context.Context)) *MockControlPlane_GetConfig_Call {
495 _c.Call.Run(func(args mock.Arguments) {
496 var arg0 context.Context
497 if args[0] != nil {
498 arg0 = args[0].(context.Context)
499 }
500 run(
501 arg0,
502 )
503 })
504 return _c
505}
506
507func (_c *MockControlPlane_GetConfig_Call) Return(config *remote.Config, err error) *MockControlPlane_GetConfig_Call {
508 _c.Call.Return(config, err)
509 return _c
510}
511
512func (_c *MockControlPlane_GetConfig_Call) RunAndReturn(run func(ctx context.Context) (*remote.Config, error)) *MockControlPlane_GetConfig_Call {
513 _c.Call.Return(run)
514 return _c
515}
516
517// GetProcessLogs provides a mock function for the type MockControlPlane
518func (_mock *MockControlPlane) GetProcessLogs(ctx context.Context, lines int) ([]string, error) {
519 ret := _mock.Called(ctx, lines)
520
521 if len(ret) == 0 {
522 panic("no return value specified for GetProcessLogs")
523 }
524
525 var r0 []string
526 var r1 error
527 if returnFunc, ok := ret.Get(0).(func(context.Context, int) ([]string, error)); ok {
528 return returnFunc(ctx, lines)
529 }
530 if returnFunc, ok := ret.Get(0).(func(context.Context, int) []string); ok {
531 r0 = returnFunc(ctx, lines)
532 } else {
533 if ret.Get(0) != nil {
534 r0 = ret.Get(0).([]string)
535 }
536 }
537 if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
538 r1 = returnFunc(ctx, lines)
539 } else {
540 r1 = ret.Error(1)
541 }
542 return r0, r1
543}
544
545// MockControlPlane_GetProcessLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProcessLogs'
546type MockControlPlane_GetProcessLogs_Call struct {
547 *mock.Call
548}
549
550// GetProcessLogs is a helper method to define mock.On call
551// - ctx context.Context
552// - lines int
553func (_e *MockControlPlane_Expecter) GetProcessLogs(ctx any, lines any) *MockControlPlane_GetProcessLogs_Call {
554 return &MockControlPlane_GetProcessLogs_Call{Call: _e.mock.On("GetProcessLogs", ctx, lines)}
555}
556
557func (_c *MockControlPlane_GetProcessLogs_Call) Run(run func(ctx context.Context, lines int)) *MockControlPlane_GetProcessLogs_Call {
558 _c.Call.Run(func(args mock.Arguments) {
559 var arg0 context.Context
560 if args[0] != nil {
561 arg0 = args[0].(context.Context)
562 }
563 var arg1 int
564 if args[1] != nil {
565 arg1 = args[1].(int)
566 }
567 run(
568 arg0,
569 arg1,
570 )
571 })
572 return _c
573}
574
575func (_c *MockControlPlane_GetProcessLogs_Call) Return(strings []string, err error) *MockControlPlane_GetProcessLogs_Call {
576 _c.Call.Return(strings, err)
577 return _c
578}
579
580func (_c *MockControlPlane_GetProcessLogs_Call) RunAndReturn(run func(ctx context.Context, lines int) ([]string, error)) *MockControlPlane_GetProcessLogs_Call {
581 _c.Call.Return(run)
582 return _c
583}
584
585// GetStatus provides a mock function for the type MockControlPlane
586func (_mock *MockControlPlane) GetStatus(ctx context.Context) (*remote.Status, error) {
587 ret := _mock.Called(ctx)
588
589 if len(ret) == 0 {
590 panic("no return value specified for GetStatus")
591 }
592
593 var r0 *remote.Status
594 var r1 error
595 if returnFunc, ok := ret.Get(0).(func(context.Context) (*remote.Status, error)); ok {
596 return returnFunc(ctx)
597 }
598 if returnFunc, ok := ret.Get(0).(func(context.Context) *remote.Status); ok {
599 r0 = returnFunc(ctx)
600 } else {
601 if ret.Get(0) != nil {
602 r0 = ret.Get(0).(*remote.Status)
603 }
604 }
605 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
606 r1 = returnFunc(ctx)
607 } else {
608 r1 = ret.Error(1)
609 }
610 return r0, r1
611}
612
613// MockControlPlane_GetStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStatus'
614type MockControlPlane_GetStatus_Call struct {
615 *mock.Call
616}
617
618// GetStatus is a helper method to define mock.On call
619// - ctx context.Context
620func (_e *MockControlPlane_Expecter) GetStatus(ctx any) *MockControlPlane_GetStatus_Call {
621 return &MockControlPlane_GetStatus_Call{Call: _e.mock.On("GetStatus", ctx)}
622}
623
624func (_c *MockControlPlane_GetStatus_Call) Run(run func(ctx context.Context)) *MockControlPlane_GetStatus_Call {
625 _c.Call.Run(func(args mock.Arguments) {
626 var arg0 context.Context
627 if args[0] != nil {
628 arg0 = args[0].(context.Context)
629 }
630 run(
631 arg0,
632 )
633 })
634 return _c
635}
636
637func (_c *MockControlPlane_GetStatus_Call) Return(status *remote.Status, err error) *MockControlPlane_GetStatus_Call {
638 _c.Call.Return(status, err)
639 return _c
640}
641
642func (_c *MockControlPlane_GetStatus_Call) RunAndReturn(run func(ctx context.Context) (*remote.Status, error)) *MockControlPlane_GetStatus_Call {
643 _c.Call.Return(run)
644 return _c
645}
646
647// GetTLSStatus provides a mock function for the type MockControlPlane
648func (_mock *MockControlPlane) GetTLSStatus(ctx context.Context) (*dto.TLSStatusResponse, error) {
649 ret := _mock.Called(ctx)
650
651 if len(ret) == 0 {
652 panic("no return value specified for GetTLSStatus")
653 }
654
655 var r0 *dto.TLSStatusResponse
656 var r1 error
657 if returnFunc, ok := ret.Get(0).(func(context.Context) (*dto.TLSStatusResponse, error)); ok {
658 return returnFunc(ctx)
659 }
660 if returnFunc, ok := ret.Get(0).(func(context.Context) *dto.TLSStatusResponse); ok {
661 r0 = returnFunc(ctx)
662 } else {
663 if ret.Get(0) != nil {
664 r0 = ret.Get(0).(*dto.TLSStatusResponse)
665 }
666 }
667 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
668 r1 = returnFunc(ctx)
669 } else {
670 r1 = ret.Error(1)
671 }
672 return r0, r1
673}
674
675// MockControlPlane_GetTLSStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTLSStatus'
676type MockControlPlane_GetTLSStatus_Call struct {
677 *mock.Call
678}
679
680// GetTLSStatus is a helper method to define mock.On call
681// - ctx context.Context
682func (_e *MockControlPlane_Expecter) GetTLSStatus(ctx any) *MockControlPlane_GetTLSStatus_Call {
683 return &MockControlPlane_GetTLSStatus_Call{Call: _e.mock.On("GetTLSStatus", ctx)}
684}
685
686func (_c *MockControlPlane_GetTLSStatus_Call) Run(run func(ctx context.Context)) *MockControlPlane_GetTLSStatus_Call {
687 _c.Call.Run(func(args mock.Arguments) {
688 var arg0 context.Context
689 if args[0] != nil {
690 arg0 = args[0].(context.Context)
691 }
692 run(
693 arg0,
694 )
695 })
696 return _c
697}
698
699func (_c *MockControlPlane_GetTLSStatus_Call) Return(tLSStatusResponse *dto.TLSStatusResponse, err error) *MockControlPlane_GetTLSStatus_Call {
700 _c.Call.Return(tLSStatusResponse, err)
701 return _c
702}
703
704func (_c *MockControlPlane_GetTLSStatus_Call) RunAndReturn(run func(ctx context.Context) (*dto.TLSStatusResponse, error)) *MockControlPlane_GetTLSStatus_Call {
705 _c.Call.Return(run)
706 return _c
707}
708
709// GetTrafficStatus provides a mock function for the type MockControlPlane
710func (_mock *MockControlPlane) GetTrafficStatus(ctx context.Context) (*dto.TrafficStatusResponse, error) {
711 ret := _mock.Called(ctx)
712
713 if len(ret) == 0 {
714 panic("no return value specified for GetTrafficStatus")
715 }
716
717 var r0 *dto.TrafficStatusResponse
718 var r1 error
719 if returnFunc, ok := ret.Get(0).(func(context.Context) (*dto.TrafficStatusResponse, error)); ok {
720 return returnFunc(ctx)
721 }
722 if returnFunc, ok := ret.Get(0).(func(context.Context) *dto.TrafficStatusResponse); ok {
723 r0 = returnFunc(ctx)
724 } else {
725 if ret.Get(0) != nil {
726 r0 = ret.Get(0).(*dto.TrafficStatusResponse)
727 }
728 }
729 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
730 r1 = returnFunc(ctx)
731 } else {
732 r1 = ret.Error(1)
733 }
734 return r0, r1
735}
736
737// MockControlPlane_GetTrafficStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTrafficStatus'
738type MockControlPlane_GetTrafficStatus_Call struct {
739 *mock.Call
740}
741
742// GetTrafficStatus is a helper method to define mock.On call
743// - ctx context.Context
744func (_e *MockControlPlane_Expecter) GetTrafficStatus(ctx any) *MockControlPlane_GetTrafficStatus_Call {
745 return &MockControlPlane_GetTrafficStatus_Call{Call: _e.mock.On("GetTrafficStatus", ctx)}
746}
747
748func (_c *MockControlPlane_GetTrafficStatus_Call) Run(run func(ctx context.Context)) *MockControlPlane_GetTrafficStatus_Call {
749 _c.Call.Run(func(args mock.Arguments) {
750 var arg0 context.Context
751 if args[0] != nil {
752 arg0 = args[0].(context.Context)
753 }
754 run(
755 arg0,
756 )
757 })
758 return _c
759}
760
761func (_c *MockControlPlane_GetTrafficStatus_Call) Return(trafficStatusResponse *dto.TrafficStatusResponse, err error) *MockControlPlane_GetTrafficStatus_Call {
762 _c.Call.Return(trafficStatusResponse, err)
763 return _c
764}
765
766func (_c *MockControlPlane_GetTrafficStatus_Call) RunAndReturn(run func(ctx context.Context) (*dto.TrafficStatusResponse, error)) *MockControlPlane_GetTrafficStatus_Call {
767 _c.Call.Return(run)
768 return _c
769}
770
771// ListAppSecrets provides a mock function for the type MockControlPlane
772func (_mock *MockControlPlane) ListAppSecrets(ctx context.Context, app string, service string) ([]dto.AppSecretMetadataDTO, error) {
773 ret := _mock.Called(ctx, app, service)
774
775 if len(ret) == 0 {
776 panic("no return value specified for ListAppSecrets")
777 }
778
779 var r0 []dto.AppSecretMetadataDTO
780 var r1 error
781 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]dto.AppSecretMetadataDTO, error)); ok {
782 return returnFunc(ctx, app, service)
783 }
784 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []dto.AppSecretMetadataDTO); ok {
785 r0 = returnFunc(ctx, app, service)
786 } else {
787 if ret.Get(0) != nil {
788 r0 = ret.Get(0).([]dto.AppSecretMetadataDTO)
789 }
790 }
791 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
792 r1 = returnFunc(ctx, app, service)
793 } else {
794 r1 = ret.Error(1)
795 }
796 return r0, r1
797}
798
799// MockControlPlane_ListAppSecrets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAppSecrets'
800type MockControlPlane_ListAppSecrets_Call struct {
801 *mock.Call
802}
803
804// ListAppSecrets is a helper method to define mock.On call
805// - ctx context.Context
806// - app string
807// - service string
808func (_e *MockControlPlane_Expecter) ListAppSecrets(ctx any, app any, service any) *MockControlPlane_ListAppSecrets_Call {
809 return &MockControlPlane_ListAppSecrets_Call{Call: _e.mock.On("ListAppSecrets", ctx, app, service)}
810}
811
812func (_c *MockControlPlane_ListAppSecrets_Call) Run(run func(ctx context.Context, app string, service string)) *MockControlPlane_ListAppSecrets_Call {
813 _c.Call.Run(func(args mock.Arguments) {
814 var arg0 context.Context
815 if args[0] != nil {
816 arg0 = args[0].(context.Context)
817 }
818 var arg1 string
819 if args[1] != nil {
820 arg1 = args[1].(string)
821 }
822 var arg2 string
823 if args[2] != nil {
824 arg2 = args[2].(string)
825 }
826 run(
827 arg0,
828 arg1,
829 arg2,
830 )
831 })
832 return _c
833}
834
835func (_c *MockControlPlane_ListAppSecrets_Call) Return(appSecretMetadataDTOs []dto.AppSecretMetadataDTO, err error) *MockControlPlane_ListAppSecrets_Call {
836 _c.Call.Return(appSecretMetadataDTOs, err)
837 return _c
838}
839
840func (_c *MockControlPlane_ListAppSecrets_Call) RunAndReturn(run func(ctx context.Context, app string, service string) ([]dto.AppSecretMetadataDTO, error)) *MockControlPlane_ListAppSecrets_Call {
841 _c.Call.Return(run)
842 return _c
843}
844
845// ListApps provides a mock function for the type MockControlPlane
846func (_mock *MockControlPlane) ListApps(ctx context.Context) ([]dto.AppSummaryDTO, error) {
847 ret := _mock.Called(ctx)
848
849 if len(ret) == 0 {
850 panic("no return value specified for ListApps")
851 }
852
853 var r0 []dto.AppSummaryDTO
854 var r1 error
855 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]dto.AppSummaryDTO, error)); ok {
856 return returnFunc(ctx)
857 }
858 if returnFunc, ok := ret.Get(0).(func(context.Context) []dto.AppSummaryDTO); ok {
859 r0 = returnFunc(ctx)
860 } else {
861 if ret.Get(0) != nil {
862 r0 = ret.Get(0).([]dto.AppSummaryDTO)
863 }
864 }
865 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
866 r1 = returnFunc(ctx)
867 } else {
868 r1 = ret.Error(1)
869 }
870 return r0, r1
871}
872
873// MockControlPlane_ListApps_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListApps'
874type MockControlPlane_ListApps_Call struct {
875 *mock.Call
876}
877
878// ListApps is a helper method to define mock.On call
879// - ctx context.Context
880func (_e *MockControlPlane_Expecter) ListApps(ctx any) *MockControlPlane_ListApps_Call {
881 return &MockControlPlane_ListApps_Call{Call: _e.mock.On("ListApps", ctx)}
882}
883
884func (_c *MockControlPlane_ListApps_Call) Run(run func(ctx context.Context)) *MockControlPlane_ListApps_Call {
885 _c.Call.Run(func(args mock.Arguments) {
886 var arg0 context.Context
887 if args[0] != nil {
888 arg0 = args[0].(context.Context)
889 }
890 run(
891 arg0,
892 )
893 })
894 return _c
895}
896
897func (_c *MockControlPlane_ListApps_Call) Return(appSummaryDTOs []dto.AppSummaryDTO, err error) *MockControlPlane_ListApps_Call {
898 _c.Call.Return(appSummaryDTOs, err)
899 return _c
900}
901
902func (_c *MockControlPlane_ListApps_Call) RunAndReturn(run func(ctx context.Context) ([]dto.AppSummaryDTO, error)) *MockControlPlane_ListApps_Call {
903 _c.Call.Return(run)
904 return _c
905}
906
907// ListBackups provides a mock function for the type MockControlPlane
908func (_mock *MockControlPlane) ListBackups(ctx context.Context, app string) ([]dto.BackupJob, error) {
909 ret := _mock.Called(ctx, app)
910
911 if len(ret) == 0 {
912 panic("no return value specified for ListBackups")
913 }
914
915 var r0 []dto.BackupJob
916 var r1 error
917 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]dto.BackupJob, error)); ok {
918 return returnFunc(ctx, app)
919 }
920 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []dto.BackupJob); ok {
921 r0 = returnFunc(ctx, app)
922 } else {
923 if ret.Get(0) != nil {
924 r0 = ret.Get(0).([]dto.BackupJob)
925 }
926 }
927 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
928 r1 = returnFunc(ctx, app)
929 } else {
930 r1 = ret.Error(1)
931 }
932 return r0, r1
933}
934
935// MockControlPlane_ListBackups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBackups'
936type MockControlPlane_ListBackups_Call struct {
937 *mock.Call
938}
939
940// ListBackups is a helper method to define mock.On call
941// - ctx context.Context
942// - app string
943func (_e *MockControlPlane_Expecter) ListBackups(ctx any, app any) *MockControlPlane_ListBackups_Call {
944 return &MockControlPlane_ListBackups_Call{Call: _e.mock.On("ListBackups", ctx, app)}
945}
946
947func (_c *MockControlPlane_ListBackups_Call) Run(run func(ctx context.Context, app string)) *MockControlPlane_ListBackups_Call {
948 _c.Call.Run(func(args mock.Arguments) {
949 var arg0 context.Context
950 if args[0] != nil {
951 arg0 = args[0].(context.Context)
952 }
953 var arg1 string
954 if args[1] != nil {
955 arg1 = args[1].(string)
956 }
957 run(
958 arg0,
959 arg1,
960 )
961 })
962 return _c
963}
964
965func (_c *MockControlPlane_ListBackups_Call) Return(backupJobs []dto.BackupJob, err error) *MockControlPlane_ListBackups_Call {
966 _c.Call.Return(backupJobs, err)
967 return _c
968}
969
970func (_c *MockControlPlane_ListBackups_Call) RunAndReturn(run func(ctx context.Context, app string) ([]dto.BackupJob, error)) *MockControlPlane_ListBackups_Call {
971 _c.Call.Return(run)
972 return _c
973}
974
975// ListNetworks provides a mock function for the type MockControlPlane
976func (_mock *MockControlPlane) ListNetworks(ctx context.Context) ([]*domain.NetworkInfo, error) {
977 ret := _mock.Called(ctx)
978
979 if len(ret) == 0 {
980 panic("no return value specified for ListNetworks")
981 }
982
983 var r0 []*domain.NetworkInfo
984 var r1 error
985 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*domain.NetworkInfo, error)); ok {
986 return returnFunc(ctx)
987 }
988 if returnFunc, ok := ret.Get(0).(func(context.Context) []*domain.NetworkInfo); ok {
989 r0 = returnFunc(ctx)
990 } else {
991 if ret.Get(0) != nil {
992 r0 = ret.Get(0).([]*domain.NetworkInfo)
993 }
994 }
995 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
996 r1 = returnFunc(ctx)
997 } else {
998 r1 = ret.Error(1)
999 }
1000 return r0, r1
1001}
1002
1003// MockControlPlane_ListNetworks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListNetworks'
1004type MockControlPlane_ListNetworks_Call struct {
1005 *mock.Call
1006}
1007
1008// ListNetworks is a helper method to define mock.On call
1009// - ctx context.Context
1010func (_e *MockControlPlane_Expecter) ListNetworks(ctx any) *MockControlPlane_ListNetworks_Call {
1011 return &MockControlPlane_ListNetworks_Call{Call: _e.mock.On("ListNetworks", ctx)}
1012}
1013
1014func (_c *MockControlPlane_ListNetworks_Call) Run(run func(ctx context.Context)) *MockControlPlane_ListNetworks_Call {
1015 _c.Call.Run(func(args mock.Arguments) {
1016 var arg0 context.Context
1017 if args[0] != nil {
1018 arg0 = args[0].(context.Context)
1019 }
1020 run(
1021 arg0,
1022 )
1023 })
1024 return _c
1025}
1026
1027func (_c *MockControlPlane_ListNetworks_Call) Return(networkInfos []*domain.NetworkInfo, err error) *MockControlPlane_ListNetworks_Call {
1028 _c.Call.Return(networkInfos, err)
1029 return _c
1030}
1031
1032func (_c *MockControlPlane_ListNetworks_Call) RunAndReturn(run func(ctx context.Context) ([]*domain.NetworkInfo, error)) *MockControlPlane_ListNetworks_Call {
1033 _c.Call.Return(run)
1034 return _c
1035}
1036
1037// ListTags provides a mock function for the type MockControlPlane
1038func (_mock *MockControlPlane) ListTags(ctx context.Context, repository string) ([]string, error) {
1039 ret := _mock.Called(ctx, repository)
1040
1041 if len(ret) == 0 {
1042 panic("no return value specified for ListTags")
1043 }
1044
1045 var r0 []string
1046 var r1 error
1047 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]string, error)); ok {
1048 return returnFunc(ctx, repository)
1049 }
1050 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []string); ok {
1051 r0 = returnFunc(ctx, repository)
1052 } else {
1053 if ret.Get(0) != nil {
1054 r0 = ret.Get(0).([]string)
1055 }
1056 }
1057 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
1058 r1 = returnFunc(ctx, repository)
1059 } else {
1060 r1 = ret.Error(1)
1061 }
1062 return r0, r1
1063}
1064
1065// MockControlPlane_ListTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTags'
1066type MockControlPlane_ListTags_Call struct {
1067 *mock.Call
1068}
1069
1070// ListTags is a helper method to define mock.On call
1071// - ctx context.Context
1072// - repository string
1073func (_e *MockControlPlane_Expecter) ListTags(ctx any, repository any) *MockControlPlane_ListTags_Call {
1074 return &MockControlPlane_ListTags_Call{Call: _e.mock.On("ListTags", ctx, repository)}
1075}
1076
1077func (_c *MockControlPlane_ListTags_Call) Run(run func(ctx context.Context, repository string)) *MockControlPlane_ListTags_Call {
1078 _c.Call.Run(func(args mock.Arguments) {
1079 var arg0 context.Context
1080 if args[0] != nil {
1081 arg0 = args[0].(context.Context)
1082 }
1083 var arg1 string
1084 if args[1] != nil {
1085 arg1 = args[1].(string)
1086 }
1087 run(
1088 arg0,
1089 arg1,
1090 )
1091 })
1092 return _c
1093}
1094
1095func (_c *MockControlPlane_ListTags_Call) Return(strings []string, err error) *MockControlPlane_ListTags_Call {
1096 _c.Call.Return(strings, err)
1097 return _c
1098}
1099
1100func (_c *MockControlPlane_ListTags_Call) RunAndReturn(run func(ctx context.Context, repository string) ([]string, error)) *MockControlPlane_ListTags_Call {
1101 _c.Call.Return(run)
1102 return _c
1103}
1104
1105// ListVolumeBackups provides a mock function for the type MockControlPlane
1106func (_mock *MockControlPlane) ListVolumeBackups(ctx context.Context, app string) ([]dto.VolumeBackupJob, error) {
1107 ret := _mock.Called(ctx, app)
1108
1109 if len(ret) == 0 {
1110 panic("no return value specified for ListVolumeBackups")
1111 }
1112
1113 var r0 []dto.VolumeBackupJob
1114 var r1 error
1115 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]dto.VolumeBackupJob, error)); ok {
1116 return returnFunc(ctx, app)
1117 }
1118 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []dto.VolumeBackupJob); ok {
1119 r0 = returnFunc(ctx, app)
1120 } else {
1121 if ret.Get(0) != nil {
1122 r0 = ret.Get(0).([]dto.VolumeBackupJob)
1123 }
1124 }
1125 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
1126 r1 = returnFunc(ctx, app)
1127 } else {
1128 r1 = ret.Error(1)
1129 }
1130 return r0, r1
1131}
1132
1133// MockControlPlane_ListVolumeBackups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVolumeBackups'
1134type MockControlPlane_ListVolumeBackups_Call struct {
1135 *mock.Call
1136}
1137
1138// ListVolumeBackups is a helper method to define mock.On call
1139// - ctx context.Context
1140// - app string
1141func (_e *MockControlPlane_Expecter) ListVolumeBackups(ctx any, app any) *MockControlPlane_ListVolumeBackups_Call {
1142 return &MockControlPlane_ListVolumeBackups_Call{Call: _e.mock.On("ListVolumeBackups", ctx, app)}
1143}
1144
1145func (_c *MockControlPlane_ListVolumeBackups_Call) Run(run func(ctx context.Context, app string)) *MockControlPlane_ListVolumeBackups_Call {
1146 _c.Call.Run(func(args mock.Arguments) {
1147 var arg0 context.Context
1148 if args[0] != nil {
1149 arg0 = args[0].(context.Context)
1150 }
1151 var arg1 string
1152 if args[1] != nil {
1153 arg1 = args[1].(string)
1154 }
1155 run(
1156 arg0,
1157 arg1,
1158 )
1159 })
1160 return _c
1161}
1162
1163func (_c *MockControlPlane_ListVolumeBackups_Call) Return(volumeBackupJobs []dto.VolumeBackupJob, err error) *MockControlPlane_ListVolumeBackups_Call {
1164 _c.Call.Return(volumeBackupJobs, err)
1165 return _c
1166}
1167
1168func (_c *MockControlPlane_ListVolumeBackups_Call) RunAndReturn(run func(ctx context.Context, app string) ([]dto.VolumeBackupJob, error)) *MockControlPlane_ListVolumeBackups_Call {
1169 _c.Call.Return(run)
1170 return _c
1171}
1172
1173// ListVolumes provides a mock function for the type MockControlPlane
1174func (_mock *MockControlPlane) ListVolumes(ctx context.Context) ([]dto.Volume, error) {
1175 ret := _mock.Called(ctx)
1176
1177 if len(ret) == 0 {
1178 panic("no return value specified for ListVolumes")
1179 }
1180
1181 var r0 []dto.Volume
1182 var r1 error
1183 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]dto.Volume, error)); ok {
1184 return returnFunc(ctx)
1185 }
1186 if returnFunc, ok := ret.Get(0).(func(context.Context) []dto.Volume); ok {
1187 r0 = returnFunc(ctx)
1188 } else {
1189 if ret.Get(0) != nil {
1190 r0 = ret.Get(0).([]dto.Volume)
1191 }
1192 }
1193 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1194 r1 = returnFunc(ctx)
1195 } else {
1196 r1 = ret.Error(1)
1197 }
1198 return r0, r1
1199}
1200
1201// MockControlPlane_ListVolumes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVolumes'
1202type MockControlPlane_ListVolumes_Call struct {
1203 *mock.Call
1204}
1205
1206// ListVolumes is a helper method to define mock.On call
1207// - ctx context.Context
1208func (_e *MockControlPlane_Expecter) ListVolumes(ctx any) *MockControlPlane_ListVolumes_Call {
1209 return &MockControlPlane_ListVolumes_Call{Call: _e.mock.On("ListVolumes", ctx)}
1210}
1211
1212func (_c *MockControlPlane_ListVolumes_Call) Run(run func(ctx context.Context)) *MockControlPlane_ListVolumes_Call {
1213 _c.Call.Run(func(args mock.Arguments) {
1214 var arg0 context.Context
1215 if args[0] != nil {
1216 arg0 = args[0].(context.Context)
1217 }
1218 run(
1219 arg0,
1220 )
1221 })
1222 return _c
1223}
1224
1225func (_c *MockControlPlane_ListVolumes_Call) Return(volumes []dto.Volume, err error) *MockControlPlane_ListVolumes_Call {
1226 _c.Call.Return(volumes, err)
1227 return _c
1228}
1229
1230func (_c *MockControlPlane_ListVolumes_Call) RunAndReturn(run func(ctx context.Context) ([]dto.Volume, error)) *MockControlPlane_ListVolumes_Call {
1231 _c.Call.Return(run)
1232 return _c
1233}
1234
1235// OperationByKey provides a mock function for the type MockControlPlane
1236func (_mock *MockControlPlane) OperationByKey(ctx context.Context, app string, key string) (*dto.AppDeployResponse, error) {
1237 ret := _mock.Called(ctx, app, key)
1238
1239 if len(ret) == 0 {
1240 panic("no return value specified for OperationByKey")
1241 }
1242
1243 var r0 *dto.AppDeployResponse
1244 var r1 error
1245 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*dto.AppDeployResponse, error)); ok {
1246 return returnFunc(ctx, app, key)
1247 }
1248 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *dto.AppDeployResponse); ok {
1249 r0 = returnFunc(ctx, app, key)
1250 } else {
1251 if ret.Get(0) != nil {
1252 r0 = ret.Get(0).(*dto.AppDeployResponse)
1253 }
1254 }
1255 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
1256 r1 = returnFunc(ctx, app, key)
1257 } else {
1258 r1 = ret.Error(1)
1259 }
1260 return r0, r1
1261}
1262
1263// MockControlPlane_OperationByKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OperationByKey'
1264type MockControlPlane_OperationByKey_Call struct {
1265 *mock.Call
1266}
1267
1268// OperationByKey is a helper method to define mock.On call
1269// - ctx context.Context
1270// - app string
1271// - key string
1272func (_e *MockControlPlane_Expecter) OperationByKey(ctx any, app any, key any) *MockControlPlane_OperationByKey_Call {
1273 return &MockControlPlane_OperationByKey_Call{Call: _e.mock.On("OperationByKey", ctx, app, key)}
1274}
1275
1276func (_c *MockControlPlane_OperationByKey_Call) Run(run func(ctx context.Context, app string, key string)) *MockControlPlane_OperationByKey_Call {
1277 _c.Call.Run(func(args mock.Arguments) {
1278 var arg0 context.Context
1279 if args[0] != nil {
1280 arg0 = args[0].(context.Context)
1281 }
1282 var arg1 string
1283 if args[1] != nil {
1284 arg1 = args[1].(string)
1285 }
1286 var arg2 string
1287 if args[2] != nil {
1288 arg2 = args[2].(string)
1289 }
1290 run(
1291 arg0,
1292 arg1,
1293 arg2,
1294 )
1295 })
1296 return _c
1297}
1298
1299func (_c *MockControlPlane_OperationByKey_Call) Return(appDeployResponse *dto.AppDeployResponse, err error) *MockControlPlane_OperationByKey_Call {
1300 _c.Call.Return(appDeployResponse, err)
1301 return _c
1302}
1303
1304func (_c *MockControlPlane_OperationByKey_Call) RunAndReturn(run func(ctx context.Context, app string, key string) (*dto.AppDeployResponse, error)) *MockControlPlane_OperationByKey_Call {
1305 _c.Call.Return(run)
1306 return _c
1307}
1308
1309// PruneVolumes provides a mock function for the type MockControlPlane
1310func (_mock *MockControlPlane) PruneVolumes(ctx context.Context, req dto.VolumePruneRequest) (*dto.VolumePruneResponse, error) {
1311 ret := _mock.Called(ctx, req)
1312
1313 if len(ret) == 0 {
1314 panic("no return value specified for PruneVolumes")
1315 }
1316
1317 var r0 *dto.VolumePruneResponse
1318 var r1 error
1319 if returnFunc, ok := ret.Get(0).(func(context.Context, dto.VolumePruneRequest) (*dto.VolumePruneResponse, error)); ok {
1320 return returnFunc(ctx, req)
1321 }
1322 if returnFunc, ok := ret.Get(0).(func(context.Context, dto.VolumePruneRequest) *dto.VolumePruneResponse); ok {
1323 r0 = returnFunc(ctx, req)
1324 } else {
1325 if ret.Get(0) != nil {
1326 r0 = ret.Get(0).(*dto.VolumePruneResponse)
1327 }
1328 }
1329 if returnFunc, ok := ret.Get(1).(func(context.Context, dto.VolumePruneRequest) error); ok {
1330 r1 = returnFunc(ctx, req)
1331 } else {
1332 r1 = ret.Error(1)
1333 }
1334 return r0, r1
1335}
1336
1337// MockControlPlane_PruneVolumes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PruneVolumes'
1338type MockControlPlane_PruneVolumes_Call struct {
1339 *mock.Call
1340}
1341
1342// PruneVolumes is a helper method to define mock.On call
1343// - ctx context.Context
1344// - req dto.VolumePruneRequest
1345func (_e *MockControlPlane_Expecter) PruneVolumes(ctx any, req any) *MockControlPlane_PruneVolumes_Call {
1346 return &MockControlPlane_PruneVolumes_Call{Call: _e.mock.On("PruneVolumes", ctx, req)}
1347}
1348
1349func (_c *MockControlPlane_PruneVolumes_Call) Run(run func(ctx context.Context, req dto.VolumePruneRequest)) *MockControlPlane_PruneVolumes_Call {
1350 _c.Call.Run(func(args mock.Arguments) {
1351 var arg0 context.Context
1352 if args[0] != nil {
1353 arg0 = args[0].(context.Context)
1354 }
1355 var arg1 dto.VolumePruneRequest
1356 if args[1] != nil {
1357 arg1 = args[1].(dto.VolumePruneRequest)
1358 }
1359 run(
1360 arg0,
1361 arg1,
1362 )
1363 })
1364 return _c
1365}
1366
1367func (_c *MockControlPlane_PruneVolumes_Call) Return(volumePruneResponse *dto.VolumePruneResponse, err error) *MockControlPlane_PruneVolumes_Call {
1368 _c.Call.Return(volumePruneResponse, err)
1369 return _c
1370}
1371
1372func (_c *MockControlPlane_PruneVolumes_Call) RunAndReturn(run func(ctx context.Context, req dto.VolumePruneRequest) (*dto.VolumePruneResponse, error)) *MockControlPlane_PruneVolumes_Call {
1373 _c.Call.Return(run)
1374 return _c
1375}
1376
1377// Reload provides a mock function for the type MockControlPlane
1378func (_mock *MockControlPlane) Reload(ctx context.Context) error {
1379 ret := _mock.Called(ctx)
1380
1381 if len(ret) == 0 {
1382 panic("no return value specified for Reload")
1383 }
1384
1385 var r0 error
1386 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1387 r0 = returnFunc(ctx)
1388 } else {
1389 r0 = ret.Error(0)
1390 }
1391 return r0
1392}
1393
1394// MockControlPlane_Reload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reload'
1395type MockControlPlane_Reload_Call struct {
1396 *mock.Call
1397}
1398
1399// Reload is a helper method to define mock.On call
1400// - ctx context.Context
1401func (_e *MockControlPlane_Expecter) Reload(ctx any) *MockControlPlane_Reload_Call {
1402 return &MockControlPlane_Reload_Call{Call: _e.mock.On("Reload", ctx)}
1403}
1404
1405func (_c *MockControlPlane_Reload_Call) Run(run func(ctx context.Context)) *MockControlPlane_Reload_Call {
1406 _c.Call.Run(func(args mock.Arguments) {
1407 var arg0 context.Context
1408 if args[0] != nil {
1409 arg0 = args[0].(context.Context)
1410 }
1411 run(
1412 arg0,
1413 )
1414 })
1415 return _c
1416}
1417
1418func (_c *MockControlPlane_Reload_Call) Return(err error) *MockControlPlane_Reload_Call {
1419 _c.Call.Return(err)
1420 return _c
1421}
1422
1423func (_c *MockControlPlane_Reload_Call) RunAndReturn(run func(ctx context.Context) error) *MockControlPlane_Reload_Call {
1424 _c.Call.Return(run)
1425 return _c
1426}
1427
1428// RemoveApp provides a mock function for the type MockControlPlane
1429func (_mock *MockControlPlane) RemoveApp(ctx context.Context, app string) (*dto.AppDeployResponse, string, error) {
1430 ret := _mock.Called(ctx, app)
1431
1432 if len(ret) == 0 {
1433 panic("no return value specified for RemoveApp")
1434 }
1435
1436 var r0 *dto.AppDeployResponse
1437 var r1 string
1438 var r2 error
1439 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*dto.AppDeployResponse, string, error)); ok {
1440 return returnFunc(ctx, app)
1441 }
1442 if returnFunc, ok := ret.Get(0).(func(context.Context, string) *dto.AppDeployResponse); ok {
1443 r0 = returnFunc(ctx, app)
1444 } else {
1445 if ret.Get(0) != nil {
1446 r0 = ret.Get(0).(*dto.AppDeployResponse)
1447 }
1448 }
1449 if returnFunc, ok := ret.Get(1).(func(context.Context, string) string); ok {
1450 r1 = returnFunc(ctx, app)
1451 } else {
1452 r1 = ret.Get(1).(string)
1453 }
1454 if returnFunc, ok := ret.Get(2).(func(context.Context, string) error); ok {
1455 r2 = returnFunc(ctx, app)
1456 } else {
1457 r2 = ret.Error(2)
1458 }
1459 return r0, r1, r2
1460}
1461
1462// MockControlPlane_RemoveApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveApp'
1463type MockControlPlane_RemoveApp_Call struct {
1464 *mock.Call
1465}
1466
1467// RemoveApp is a helper method to define mock.On call
1468// - ctx context.Context
1469// - app string
1470func (_e *MockControlPlane_Expecter) RemoveApp(ctx any, app any) *MockControlPlane_RemoveApp_Call {
1471 return &MockControlPlane_RemoveApp_Call{Call: _e.mock.On("RemoveApp", ctx, app)}
1472}
1473
1474func (_c *MockControlPlane_RemoveApp_Call) Run(run func(ctx context.Context, app string)) *MockControlPlane_RemoveApp_Call {
1475 _c.Call.Run(func(args mock.Arguments) {
1476 var arg0 context.Context
1477 if args[0] != nil {
1478 arg0 = args[0].(context.Context)
1479 }
1480 var arg1 string
1481 if args[1] != nil {
1482 arg1 = args[1].(string)
1483 }
1484 run(
1485 arg0,
1486 arg1,
1487 )
1488 })
1489 return _c
1490}
1491
1492func (_c *MockControlPlane_RemoveApp_Call) Return(appDeployResponse *dto.AppDeployResponse, s string, err error) *MockControlPlane_RemoveApp_Call {
1493 _c.Call.Return(appDeployResponse, s, err)
1494 return _c
1495}
1496
1497func (_c *MockControlPlane_RemoveApp_Call) RunAndReturn(run func(ctx context.Context, app string) (*dto.AppDeployResponse, string, error)) *MockControlPlane_RemoveApp_Call {
1498 _c.Call.Return(run)
1499 return _c
1500}
1501
1502// RestartApp provides a mock function for the type MockControlPlane
1503func (_mock *MockControlPlane) RestartApp(ctx context.Context, app string, service string, all bool) (*dto.AppDeployResponse, string, error) {
1504 ret := _mock.Called(ctx, app, service, all)
1505
1506 if len(ret) == 0 {
1507 panic("no return value specified for RestartApp")
1508 }
1509
1510 var r0 *dto.AppDeployResponse
1511 var r1 string
1512 var r2 error
1513 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, bool) (*dto.AppDeployResponse, string, error)); ok {
1514 return returnFunc(ctx, app, service, all)
1515 }
1516 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, bool) *dto.AppDeployResponse); ok {
1517 r0 = returnFunc(ctx, app, service, all)
1518 } else {
1519 if ret.Get(0) != nil {
1520 r0 = ret.Get(0).(*dto.AppDeployResponse)
1521 }
1522 }
1523 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, bool) string); ok {
1524 r1 = returnFunc(ctx, app, service, all)
1525 } else {
1526 r1 = ret.Get(1).(string)
1527 }
1528 if returnFunc, ok := ret.Get(2).(func(context.Context, string, string, bool) error); ok {
1529 r2 = returnFunc(ctx, app, service, all)
1530 } else {
1531 r2 = ret.Error(2)
1532 }
1533 return r0, r1, r2
1534}
1535
1536// MockControlPlane_RestartApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestartApp'
1537type MockControlPlane_RestartApp_Call struct {
1538 *mock.Call
1539}
1540
1541// RestartApp is a helper method to define mock.On call
1542// - ctx context.Context
1543// - app string
1544// - service string
1545// - all bool
1546func (_e *MockControlPlane_Expecter) RestartApp(ctx any, app any, service any, all any) *MockControlPlane_RestartApp_Call {
1547 return &MockControlPlane_RestartApp_Call{Call: _e.mock.On("RestartApp", ctx, app, service, all)}
1548}
1549
1550func (_c *MockControlPlane_RestartApp_Call) Run(run func(ctx context.Context, app string, service string, all bool)) *MockControlPlane_RestartApp_Call {
1551 _c.Call.Run(func(args mock.Arguments) {
1552 var arg0 context.Context
1553 if args[0] != nil {
1554 arg0 = args[0].(context.Context)
1555 }
1556 var arg1 string
1557 if args[1] != nil {
1558 arg1 = args[1].(string)
1559 }
1560 var arg2 string
1561 if args[2] != nil {
1562 arg2 = args[2].(string)
1563 }
1564 var arg3 bool
1565 if args[3] != nil {
1566 arg3 = args[3].(bool)
1567 }
1568 run(
1569 arg0,
1570 arg1,
1571 arg2,
1572 arg3,
1573 )
1574 })
1575 return _c
1576}
1577
1578func (_c *MockControlPlane_RestartApp_Call) Return(appDeployResponse *dto.AppDeployResponse, s string, err error) *MockControlPlane_RestartApp_Call {
1579 _c.Call.Return(appDeployResponse, s, err)
1580 return _c
1581}
1582
1583func (_c *MockControlPlane_RestartApp_Call) RunAndReturn(run func(ctx context.Context, app string, service string, all bool) (*dto.AppDeployResponse, string, error)) *MockControlPlane_RestartApp_Call {
1584 _c.Call.Return(run)
1585 return _c
1586}
1587
1588// RunBackup provides a mock function for the type MockControlPlane
1589func (_mock *MockControlPlane) RunBackup(ctx context.Context, app string, service string, database string) (*dto.BackupRunResponse, error) {
1590 ret := _mock.Called(ctx, app, service, database)
1591
1592 if len(ret) == 0 {
1593 panic("no return value specified for RunBackup")
1594 }
1595
1596 var r0 *dto.BackupRunResponse
1597 var r1 error
1598 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*dto.BackupRunResponse, error)); ok {
1599 return returnFunc(ctx, app, service, database)
1600 }
1601 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *dto.BackupRunResponse); ok {
1602 r0 = returnFunc(ctx, app, service, database)
1603 } else {
1604 if ret.Get(0) != nil {
1605 r0 = ret.Get(0).(*dto.BackupRunResponse)
1606 }
1607 }
1608 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
1609 r1 = returnFunc(ctx, app, service, database)
1610 } else {
1611 r1 = ret.Error(1)
1612 }
1613 return r0, r1
1614}
1615
1616// MockControlPlane_RunBackup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunBackup'
1617type MockControlPlane_RunBackup_Call struct {
1618 *mock.Call
1619}
1620
1621// RunBackup is a helper method to define mock.On call
1622// - ctx context.Context
1623// - app string
1624// - service string
1625// - database string
1626func (_e *MockControlPlane_Expecter) RunBackup(ctx any, app any, service any, database any) *MockControlPlane_RunBackup_Call {
1627 return &MockControlPlane_RunBackup_Call{Call: _e.mock.On("RunBackup", ctx, app, service, database)}
1628}
1629
1630func (_c *MockControlPlane_RunBackup_Call) Run(run func(ctx context.Context, app string, service string, database string)) *MockControlPlane_RunBackup_Call {
1631 _c.Call.Run(func(args mock.Arguments) {
1632 var arg0 context.Context
1633 if args[0] != nil {
1634 arg0 = args[0].(context.Context)
1635 }
1636 var arg1 string
1637 if args[1] != nil {
1638 arg1 = args[1].(string)
1639 }
1640 var arg2 string
1641 if args[2] != nil {
1642 arg2 = args[2].(string)
1643 }
1644 var arg3 string
1645 if args[3] != nil {
1646 arg3 = args[3].(string)
1647 }
1648 run(
1649 arg0,
1650 arg1,
1651 arg2,
1652 arg3,
1653 )
1654 })
1655 return _c
1656}
1657
1658func (_c *MockControlPlane_RunBackup_Call) Return(backupRunResponse *dto.BackupRunResponse, err error) *MockControlPlane_RunBackup_Call {
1659 _c.Call.Return(backupRunResponse, err)
1660 return _c
1661}
1662
1663func (_c *MockControlPlane_RunBackup_Call) RunAndReturn(run func(ctx context.Context, app string, service string, database string) (*dto.BackupRunResponse, error)) *MockControlPlane_RunBackup_Call {
1664 _c.Call.Return(run)
1665 return _c
1666}
1667
1668// RunVolumeBackups provides a mock function for the type MockControlPlane
1669func (_mock *MockControlPlane) RunVolumeBackups(ctx context.Context, app string, service string, volume string) (*dto.VolumeBackupRunResponse, error) {
1670 ret := _mock.Called(ctx, app, service, volume)
1671
1672 if len(ret) == 0 {
1673 panic("no return value specified for RunVolumeBackups")
1674 }
1675
1676 var r0 *dto.VolumeBackupRunResponse
1677 var r1 error
1678 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*dto.VolumeBackupRunResponse, error)); ok {
1679 return returnFunc(ctx, app, service, volume)
1680 }
1681 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *dto.VolumeBackupRunResponse); ok {
1682 r0 = returnFunc(ctx, app, service, volume)
1683 } else {
1684 if ret.Get(0) != nil {
1685 r0 = ret.Get(0).(*dto.VolumeBackupRunResponse)
1686 }
1687 }
1688 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
1689 r1 = returnFunc(ctx, app, service, volume)
1690 } else {
1691 r1 = ret.Error(1)
1692 }
1693 return r0, r1
1694}
1695
1696// MockControlPlane_RunVolumeBackups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunVolumeBackups'
1697type MockControlPlane_RunVolumeBackups_Call struct {
1698 *mock.Call
1699}
1700
1701// RunVolumeBackups is a helper method to define mock.On call
1702// - ctx context.Context
1703// - app string
1704// - service string
1705// - volume string
1706func (_e *MockControlPlane_Expecter) RunVolumeBackups(ctx any, app any, service any, volume any) *MockControlPlane_RunVolumeBackups_Call {
1707 return &MockControlPlane_RunVolumeBackups_Call{Call: _e.mock.On("RunVolumeBackups", ctx, app, service, volume)}
1708}
1709
1710func (_c *MockControlPlane_RunVolumeBackups_Call) Run(run func(ctx context.Context, app string, service string, volume string)) *MockControlPlane_RunVolumeBackups_Call {
1711 _c.Call.Run(func(args mock.Arguments) {
1712 var arg0 context.Context
1713 if args[0] != nil {
1714 arg0 = args[0].(context.Context)
1715 }
1716 var arg1 string
1717 if args[1] != nil {
1718 arg1 = args[1].(string)
1719 }
1720 var arg2 string
1721 if args[2] != nil {
1722 arg2 = args[2].(string)
1723 }
1724 var arg3 string
1725 if args[3] != nil {
1726 arg3 = args[3].(string)
1727 }
1728 run(
1729 arg0,
1730 arg1,
1731 arg2,
1732 arg3,
1733 )
1734 })
1735 return _c
1736}
1737
1738func (_c *MockControlPlane_RunVolumeBackups_Call) Return(volumeBackupRunResponse *dto.VolumeBackupRunResponse, err error) *MockControlPlane_RunVolumeBackups_Call {
1739 _c.Call.Return(volumeBackupRunResponse, err)
1740 return _c
1741}
1742
1743func (_c *MockControlPlane_RunVolumeBackups_Call) RunAndReturn(run func(ctx context.Context, app string, service string, volume string) (*dto.VolumeBackupRunResponse, error)) *MockControlPlane_RunVolumeBackups_Call {
1744 _c.Call.Return(run)
1745 return _c
1746}
1747
1748// SetAppSecrets provides a mock function for the type MockControlPlane
1749func (_mock *MockControlPlane) SetAppSecrets(ctx context.Context, app string, req dto.AppSecretSetRequest) error {
1750 ret := _mock.Called(ctx, app, req)
1751
1752 if len(ret) == 0 {
1753 panic("no return value specified for SetAppSecrets")
1754 }
1755
1756 var r0 error
1757 if returnFunc, ok := ret.Get(0).(func(context.Context, string, dto.AppSecretSetRequest) error); ok {
1758 r0 = returnFunc(ctx, app, req)
1759 } else {
1760 r0 = ret.Error(0)
1761 }
1762 return r0
1763}
1764
1765// MockControlPlane_SetAppSecrets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetAppSecrets'
1766type MockControlPlane_SetAppSecrets_Call struct {
1767 *mock.Call
1768}
1769
1770// SetAppSecrets is a helper method to define mock.On call
1771// - ctx context.Context
1772// - app string
1773// - req dto.AppSecretSetRequest
1774func (_e *MockControlPlane_Expecter) SetAppSecrets(ctx any, app any, req any) *MockControlPlane_SetAppSecrets_Call {
1775 return &MockControlPlane_SetAppSecrets_Call{Call: _e.mock.On("SetAppSecrets", ctx, app, req)}
1776}
1777
1778func (_c *MockControlPlane_SetAppSecrets_Call) Run(run func(ctx context.Context, app string, req dto.AppSecretSetRequest)) *MockControlPlane_SetAppSecrets_Call {
1779 _c.Call.Run(func(args mock.Arguments) {
1780 var arg0 context.Context
1781 if args[0] != nil {
1782 arg0 = args[0].(context.Context)
1783 }
1784 var arg1 string
1785 if args[1] != nil {
1786 arg1 = args[1].(string)
1787 }
1788 var arg2 dto.AppSecretSetRequest
1789 if args[2] != nil {
1790 arg2 = args[2].(dto.AppSecretSetRequest)
1791 }
1792 run(
1793 arg0,
1794 arg1,
1795 arg2,
1796 )
1797 })
1798 return _c
1799}
1800
1801func (_c *MockControlPlane_SetAppSecrets_Call) Return(err error) *MockControlPlane_SetAppSecrets_Call {
1802 _c.Call.Return(err)
1803 return _c
1804}
1805
1806func (_c *MockControlPlane_SetAppSecrets_Call) RunAndReturn(run func(ctx context.Context, app string, req dto.AppSecretSetRequest) error) *MockControlPlane_SetAppSecrets_Call {
1807 _c.Call.Return(run)
1808 return _c
1809}
1810
1811// ShowApp provides a mock function for the type MockControlPlane
1812func (_mock *MockControlPlane) ShowApp(ctx context.Context, app string) (*dto.AppShowResponse, error) {
1813 ret := _mock.Called(ctx, app)
1814
1815 if len(ret) == 0 {
1816 panic("no return value specified for ShowApp")
1817 }
1818
1819 var r0 *dto.AppShowResponse
1820 var r1 error
1821 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*dto.AppShowResponse, error)); ok {
1822 return returnFunc(ctx, app)
1823 }
1824 if returnFunc, ok := ret.Get(0).(func(context.Context, string) *dto.AppShowResponse); ok {
1825 r0 = returnFunc(ctx, app)
1826 } else {
1827 if ret.Get(0) != nil {
1828 r0 = ret.Get(0).(*dto.AppShowResponse)
1829 }
1830 }
1831 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
1832 r1 = returnFunc(ctx, app)
1833 } else {
1834 r1 = ret.Error(1)
1835 }
1836 return r0, r1
1837}
1838
1839// MockControlPlane_ShowApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowApp'
1840type MockControlPlane_ShowApp_Call struct {
1841 *mock.Call
1842}
1843
1844// ShowApp is a helper method to define mock.On call
1845// - ctx context.Context
1846// - app string
1847func (_e *MockControlPlane_Expecter) ShowApp(ctx any, app any) *MockControlPlane_ShowApp_Call {
1848 return &MockControlPlane_ShowApp_Call{Call: _e.mock.On("ShowApp", ctx, app)}
1849}
1850
1851func (_c *MockControlPlane_ShowApp_Call) Run(run func(ctx context.Context, app string)) *MockControlPlane_ShowApp_Call {
1852 _c.Call.Run(func(args mock.Arguments) {
1853 var arg0 context.Context
1854 if args[0] != nil {
1855 arg0 = args[0].(context.Context)
1856 }
1857 var arg1 string
1858 if args[1] != nil {
1859 arg1 = args[1].(string)
1860 }
1861 run(
1862 arg0,
1863 arg1,
1864 )
1865 })
1866 return _c
1867}
1868
1869func (_c *MockControlPlane_ShowApp_Call) Return(appShowResponse *dto.AppShowResponse, err error) *MockControlPlane_ShowApp_Call {
1870 _c.Call.Return(appShowResponse, err)
1871 return _c
1872}
1873
1874func (_c *MockControlPlane_ShowApp_Call) RunAndReturn(run func(ctx context.Context, app string) (*dto.AppShowResponse, error)) *MockControlPlane_ShowApp_Call {
1875 _c.Call.Return(run)
1876 return _c
1877}
1878
1879// StartApp provides a mock function for the type MockControlPlane
1880func (_mock *MockControlPlane) StartApp(ctx context.Context, app string) (*dto.AppDeployResponse, string, error) {
1881 ret := _mock.Called(ctx, app)
1882
1883 if len(ret) == 0 {
1884 panic("no return value specified for StartApp")
1885 }
1886
1887 var r0 *dto.AppDeployResponse
1888 var r1 string
1889 var r2 error
1890 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*dto.AppDeployResponse, string, error)); ok {
1891 return returnFunc(ctx, app)
1892 }
1893 if returnFunc, ok := ret.Get(0).(func(context.Context, string) *dto.AppDeployResponse); ok {
1894 r0 = returnFunc(ctx, app)
1895 } else {
1896 if ret.Get(0) != nil {
1897 r0 = ret.Get(0).(*dto.AppDeployResponse)
1898 }
1899 }
1900 if returnFunc, ok := ret.Get(1).(func(context.Context, string) string); ok {
1901 r1 = returnFunc(ctx, app)
1902 } else {
1903 r1 = ret.Get(1).(string)
1904 }
1905 if returnFunc, ok := ret.Get(2).(func(context.Context, string) error); ok {
1906 r2 = returnFunc(ctx, app)
1907 } else {
1908 r2 = ret.Error(2)
1909 }
1910 return r0, r1, r2
1911}
1912
1913// MockControlPlane_StartApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartApp'
1914type MockControlPlane_StartApp_Call struct {
1915 *mock.Call
1916}
1917
1918// StartApp is a helper method to define mock.On call
1919// - ctx context.Context
1920// - app string
1921func (_e *MockControlPlane_Expecter) StartApp(ctx any, app any) *MockControlPlane_StartApp_Call {
1922 return &MockControlPlane_StartApp_Call{Call: _e.mock.On("StartApp", ctx, app)}
1923}
1924
1925func (_c *MockControlPlane_StartApp_Call) Run(run func(ctx context.Context, app string)) *MockControlPlane_StartApp_Call {
1926 _c.Call.Run(func(args mock.Arguments) {
1927 var arg0 context.Context
1928 if args[0] != nil {
1929 arg0 = args[0].(context.Context)
1930 }
1931 var arg1 string
1932 if args[1] != nil {
1933 arg1 = args[1].(string)
1934 }
1935 run(
1936 arg0,
1937 arg1,
1938 )
1939 })
1940 return _c
1941}
1942
1943func (_c *MockControlPlane_StartApp_Call) Return(appDeployResponse *dto.AppDeployResponse, s string, err error) *MockControlPlane_StartApp_Call {
1944 _c.Call.Return(appDeployResponse, s, err)
1945 return _c
1946}
1947
1948func (_c *MockControlPlane_StartApp_Call) RunAndReturn(run func(ctx context.Context, app string) (*dto.AppDeployResponse, string, error)) *MockControlPlane_StartApp_Call {
1949 _c.Call.Return(run)
1950 return _c
1951}
1952
1953// StopApp provides a mock function for the type MockControlPlane
1954func (_mock *MockControlPlane) StopApp(ctx context.Context, app string) (*dto.AppDeployResponse, string, error) {
1955 ret := _mock.Called(ctx, app)
1956
1957 if len(ret) == 0 {
1958 panic("no return value specified for StopApp")
1959 }
1960
1961 var r0 *dto.AppDeployResponse
1962 var r1 string
1963 var r2 error
1964 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*dto.AppDeployResponse, string, error)); ok {
1965 return returnFunc(ctx, app)
1966 }
1967 if returnFunc, ok := ret.Get(0).(func(context.Context, string) *dto.AppDeployResponse); ok {
1968 r0 = returnFunc(ctx, app)
1969 } else {
1970 if ret.Get(0) != nil {
1971 r0 = ret.Get(0).(*dto.AppDeployResponse)
1972 }
1973 }
1974 if returnFunc, ok := ret.Get(1).(func(context.Context, string) string); ok {
1975 r1 = returnFunc(ctx, app)
1976 } else {
1977 r1 = ret.Get(1).(string)
1978 }
1979 if returnFunc, ok := ret.Get(2).(func(context.Context, string) error); ok {
1980 r2 = returnFunc(ctx, app)
1981 } else {
1982 r2 = ret.Error(2)
1983 }
1984 return r0, r1, r2
1985}
1986
1987// MockControlPlane_StopApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StopApp'
1988type MockControlPlane_StopApp_Call struct {
1989 *mock.Call
1990}
1991
1992// StopApp is a helper method to define mock.On call
1993// - ctx context.Context
1994// - app string
1995func (_e *MockControlPlane_Expecter) StopApp(ctx any, app any) *MockControlPlane_StopApp_Call {
1996 return &MockControlPlane_StopApp_Call{Call: _e.mock.On("StopApp", ctx, app)}
1997}
1998
1999func (_c *MockControlPlane_StopApp_Call) Run(run func(ctx context.Context, app string)) *MockControlPlane_StopApp_Call {
2000 _c.Call.Run(func(args mock.Arguments) {
2001 var arg0 context.Context
2002 if args[0] != nil {
2003 arg0 = args[0].(context.Context)
2004 }
2005 var arg1 string
2006 if args[1] != nil {
2007 arg1 = args[1].(string)
2008 }
2009 run(
2010 arg0,
2011 arg1,
2012 )
2013 })
2014 return _c
2015}
2016
2017func (_c *MockControlPlane_StopApp_Call) Return(appDeployResponse *dto.AppDeployResponse, s string, err error) *MockControlPlane_StopApp_Call {
2018 _c.Call.Return(appDeployResponse, s, err)
2019 return _c
2020}
2021
2022func (_c *MockControlPlane_StopApp_Call) RunAndReturn(run func(ctx context.Context, app string) (*dto.AppDeployResponse, string, error)) *MockControlPlane_StopApp_Call {
2023 _c.Call.Return(run)
2024 return _c
2025}
2026
2027// StreamProcessLogs provides a mock function for the type MockControlPlane
2028func (_mock *MockControlPlane) StreamProcessLogs(ctx context.Context, lines int) (<-chan string, error) {
2029 ret := _mock.Called(ctx, lines)
2030
2031 if len(ret) == 0 {
2032 panic("no return value specified for StreamProcessLogs")
2033 }
2034
2035 var r0 <-chan string
2036 var r1 error
2037 if returnFunc, ok := ret.Get(0).(func(context.Context, int) (<-chan string, error)); ok {
2038 return returnFunc(ctx, lines)
2039 }
2040 if returnFunc, ok := ret.Get(0).(func(context.Context, int) <-chan string); ok {
2041 r0 = returnFunc(ctx, lines)
2042 } else {
2043 if ret.Get(0) != nil {
2044 r0 = ret.Get(0).(<-chan string)
2045 }
2046 }
2047 if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
2048 r1 = returnFunc(ctx, lines)
2049 } else {
2050 r1 = ret.Error(1)
2051 }
2052 return r0, r1
2053}
2054
2055// MockControlPlane_StreamProcessLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StreamProcessLogs'
2056type MockControlPlane_StreamProcessLogs_Call struct {
2057 *mock.Call
2058}
2059
2060// StreamProcessLogs is a helper method to define mock.On call
2061// - ctx context.Context
2062// - lines int
2063func (_e *MockControlPlane_Expecter) StreamProcessLogs(ctx any, lines any) *MockControlPlane_StreamProcessLogs_Call {
2064 return &MockControlPlane_StreamProcessLogs_Call{Call: _e.mock.On("StreamProcessLogs", ctx, lines)}
2065}
2066
2067func (_c *MockControlPlane_StreamProcessLogs_Call) Run(run func(ctx context.Context, lines int)) *MockControlPlane_StreamProcessLogs_Call {
2068 _c.Call.Run(func(args mock.Arguments) {
2069 var arg0 context.Context
2070 if args[0] != nil {
2071 arg0 = args[0].(context.Context)
2072 }
2073 var arg1 int
2074 if args[1] != nil {
2075 arg1 = args[1].(int)
2076 }
2077 run(
2078 arg0,
2079 arg1,
2080 )
2081 })
2082 return _c
2083}
2084
2085func (_c *MockControlPlane_StreamProcessLogs_Call) Return(stringCh <-chan string, err error) *MockControlPlane_StreamProcessLogs_Call {
2086 _c.Call.Return(stringCh, err)
2087 return _c
2088}
2089
2090func (_c *MockControlPlane_StreamProcessLogs_Call) RunAndReturn(run func(ctx context.Context, lines int) (<-chan string, error)) *MockControlPlane_StreamProcessLogs_Call {
2091 _c.Call.Return(run)
2092 return _c
2093}
2094
2095// VerifyAuth provides a mock function for the type MockControlPlane
2096func (_mock *MockControlPlane) VerifyAuth(ctx context.Context) (*dto.AuthVerifyResponse, error) {
2097 ret := _mock.Called(ctx)
2098
2099 if len(ret) == 0 {
2100 panic("no return value specified for VerifyAuth")
2101 }
2102
2103 var r0 *dto.AuthVerifyResponse
2104 var r1 error
2105 if returnFunc, ok := ret.Get(0).(func(context.Context) (*dto.AuthVerifyResponse, error)); ok {
2106 return returnFunc(ctx)
2107 }
2108 if returnFunc, ok := ret.Get(0).(func(context.Context) *dto.AuthVerifyResponse); ok {
2109 r0 = returnFunc(ctx)
2110 } else {
2111 if ret.Get(0) != nil {
2112 r0 = ret.Get(0).(*dto.AuthVerifyResponse)
2113 }
2114 }
2115 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
2116 r1 = returnFunc(ctx)
2117 } else {
2118 r1 = ret.Error(1)
2119 }
2120 return r0, r1
2121}
2122
2123// MockControlPlane_VerifyAuth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VerifyAuth'
2124type MockControlPlane_VerifyAuth_Call struct {
2125 *mock.Call
2126}
2127
2128// VerifyAuth is a helper method to define mock.On call
2129// - ctx context.Context
2130func (_e *MockControlPlane_Expecter) VerifyAuth(ctx any) *MockControlPlane_VerifyAuth_Call {
2131 return &MockControlPlane_VerifyAuth_Call{Call: _e.mock.On("VerifyAuth", ctx)}
2132}
2133
2134func (_c *MockControlPlane_VerifyAuth_Call) Run(run func(ctx context.Context)) *MockControlPlane_VerifyAuth_Call {
2135 _c.Call.Run(func(args mock.Arguments) {
2136 var arg0 context.Context
2137 if args[0] != nil {
2138 arg0 = args[0].(context.Context)
2139 }
2140 run(
2141 arg0,
2142 )
2143 })
2144 return _c
2145}
2146
2147func (_c *MockControlPlane_VerifyAuth_Call) Return(authVerifyResponse *dto.AuthVerifyResponse, err error) *MockControlPlane_VerifyAuth_Call {
2148 _c.Call.Return(authVerifyResponse, err)
2149 return _c
2150}
2151
2152func (_c *MockControlPlane_VerifyAuth_Call) RunAndReturn(run func(ctx context.Context) (*dto.AuthVerifyResponse, error)) *MockControlPlane_VerifyAuth_Call {
2153 _c.Call.Return(run)
2154 return _c
2155}
2156
2157// VolumeBackupStatus provides a mock function for the type MockControlPlane
2158func (_mock *MockControlPlane) VolumeBackupStatus(ctx context.Context) ([]dto.VolumeBackupJob, error) {
2159 ret := _mock.Called(ctx)
2160
2161 if len(ret) == 0 {
2162 panic("no return value specified for VolumeBackupStatus")
2163 }
2164
2165 var r0 []dto.VolumeBackupJob
2166 var r1 error
2167 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]dto.VolumeBackupJob, error)); ok {
2168 return returnFunc(ctx)
2169 }
2170 if returnFunc, ok := ret.Get(0).(func(context.Context) []dto.VolumeBackupJob); ok {
2171 r0 = returnFunc(ctx)
2172 } else {
2173 if ret.Get(0) != nil {
2174 r0 = ret.Get(0).([]dto.VolumeBackupJob)
2175 }
2176 }
2177 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
2178 r1 = returnFunc(ctx)
2179 } else {
2180 r1 = ret.Error(1)
2181 }
2182 return r0, r1
2183}
2184
2185// MockControlPlane_VolumeBackupStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VolumeBackupStatus'
2186type MockControlPlane_VolumeBackupStatus_Call struct {
2187 *mock.Call
2188}
2189
2190// VolumeBackupStatus is a helper method to define mock.On call
2191// - ctx context.Context
2192func (_e *MockControlPlane_Expecter) VolumeBackupStatus(ctx any) *MockControlPlane_VolumeBackupStatus_Call {
2193 return &MockControlPlane_VolumeBackupStatus_Call{Call: _e.mock.On("VolumeBackupStatus", ctx)}
2194}
2195
2196func (_c *MockControlPlane_VolumeBackupStatus_Call) Run(run func(ctx context.Context)) *MockControlPlane_VolumeBackupStatus_Call {
2197 _c.Call.Run(func(args mock.Arguments) {
2198 var arg0 context.Context
2199 if args[0] != nil {
2200 arg0 = args[0].(context.Context)
2201 }
2202 run(
2203 arg0,
2204 )
2205 })
2206 return _c
2207}
2208
2209func (_c *MockControlPlane_VolumeBackupStatus_Call) Return(volumeBackupJobs []dto.VolumeBackupJob, err error) *MockControlPlane_VolumeBackupStatus_Call {
2210 _c.Call.Return(volumeBackupJobs, err)
2211 return _c
2212}
2213
2214func (_c *MockControlPlane_VolumeBackupStatus_Call) RunAndReturn(run func(ctx context.Context) ([]dto.VolumeBackupJob, error)) *MockControlPlane_VolumeBackupStatus_Call {
2215 _c.Call.Return(run)
2216 return _c
2217}