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// GetConfig provides a mock function for the type MockControlPlane
394func (_mock *MockControlPlane) GetConfig(ctx context.Context) (*remote.Config, error) {
395 ret := _mock.Called(ctx)
396
397 if len(ret) == 0 {
398 panic("no return value specified for GetConfig")
399 }
400
401 var r0 *remote.Config
402 var r1 error
403 if returnFunc, ok := ret.Get(0).(func(context.Context) (*remote.Config, error)); ok {
404 return returnFunc(ctx)
405 }
406 if returnFunc, ok := ret.Get(0).(func(context.Context) *remote.Config); ok {
407 r0 = returnFunc(ctx)
408 } else {
409 if ret.Get(0) != nil {
410 r0 = ret.Get(0).(*remote.Config)
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_GetConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConfig'
422type MockControlPlane_GetConfig_Call struct {
423 *mock.Call
424}
425
426// GetConfig is a helper method to define mock.On call
427// - ctx context.Context
428func (_e *MockControlPlane_Expecter) GetConfig(ctx any) *MockControlPlane_GetConfig_Call {
429 return &MockControlPlane_GetConfig_Call{Call: _e.mock.On("GetConfig", ctx)}
430}
431
432func (_c *MockControlPlane_GetConfig_Call) Run(run func(ctx context.Context)) *MockControlPlane_GetConfig_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_GetConfig_Call) Return(config *remote.Config, err error) *MockControlPlane_GetConfig_Call {
446 _c.Call.Return(config, err)
447 return _c
448}
449
450func (_c *MockControlPlane_GetConfig_Call) RunAndReturn(run func(ctx context.Context) (*remote.Config, error)) *MockControlPlane_GetConfig_Call {
451 _c.Call.Return(run)
452 return _c
453}
454
455// GetProcessLogs provides a mock function for the type MockControlPlane
456func (_mock *MockControlPlane) GetProcessLogs(ctx context.Context, lines int) ([]string, error) {
457 ret := _mock.Called(ctx, lines)
458
459 if len(ret) == 0 {
460 panic("no return value specified for GetProcessLogs")
461 }
462
463 var r0 []string
464 var r1 error
465 if returnFunc, ok := ret.Get(0).(func(context.Context, int) ([]string, error)); ok {
466 return returnFunc(ctx, lines)
467 }
468 if returnFunc, ok := ret.Get(0).(func(context.Context, int) []string); ok {
469 r0 = returnFunc(ctx, lines)
470 } else {
471 if ret.Get(0) != nil {
472 r0 = ret.Get(0).([]string)
473 }
474 }
475 if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
476 r1 = returnFunc(ctx, lines)
477 } else {
478 r1 = ret.Error(1)
479 }
480 return r0, r1
481}
482
483// MockControlPlane_GetProcessLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProcessLogs'
484type MockControlPlane_GetProcessLogs_Call struct {
485 *mock.Call
486}
487
488// GetProcessLogs is a helper method to define mock.On call
489// - ctx context.Context
490// - lines int
491func (_e *MockControlPlane_Expecter) GetProcessLogs(ctx any, lines any) *MockControlPlane_GetProcessLogs_Call {
492 return &MockControlPlane_GetProcessLogs_Call{Call: _e.mock.On("GetProcessLogs", ctx, lines)}
493}
494
495func (_c *MockControlPlane_GetProcessLogs_Call) Run(run func(ctx context.Context, lines int)) *MockControlPlane_GetProcessLogs_Call {
496 _c.Call.Run(func(args mock.Arguments) {
497 var arg0 context.Context
498 if args[0] != nil {
499 arg0 = args[0].(context.Context)
500 }
501 var arg1 int
502 if args[1] != nil {
503 arg1 = args[1].(int)
504 }
505 run(
506 arg0,
507 arg1,
508 )
509 })
510 return _c
511}
512
513func (_c *MockControlPlane_GetProcessLogs_Call) Return(strings []string, err error) *MockControlPlane_GetProcessLogs_Call {
514 _c.Call.Return(strings, err)
515 return _c
516}
517
518func (_c *MockControlPlane_GetProcessLogs_Call) RunAndReturn(run func(ctx context.Context, lines int) ([]string, error)) *MockControlPlane_GetProcessLogs_Call {
519 _c.Call.Return(run)
520 return _c
521}
522
523// GetStatus provides a mock function for the type MockControlPlane
524func (_mock *MockControlPlane) GetStatus(ctx context.Context) (*remote.Status, error) {
525 ret := _mock.Called(ctx)
526
527 if len(ret) == 0 {
528 panic("no return value specified for GetStatus")
529 }
530
531 var r0 *remote.Status
532 var r1 error
533 if returnFunc, ok := ret.Get(0).(func(context.Context) (*remote.Status, error)); ok {
534 return returnFunc(ctx)
535 }
536 if returnFunc, ok := ret.Get(0).(func(context.Context) *remote.Status); ok {
537 r0 = returnFunc(ctx)
538 } else {
539 if ret.Get(0) != nil {
540 r0 = ret.Get(0).(*remote.Status)
541 }
542 }
543 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
544 r1 = returnFunc(ctx)
545 } else {
546 r1 = ret.Error(1)
547 }
548 return r0, r1
549}
550
551// MockControlPlane_GetStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStatus'
552type MockControlPlane_GetStatus_Call struct {
553 *mock.Call
554}
555
556// GetStatus is a helper method to define mock.On call
557// - ctx context.Context
558func (_e *MockControlPlane_Expecter) GetStatus(ctx any) *MockControlPlane_GetStatus_Call {
559 return &MockControlPlane_GetStatus_Call{Call: _e.mock.On("GetStatus", ctx)}
560}
561
562func (_c *MockControlPlane_GetStatus_Call) Run(run func(ctx context.Context)) *MockControlPlane_GetStatus_Call {
563 _c.Call.Run(func(args mock.Arguments) {
564 var arg0 context.Context
565 if args[0] != nil {
566 arg0 = args[0].(context.Context)
567 }
568 run(
569 arg0,
570 )
571 })
572 return _c
573}
574
575func (_c *MockControlPlane_GetStatus_Call) Return(status *remote.Status, err error) *MockControlPlane_GetStatus_Call {
576 _c.Call.Return(status, err)
577 return _c
578}
579
580func (_c *MockControlPlane_GetStatus_Call) RunAndReturn(run func(ctx context.Context) (*remote.Status, error)) *MockControlPlane_GetStatus_Call {
581 _c.Call.Return(run)
582 return _c
583}
584
585// GetTLSStatus provides a mock function for the type MockControlPlane
586func (_mock *MockControlPlane) GetTLSStatus(ctx context.Context) (*dto.TLSStatusResponse, error) {
587 ret := _mock.Called(ctx)
588
589 if len(ret) == 0 {
590 panic("no return value specified for GetTLSStatus")
591 }
592
593 var r0 *dto.TLSStatusResponse
594 var r1 error
595 if returnFunc, ok := ret.Get(0).(func(context.Context) (*dto.TLSStatusResponse, error)); ok {
596 return returnFunc(ctx)
597 }
598 if returnFunc, ok := ret.Get(0).(func(context.Context) *dto.TLSStatusResponse); ok {
599 r0 = returnFunc(ctx)
600 } else {
601 if ret.Get(0) != nil {
602 r0 = ret.Get(0).(*dto.TLSStatusResponse)
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_GetTLSStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTLSStatus'
614type MockControlPlane_GetTLSStatus_Call struct {
615 *mock.Call
616}
617
618// GetTLSStatus is a helper method to define mock.On call
619// - ctx context.Context
620func (_e *MockControlPlane_Expecter) GetTLSStatus(ctx any) *MockControlPlane_GetTLSStatus_Call {
621 return &MockControlPlane_GetTLSStatus_Call{Call: _e.mock.On("GetTLSStatus", ctx)}
622}
623
624func (_c *MockControlPlane_GetTLSStatus_Call) Run(run func(ctx context.Context)) *MockControlPlane_GetTLSStatus_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_GetTLSStatus_Call) Return(tLSStatusResponse *dto.TLSStatusResponse, err error) *MockControlPlane_GetTLSStatus_Call {
638 _c.Call.Return(tLSStatusResponse, err)
639 return _c
640}
641
642func (_c *MockControlPlane_GetTLSStatus_Call) RunAndReturn(run func(ctx context.Context) (*dto.TLSStatusResponse, error)) *MockControlPlane_GetTLSStatus_Call {
643 _c.Call.Return(run)
644 return _c
645}
646
647// GetTrafficStatus provides a mock function for the type MockControlPlane
648func (_mock *MockControlPlane) GetTrafficStatus(ctx context.Context) (*dto.TrafficStatusResponse, error) {
649 ret := _mock.Called(ctx)
650
651 if len(ret) == 0 {
652 panic("no return value specified for GetTrafficStatus")
653 }
654
655 var r0 *dto.TrafficStatusResponse
656 var r1 error
657 if returnFunc, ok := ret.Get(0).(func(context.Context) (*dto.TrafficStatusResponse, error)); ok {
658 return returnFunc(ctx)
659 }
660 if returnFunc, ok := ret.Get(0).(func(context.Context) *dto.TrafficStatusResponse); ok {
661 r0 = returnFunc(ctx)
662 } else {
663 if ret.Get(0) != nil {
664 r0 = ret.Get(0).(*dto.TrafficStatusResponse)
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_GetTrafficStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTrafficStatus'
676type MockControlPlane_GetTrafficStatus_Call struct {
677 *mock.Call
678}
679
680// GetTrafficStatus is a helper method to define mock.On call
681// - ctx context.Context
682func (_e *MockControlPlane_Expecter) GetTrafficStatus(ctx any) *MockControlPlane_GetTrafficStatus_Call {
683 return &MockControlPlane_GetTrafficStatus_Call{Call: _e.mock.On("GetTrafficStatus", ctx)}
684}
685
686func (_c *MockControlPlane_GetTrafficStatus_Call) Run(run func(ctx context.Context)) *MockControlPlane_GetTrafficStatus_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_GetTrafficStatus_Call) Return(trafficStatusResponse *dto.TrafficStatusResponse, err error) *MockControlPlane_GetTrafficStatus_Call {
700 _c.Call.Return(trafficStatusResponse, err)
701 return _c
702}
703
704func (_c *MockControlPlane_GetTrafficStatus_Call) RunAndReturn(run func(ctx context.Context) (*dto.TrafficStatusResponse, error)) *MockControlPlane_GetTrafficStatus_Call {
705 _c.Call.Return(run)
706 return _c
707}
708
709// ListAppSecrets provides a mock function for the type MockControlPlane
710func (_mock *MockControlPlane) ListAppSecrets(ctx context.Context, app string, service string) ([]dto.AppSecretMetadataDTO, error) {
711 ret := _mock.Called(ctx, app, service)
712
713 if len(ret) == 0 {
714 panic("no return value specified for ListAppSecrets")
715 }
716
717 var r0 []dto.AppSecretMetadataDTO
718 var r1 error
719 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]dto.AppSecretMetadataDTO, error)); ok {
720 return returnFunc(ctx, app, service)
721 }
722 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []dto.AppSecretMetadataDTO); ok {
723 r0 = returnFunc(ctx, app, service)
724 } else {
725 if ret.Get(0) != nil {
726 r0 = ret.Get(0).([]dto.AppSecretMetadataDTO)
727 }
728 }
729 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
730 r1 = returnFunc(ctx, app, service)
731 } else {
732 r1 = ret.Error(1)
733 }
734 return r0, r1
735}
736
737// MockControlPlane_ListAppSecrets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAppSecrets'
738type MockControlPlane_ListAppSecrets_Call struct {
739 *mock.Call
740}
741
742// ListAppSecrets is a helper method to define mock.On call
743// - ctx context.Context
744// - app string
745// - service string
746func (_e *MockControlPlane_Expecter) ListAppSecrets(ctx any, app any, service any) *MockControlPlane_ListAppSecrets_Call {
747 return &MockControlPlane_ListAppSecrets_Call{Call: _e.mock.On("ListAppSecrets", ctx, app, service)}
748}
749
750func (_c *MockControlPlane_ListAppSecrets_Call) Run(run func(ctx context.Context, app string, service string)) *MockControlPlane_ListAppSecrets_Call {
751 _c.Call.Run(func(args mock.Arguments) {
752 var arg0 context.Context
753 if args[0] != nil {
754 arg0 = args[0].(context.Context)
755 }
756 var arg1 string
757 if args[1] != nil {
758 arg1 = args[1].(string)
759 }
760 var arg2 string
761 if args[2] != nil {
762 arg2 = args[2].(string)
763 }
764 run(
765 arg0,
766 arg1,
767 arg2,
768 )
769 })
770 return _c
771}
772
773func (_c *MockControlPlane_ListAppSecrets_Call) Return(appSecretMetadataDTOs []dto.AppSecretMetadataDTO, err error) *MockControlPlane_ListAppSecrets_Call {
774 _c.Call.Return(appSecretMetadataDTOs, err)
775 return _c
776}
777
778func (_c *MockControlPlane_ListAppSecrets_Call) RunAndReturn(run func(ctx context.Context, app string, service string) ([]dto.AppSecretMetadataDTO, error)) *MockControlPlane_ListAppSecrets_Call {
779 _c.Call.Return(run)
780 return _c
781}
782
783// ListApps provides a mock function for the type MockControlPlane
784func (_mock *MockControlPlane) ListApps(ctx context.Context) ([]dto.AppSummaryDTO, error) {
785 ret := _mock.Called(ctx)
786
787 if len(ret) == 0 {
788 panic("no return value specified for ListApps")
789 }
790
791 var r0 []dto.AppSummaryDTO
792 var r1 error
793 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]dto.AppSummaryDTO, error)); ok {
794 return returnFunc(ctx)
795 }
796 if returnFunc, ok := ret.Get(0).(func(context.Context) []dto.AppSummaryDTO); ok {
797 r0 = returnFunc(ctx)
798 } else {
799 if ret.Get(0) != nil {
800 r0 = ret.Get(0).([]dto.AppSummaryDTO)
801 }
802 }
803 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
804 r1 = returnFunc(ctx)
805 } else {
806 r1 = ret.Error(1)
807 }
808 return r0, r1
809}
810
811// MockControlPlane_ListApps_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListApps'
812type MockControlPlane_ListApps_Call struct {
813 *mock.Call
814}
815
816// ListApps is a helper method to define mock.On call
817// - ctx context.Context
818func (_e *MockControlPlane_Expecter) ListApps(ctx any) *MockControlPlane_ListApps_Call {
819 return &MockControlPlane_ListApps_Call{Call: _e.mock.On("ListApps", ctx)}
820}
821
822func (_c *MockControlPlane_ListApps_Call) Run(run func(ctx context.Context)) *MockControlPlane_ListApps_Call {
823 _c.Call.Run(func(args mock.Arguments) {
824 var arg0 context.Context
825 if args[0] != nil {
826 arg0 = args[0].(context.Context)
827 }
828 run(
829 arg0,
830 )
831 })
832 return _c
833}
834
835func (_c *MockControlPlane_ListApps_Call) Return(appSummaryDTOs []dto.AppSummaryDTO, err error) *MockControlPlane_ListApps_Call {
836 _c.Call.Return(appSummaryDTOs, err)
837 return _c
838}
839
840func (_c *MockControlPlane_ListApps_Call) RunAndReturn(run func(ctx context.Context) ([]dto.AppSummaryDTO, error)) *MockControlPlane_ListApps_Call {
841 _c.Call.Return(run)
842 return _c
843}
844
845// ListBackups provides a mock function for the type MockControlPlane
846func (_mock *MockControlPlane) ListBackups(ctx context.Context, app string) ([]dto.BackupJob, error) {
847 ret := _mock.Called(ctx, app)
848
849 if len(ret) == 0 {
850 panic("no return value specified for ListBackups")
851 }
852
853 var r0 []dto.BackupJob
854 var r1 error
855 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]dto.BackupJob, error)); ok {
856 return returnFunc(ctx, app)
857 }
858 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []dto.BackupJob); ok {
859 r0 = returnFunc(ctx, app)
860 } else {
861 if ret.Get(0) != nil {
862 r0 = ret.Get(0).([]dto.BackupJob)
863 }
864 }
865 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
866 r1 = returnFunc(ctx, app)
867 } else {
868 r1 = ret.Error(1)
869 }
870 return r0, r1
871}
872
873// MockControlPlane_ListBackups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBackups'
874type MockControlPlane_ListBackups_Call struct {
875 *mock.Call
876}
877
878// ListBackups is a helper method to define mock.On call
879// - ctx context.Context
880// - app string
881func (_e *MockControlPlane_Expecter) ListBackups(ctx any, app any) *MockControlPlane_ListBackups_Call {
882 return &MockControlPlane_ListBackups_Call{Call: _e.mock.On("ListBackups", ctx, app)}
883}
884
885func (_c *MockControlPlane_ListBackups_Call) Run(run func(ctx context.Context, app string)) *MockControlPlane_ListBackups_Call {
886 _c.Call.Run(func(args mock.Arguments) {
887 var arg0 context.Context
888 if args[0] != nil {
889 arg0 = args[0].(context.Context)
890 }
891 var arg1 string
892 if args[1] != nil {
893 arg1 = args[1].(string)
894 }
895 run(
896 arg0,
897 arg1,
898 )
899 })
900 return _c
901}
902
903func (_c *MockControlPlane_ListBackups_Call) Return(backupJobs []dto.BackupJob, err error) *MockControlPlane_ListBackups_Call {
904 _c.Call.Return(backupJobs, err)
905 return _c
906}
907
908func (_c *MockControlPlane_ListBackups_Call) RunAndReturn(run func(ctx context.Context, app string) ([]dto.BackupJob, error)) *MockControlPlane_ListBackups_Call {
909 _c.Call.Return(run)
910 return _c
911}
912
913// ListNetworks provides a mock function for the type MockControlPlane
914func (_mock *MockControlPlane) ListNetworks(ctx context.Context) ([]*domain.NetworkInfo, error) {
915 ret := _mock.Called(ctx)
916
917 if len(ret) == 0 {
918 panic("no return value specified for ListNetworks")
919 }
920
921 var r0 []*domain.NetworkInfo
922 var r1 error
923 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*domain.NetworkInfo, error)); ok {
924 return returnFunc(ctx)
925 }
926 if returnFunc, ok := ret.Get(0).(func(context.Context) []*domain.NetworkInfo); ok {
927 r0 = returnFunc(ctx)
928 } else {
929 if ret.Get(0) != nil {
930 r0 = ret.Get(0).([]*domain.NetworkInfo)
931 }
932 }
933 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
934 r1 = returnFunc(ctx)
935 } else {
936 r1 = ret.Error(1)
937 }
938 return r0, r1
939}
940
941// MockControlPlane_ListNetworks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListNetworks'
942type MockControlPlane_ListNetworks_Call struct {
943 *mock.Call
944}
945
946// ListNetworks is a helper method to define mock.On call
947// - ctx context.Context
948func (_e *MockControlPlane_Expecter) ListNetworks(ctx any) *MockControlPlane_ListNetworks_Call {
949 return &MockControlPlane_ListNetworks_Call{Call: _e.mock.On("ListNetworks", ctx)}
950}
951
952func (_c *MockControlPlane_ListNetworks_Call) Run(run func(ctx context.Context)) *MockControlPlane_ListNetworks_Call {
953 _c.Call.Run(func(args mock.Arguments) {
954 var arg0 context.Context
955 if args[0] != nil {
956 arg0 = args[0].(context.Context)
957 }
958 run(
959 arg0,
960 )
961 })
962 return _c
963}
964
965func (_c *MockControlPlane_ListNetworks_Call) Return(networkInfos []*domain.NetworkInfo, err error) *MockControlPlane_ListNetworks_Call {
966 _c.Call.Return(networkInfos, err)
967 return _c
968}
969
970func (_c *MockControlPlane_ListNetworks_Call) RunAndReturn(run func(ctx context.Context) ([]*domain.NetworkInfo, error)) *MockControlPlane_ListNetworks_Call {
971 _c.Call.Return(run)
972 return _c
973}
974
975// ListTags provides a mock function for the type MockControlPlane
976func (_mock *MockControlPlane) ListTags(ctx context.Context, repository string) ([]string, error) {
977 ret := _mock.Called(ctx, repository)
978
979 if len(ret) == 0 {
980 panic("no return value specified for ListTags")
981 }
982
983 var r0 []string
984 var r1 error
985 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]string, error)); ok {
986 return returnFunc(ctx, repository)
987 }
988 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []string); ok {
989 r0 = returnFunc(ctx, repository)
990 } else {
991 if ret.Get(0) != nil {
992 r0 = ret.Get(0).([]string)
993 }
994 }
995 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
996 r1 = returnFunc(ctx, repository)
997 } else {
998 r1 = ret.Error(1)
999 }
1000 return r0, r1
1001}
1002
1003// MockControlPlane_ListTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTags'
1004type MockControlPlane_ListTags_Call struct {
1005 *mock.Call
1006}
1007
1008// ListTags is a helper method to define mock.On call
1009// - ctx context.Context
1010// - repository string
1011func (_e *MockControlPlane_Expecter) ListTags(ctx any, repository any) *MockControlPlane_ListTags_Call {
1012 return &MockControlPlane_ListTags_Call{Call: _e.mock.On("ListTags", ctx, repository)}
1013}
1014
1015func (_c *MockControlPlane_ListTags_Call) Run(run func(ctx context.Context, repository string)) *MockControlPlane_ListTags_Call {
1016 _c.Call.Run(func(args mock.Arguments) {
1017 var arg0 context.Context
1018 if args[0] != nil {
1019 arg0 = args[0].(context.Context)
1020 }
1021 var arg1 string
1022 if args[1] != nil {
1023 arg1 = args[1].(string)
1024 }
1025 run(
1026 arg0,
1027 arg1,
1028 )
1029 })
1030 return _c
1031}
1032
1033func (_c *MockControlPlane_ListTags_Call) Return(strings []string, err error) *MockControlPlane_ListTags_Call {
1034 _c.Call.Return(strings, err)
1035 return _c
1036}
1037
1038func (_c *MockControlPlane_ListTags_Call) RunAndReturn(run func(ctx context.Context, repository string) ([]string, error)) *MockControlPlane_ListTags_Call {
1039 _c.Call.Return(run)
1040 return _c
1041}
1042
1043// ListVolumeBackups provides a mock function for the type MockControlPlane
1044func (_mock *MockControlPlane) ListVolumeBackups(ctx context.Context, app string) ([]dto.VolumeBackupJob, error) {
1045 ret := _mock.Called(ctx, app)
1046
1047 if len(ret) == 0 {
1048 panic("no return value specified for ListVolumeBackups")
1049 }
1050
1051 var r0 []dto.VolumeBackupJob
1052 var r1 error
1053 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]dto.VolumeBackupJob, error)); ok {
1054 return returnFunc(ctx, app)
1055 }
1056 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []dto.VolumeBackupJob); ok {
1057 r0 = returnFunc(ctx, app)
1058 } else {
1059 if ret.Get(0) != nil {
1060 r0 = ret.Get(0).([]dto.VolumeBackupJob)
1061 }
1062 }
1063 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
1064 r1 = returnFunc(ctx, app)
1065 } else {
1066 r1 = ret.Error(1)
1067 }
1068 return r0, r1
1069}
1070
1071// MockControlPlane_ListVolumeBackups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVolumeBackups'
1072type MockControlPlane_ListVolumeBackups_Call struct {
1073 *mock.Call
1074}
1075
1076// ListVolumeBackups is a helper method to define mock.On call
1077// - ctx context.Context
1078// - app string
1079func (_e *MockControlPlane_Expecter) ListVolumeBackups(ctx any, app any) *MockControlPlane_ListVolumeBackups_Call {
1080 return &MockControlPlane_ListVolumeBackups_Call{Call: _e.mock.On("ListVolumeBackups", ctx, app)}
1081}
1082
1083func (_c *MockControlPlane_ListVolumeBackups_Call) Run(run func(ctx context.Context, app string)) *MockControlPlane_ListVolumeBackups_Call {
1084 _c.Call.Run(func(args mock.Arguments) {
1085 var arg0 context.Context
1086 if args[0] != nil {
1087 arg0 = args[0].(context.Context)
1088 }
1089 var arg1 string
1090 if args[1] != nil {
1091 arg1 = args[1].(string)
1092 }
1093 run(
1094 arg0,
1095 arg1,
1096 )
1097 })
1098 return _c
1099}
1100
1101func (_c *MockControlPlane_ListVolumeBackups_Call) Return(volumeBackupJobs []dto.VolumeBackupJob, err error) *MockControlPlane_ListVolumeBackups_Call {
1102 _c.Call.Return(volumeBackupJobs, err)
1103 return _c
1104}
1105
1106func (_c *MockControlPlane_ListVolumeBackups_Call) RunAndReturn(run func(ctx context.Context, app string) ([]dto.VolumeBackupJob, error)) *MockControlPlane_ListVolumeBackups_Call {
1107 _c.Call.Return(run)
1108 return _c
1109}
1110
1111// ListVolumes provides a mock function for the type MockControlPlane
1112func (_mock *MockControlPlane) ListVolumes(ctx context.Context) ([]dto.Volume, error) {
1113 ret := _mock.Called(ctx)
1114
1115 if len(ret) == 0 {
1116 panic("no return value specified for ListVolumes")
1117 }
1118
1119 var r0 []dto.Volume
1120 var r1 error
1121 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]dto.Volume, error)); ok {
1122 return returnFunc(ctx)
1123 }
1124 if returnFunc, ok := ret.Get(0).(func(context.Context) []dto.Volume); ok {
1125 r0 = returnFunc(ctx)
1126 } else {
1127 if ret.Get(0) != nil {
1128 r0 = ret.Get(0).([]dto.Volume)
1129 }
1130 }
1131 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1132 r1 = returnFunc(ctx)
1133 } else {
1134 r1 = ret.Error(1)
1135 }
1136 return r0, r1
1137}
1138
1139// MockControlPlane_ListVolumes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVolumes'
1140type MockControlPlane_ListVolumes_Call struct {
1141 *mock.Call
1142}
1143
1144// ListVolumes is a helper method to define mock.On call
1145// - ctx context.Context
1146func (_e *MockControlPlane_Expecter) ListVolumes(ctx any) *MockControlPlane_ListVolumes_Call {
1147 return &MockControlPlane_ListVolumes_Call{Call: _e.mock.On("ListVolumes", ctx)}
1148}
1149
1150func (_c *MockControlPlane_ListVolumes_Call) Run(run func(ctx context.Context)) *MockControlPlane_ListVolumes_Call {
1151 _c.Call.Run(func(args mock.Arguments) {
1152 var arg0 context.Context
1153 if args[0] != nil {
1154 arg0 = args[0].(context.Context)
1155 }
1156 run(
1157 arg0,
1158 )
1159 })
1160 return _c
1161}
1162
1163func (_c *MockControlPlane_ListVolumes_Call) Return(volumes []dto.Volume, err error) *MockControlPlane_ListVolumes_Call {
1164 _c.Call.Return(volumes, err)
1165 return _c
1166}
1167
1168func (_c *MockControlPlane_ListVolumes_Call) RunAndReturn(run func(ctx context.Context) ([]dto.Volume, error)) *MockControlPlane_ListVolumes_Call {
1169 _c.Call.Return(run)
1170 return _c
1171}
1172
1173// OperationByKey provides a mock function for the type MockControlPlane
1174func (_mock *MockControlPlane) OperationByKey(ctx context.Context, app string, key string) (*dto.AppDeployResponse, error) {
1175 ret := _mock.Called(ctx, app, key)
1176
1177 if len(ret) == 0 {
1178 panic("no return value specified for OperationByKey")
1179 }
1180
1181 var r0 *dto.AppDeployResponse
1182 var r1 error
1183 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*dto.AppDeployResponse, error)); ok {
1184 return returnFunc(ctx, app, key)
1185 }
1186 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *dto.AppDeployResponse); ok {
1187 r0 = returnFunc(ctx, app, key)
1188 } else {
1189 if ret.Get(0) != nil {
1190 r0 = ret.Get(0).(*dto.AppDeployResponse)
1191 }
1192 }
1193 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
1194 r1 = returnFunc(ctx, app, key)
1195 } else {
1196 r1 = ret.Error(1)
1197 }
1198 return r0, r1
1199}
1200
1201// MockControlPlane_OperationByKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OperationByKey'
1202type MockControlPlane_OperationByKey_Call struct {
1203 *mock.Call
1204}
1205
1206// OperationByKey is a helper method to define mock.On call
1207// - ctx context.Context
1208// - app string
1209// - key string
1210func (_e *MockControlPlane_Expecter) OperationByKey(ctx any, app any, key any) *MockControlPlane_OperationByKey_Call {
1211 return &MockControlPlane_OperationByKey_Call{Call: _e.mock.On("OperationByKey", ctx, app, key)}
1212}
1213
1214func (_c *MockControlPlane_OperationByKey_Call) Run(run func(ctx context.Context, app string, key string)) *MockControlPlane_OperationByKey_Call {
1215 _c.Call.Run(func(args mock.Arguments) {
1216 var arg0 context.Context
1217 if args[0] != nil {
1218 arg0 = args[0].(context.Context)
1219 }
1220 var arg1 string
1221 if args[1] != nil {
1222 arg1 = args[1].(string)
1223 }
1224 var arg2 string
1225 if args[2] != nil {
1226 arg2 = args[2].(string)
1227 }
1228 run(
1229 arg0,
1230 arg1,
1231 arg2,
1232 )
1233 })
1234 return _c
1235}
1236
1237func (_c *MockControlPlane_OperationByKey_Call) Return(appDeployResponse *dto.AppDeployResponse, err error) *MockControlPlane_OperationByKey_Call {
1238 _c.Call.Return(appDeployResponse, err)
1239 return _c
1240}
1241
1242func (_c *MockControlPlane_OperationByKey_Call) RunAndReturn(run func(ctx context.Context, app string, key string) (*dto.AppDeployResponse, error)) *MockControlPlane_OperationByKey_Call {
1243 _c.Call.Return(run)
1244 return _c
1245}
1246
1247// PruneVolumes provides a mock function for the type MockControlPlane
1248func (_mock *MockControlPlane) PruneVolumes(ctx context.Context, req dto.VolumePruneRequest) (*dto.VolumePruneResponse, error) {
1249 ret := _mock.Called(ctx, req)
1250
1251 if len(ret) == 0 {
1252 panic("no return value specified for PruneVolumes")
1253 }
1254
1255 var r0 *dto.VolumePruneResponse
1256 var r1 error
1257 if returnFunc, ok := ret.Get(0).(func(context.Context, dto.VolumePruneRequest) (*dto.VolumePruneResponse, error)); ok {
1258 return returnFunc(ctx, req)
1259 }
1260 if returnFunc, ok := ret.Get(0).(func(context.Context, dto.VolumePruneRequest) *dto.VolumePruneResponse); ok {
1261 r0 = returnFunc(ctx, req)
1262 } else {
1263 if ret.Get(0) != nil {
1264 r0 = ret.Get(0).(*dto.VolumePruneResponse)
1265 }
1266 }
1267 if returnFunc, ok := ret.Get(1).(func(context.Context, dto.VolumePruneRequest) error); ok {
1268 r1 = returnFunc(ctx, req)
1269 } else {
1270 r1 = ret.Error(1)
1271 }
1272 return r0, r1
1273}
1274
1275// MockControlPlane_PruneVolumes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PruneVolumes'
1276type MockControlPlane_PruneVolumes_Call struct {
1277 *mock.Call
1278}
1279
1280// PruneVolumes is a helper method to define mock.On call
1281// - ctx context.Context
1282// - req dto.VolumePruneRequest
1283func (_e *MockControlPlane_Expecter) PruneVolumes(ctx any, req any) *MockControlPlane_PruneVolumes_Call {
1284 return &MockControlPlane_PruneVolumes_Call{Call: _e.mock.On("PruneVolumes", ctx, req)}
1285}
1286
1287func (_c *MockControlPlane_PruneVolumes_Call) Run(run func(ctx context.Context, req dto.VolumePruneRequest)) *MockControlPlane_PruneVolumes_Call {
1288 _c.Call.Run(func(args mock.Arguments) {
1289 var arg0 context.Context
1290 if args[0] != nil {
1291 arg0 = args[0].(context.Context)
1292 }
1293 var arg1 dto.VolumePruneRequest
1294 if args[1] != nil {
1295 arg1 = args[1].(dto.VolumePruneRequest)
1296 }
1297 run(
1298 arg0,
1299 arg1,
1300 )
1301 })
1302 return _c
1303}
1304
1305func (_c *MockControlPlane_PruneVolumes_Call) Return(volumePruneResponse *dto.VolumePruneResponse, err error) *MockControlPlane_PruneVolumes_Call {
1306 _c.Call.Return(volumePruneResponse, err)
1307 return _c
1308}
1309
1310func (_c *MockControlPlane_PruneVolumes_Call) RunAndReturn(run func(ctx context.Context, req dto.VolumePruneRequest) (*dto.VolumePruneResponse, error)) *MockControlPlane_PruneVolumes_Call {
1311 _c.Call.Return(run)
1312 return _c
1313}
1314
1315// Reload provides a mock function for the type MockControlPlane
1316func (_mock *MockControlPlane) Reload(ctx context.Context) error {
1317 ret := _mock.Called(ctx)
1318
1319 if len(ret) == 0 {
1320 panic("no return value specified for Reload")
1321 }
1322
1323 var r0 error
1324 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1325 r0 = returnFunc(ctx)
1326 } else {
1327 r0 = ret.Error(0)
1328 }
1329 return r0
1330}
1331
1332// MockControlPlane_Reload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reload'
1333type MockControlPlane_Reload_Call struct {
1334 *mock.Call
1335}
1336
1337// Reload is a helper method to define mock.On call
1338// - ctx context.Context
1339func (_e *MockControlPlane_Expecter) Reload(ctx any) *MockControlPlane_Reload_Call {
1340 return &MockControlPlane_Reload_Call{Call: _e.mock.On("Reload", ctx)}
1341}
1342
1343func (_c *MockControlPlane_Reload_Call) Run(run func(ctx context.Context)) *MockControlPlane_Reload_Call {
1344 _c.Call.Run(func(args mock.Arguments) {
1345 var arg0 context.Context
1346 if args[0] != nil {
1347 arg0 = args[0].(context.Context)
1348 }
1349 run(
1350 arg0,
1351 )
1352 })
1353 return _c
1354}
1355
1356func (_c *MockControlPlane_Reload_Call) Return(err error) *MockControlPlane_Reload_Call {
1357 _c.Call.Return(err)
1358 return _c
1359}
1360
1361func (_c *MockControlPlane_Reload_Call) RunAndReturn(run func(ctx context.Context) error) *MockControlPlane_Reload_Call {
1362 _c.Call.Return(run)
1363 return _c
1364}
1365
1366// RemoveApp provides a mock function for the type MockControlPlane
1367func (_mock *MockControlPlane) RemoveApp(ctx context.Context, app string) (*dto.AppDeployResponse, string, error) {
1368 ret := _mock.Called(ctx, app)
1369
1370 if len(ret) == 0 {
1371 panic("no return value specified for RemoveApp")
1372 }
1373
1374 var r0 *dto.AppDeployResponse
1375 var r1 string
1376 var r2 error
1377 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*dto.AppDeployResponse, string, error)); ok {
1378 return returnFunc(ctx, app)
1379 }
1380 if returnFunc, ok := ret.Get(0).(func(context.Context, string) *dto.AppDeployResponse); ok {
1381 r0 = returnFunc(ctx, app)
1382 } else {
1383 if ret.Get(0) != nil {
1384 r0 = ret.Get(0).(*dto.AppDeployResponse)
1385 }
1386 }
1387 if returnFunc, ok := ret.Get(1).(func(context.Context, string) string); ok {
1388 r1 = returnFunc(ctx, app)
1389 } else {
1390 r1 = ret.Get(1).(string)
1391 }
1392 if returnFunc, ok := ret.Get(2).(func(context.Context, string) error); ok {
1393 r2 = returnFunc(ctx, app)
1394 } else {
1395 r2 = ret.Error(2)
1396 }
1397 return r0, r1, r2
1398}
1399
1400// MockControlPlane_RemoveApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveApp'
1401type MockControlPlane_RemoveApp_Call struct {
1402 *mock.Call
1403}
1404
1405// RemoveApp is a helper method to define mock.On call
1406// - ctx context.Context
1407// - app string
1408func (_e *MockControlPlane_Expecter) RemoveApp(ctx any, app any) *MockControlPlane_RemoveApp_Call {
1409 return &MockControlPlane_RemoveApp_Call{Call: _e.mock.On("RemoveApp", ctx, app)}
1410}
1411
1412func (_c *MockControlPlane_RemoveApp_Call) Run(run func(ctx context.Context, app string)) *MockControlPlane_RemoveApp_Call {
1413 _c.Call.Run(func(args mock.Arguments) {
1414 var arg0 context.Context
1415 if args[0] != nil {
1416 arg0 = args[0].(context.Context)
1417 }
1418 var arg1 string
1419 if args[1] != nil {
1420 arg1 = args[1].(string)
1421 }
1422 run(
1423 arg0,
1424 arg1,
1425 )
1426 })
1427 return _c
1428}
1429
1430func (_c *MockControlPlane_RemoveApp_Call) Return(appDeployResponse *dto.AppDeployResponse, s string, err error) *MockControlPlane_RemoveApp_Call {
1431 _c.Call.Return(appDeployResponse, s, err)
1432 return _c
1433}
1434
1435func (_c *MockControlPlane_RemoveApp_Call) RunAndReturn(run func(ctx context.Context, app string) (*dto.AppDeployResponse, string, error)) *MockControlPlane_RemoveApp_Call {
1436 _c.Call.Return(run)
1437 return _c
1438}
1439
1440// RestartApp provides a mock function for the type MockControlPlane
1441func (_mock *MockControlPlane) RestartApp(ctx context.Context, app string, service string, all bool) (*dto.AppDeployResponse, string, error) {
1442 ret := _mock.Called(ctx, app, service, all)
1443
1444 if len(ret) == 0 {
1445 panic("no return value specified for RestartApp")
1446 }
1447
1448 var r0 *dto.AppDeployResponse
1449 var r1 string
1450 var r2 error
1451 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, bool) (*dto.AppDeployResponse, string, error)); ok {
1452 return returnFunc(ctx, app, service, all)
1453 }
1454 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, bool) *dto.AppDeployResponse); ok {
1455 r0 = returnFunc(ctx, app, service, all)
1456 } else {
1457 if ret.Get(0) != nil {
1458 r0 = ret.Get(0).(*dto.AppDeployResponse)
1459 }
1460 }
1461 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, bool) string); ok {
1462 r1 = returnFunc(ctx, app, service, all)
1463 } else {
1464 r1 = ret.Get(1).(string)
1465 }
1466 if returnFunc, ok := ret.Get(2).(func(context.Context, string, string, bool) error); ok {
1467 r2 = returnFunc(ctx, app, service, all)
1468 } else {
1469 r2 = ret.Error(2)
1470 }
1471 return r0, r1, r2
1472}
1473
1474// MockControlPlane_RestartApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestartApp'
1475type MockControlPlane_RestartApp_Call struct {
1476 *mock.Call
1477}
1478
1479// RestartApp is a helper method to define mock.On call
1480// - ctx context.Context
1481// - app string
1482// - service string
1483// - all bool
1484func (_e *MockControlPlane_Expecter) RestartApp(ctx any, app any, service any, all any) *MockControlPlane_RestartApp_Call {
1485 return &MockControlPlane_RestartApp_Call{Call: _e.mock.On("RestartApp", ctx, app, service, all)}
1486}
1487
1488func (_c *MockControlPlane_RestartApp_Call) Run(run func(ctx context.Context, app string, service string, all bool)) *MockControlPlane_RestartApp_Call {
1489 _c.Call.Run(func(args mock.Arguments) {
1490 var arg0 context.Context
1491 if args[0] != nil {
1492 arg0 = args[0].(context.Context)
1493 }
1494 var arg1 string
1495 if args[1] != nil {
1496 arg1 = args[1].(string)
1497 }
1498 var arg2 string
1499 if args[2] != nil {
1500 arg2 = args[2].(string)
1501 }
1502 var arg3 bool
1503 if args[3] != nil {
1504 arg3 = args[3].(bool)
1505 }
1506 run(
1507 arg0,
1508 arg1,
1509 arg2,
1510 arg3,
1511 )
1512 })
1513 return _c
1514}
1515
1516func (_c *MockControlPlane_RestartApp_Call) Return(appDeployResponse *dto.AppDeployResponse, s string, err error) *MockControlPlane_RestartApp_Call {
1517 _c.Call.Return(appDeployResponse, s, err)
1518 return _c
1519}
1520
1521func (_c *MockControlPlane_RestartApp_Call) RunAndReturn(run func(ctx context.Context, app string, service string, all bool) (*dto.AppDeployResponse, string, error)) *MockControlPlane_RestartApp_Call {
1522 _c.Call.Return(run)
1523 return _c
1524}
1525
1526// RunBackup provides a mock function for the type MockControlPlane
1527func (_mock *MockControlPlane) RunBackup(ctx context.Context, app string, service string, database string) (*dto.BackupRunResponse, error) {
1528 ret := _mock.Called(ctx, app, service, database)
1529
1530 if len(ret) == 0 {
1531 panic("no return value specified for RunBackup")
1532 }
1533
1534 var r0 *dto.BackupRunResponse
1535 var r1 error
1536 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*dto.BackupRunResponse, error)); ok {
1537 return returnFunc(ctx, app, service, database)
1538 }
1539 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *dto.BackupRunResponse); ok {
1540 r0 = returnFunc(ctx, app, service, database)
1541 } else {
1542 if ret.Get(0) != nil {
1543 r0 = ret.Get(0).(*dto.BackupRunResponse)
1544 }
1545 }
1546 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
1547 r1 = returnFunc(ctx, app, service, database)
1548 } else {
1549 r1 = ret.Error(1)
1550 }
1551 return r0, r1
1552}
1553
1554// MockControlPlane_RunBackup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunBackup'
1555type MockControlPlane_RunBackup_Call struct {
1556 *mock.Call
1557}
1558
1559// RunBackup is a helper method to define mock.On call
1560// - ctx context.Context
1561// - app string
1562// - service string
1563// - database string
1564func (_e *MockControlPlane_Expecter) RunBackup(ctx any, app any, service any, database any) *MockControlPlane_RunBackup_Call {
1565 return &MockControlPlane_RunBackup_Call{Call: _e.mock.On("RunBackup", ctx, app, service, database)}
1566}
1567
1568func (_c *MockControlPlane_RunBackup_Call) Run(run func(ctx context.Context, app string, service string, database string)) *MockControlPlane_RunBackup_Call {
1569 _c.Call.Run(func(args mock.Arguments) {
1570 var arg0 context.Context
1571 if args[0] != nil {
1572 arg0 = args[0].(context.Context)
1573 }
1574 var arg1 string
1575 if args[1] != nil {
1576 arg1 = args[1].(string)
1577 }
1578 var arg2 string
1579 if args[2] != nil {
1580 arg2 = args[2].(string)
1581 }
1582 var arg3 string
1583 if args[3] != nil {
1584 arg3 = args[3].(string)
1585 }
1586 run(
1587 arg0,
1588 arg1,
1589 arg2,
1590 arg3,
1591 )
1592 })
1593 return _c
1594}
1595
1596func (_c *MockControlPlane_RunBackup_Call) Return(backupRunResponse *dto.BackupRunResponse, err error) *MockControlPlane_RunBackup_Call {
1597 _c.Call.Return(backupRunResponse, err)
1598 return _c
1599}
1600
1601func (_c *MockControlPlane_RunBackup_Call) RunAndReturn(run func(ctx context.Context, app string, service string, database string) (*dto.BackupRunResponse, error)) *MockControlPlane_RunBackup_Call {
1602 _c.Call.Return(run)
1603 return _c
1604}
1605
1606// RunVolumeBackups provides a mock function for the type MockControlPlane
1607func (_mock *MockControlPlane) RunVolumeBackups(ctx context.Context, app string, service string, volume string) (*dto.VolumeBackupRunResponse, error) {
1608 ret := _mock.Called(ctx, app, service, volume)
1609
1610 if len(ret) == 0 {
1611 panic("no return value specified for RunVolumeBackups")
1612 }
1613
1614 var r0 *dto.VolumeBackupRunResponse
1615 var r1 error
1616 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*dto.VolumeBackupRunResponse, error)); ok {
1617 return returnFunc(ctx, app, service, volume)
1618 }
1619 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *dto.VolumeBackupRunResponse); ok {
1620 r0 = returnFunc(ctx, app, service, volume)
1621 } else {
1622 if ret.Get(0) != nil {
1623 r0 = ret.Get(0).(*dto.VolumeBackupRunResponse)
1624 }
1625 }
1626 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
1627 r1 = returnFunc(ctx, app, service, volume)
1628 } else {
1629 r1 = ret.Error(1)
1630 }
1631 return r0, r1
1632}
1633
1634// MockControlPlane_RunVolumeBackups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunVolumeBackups'
1635type MockControlPlane_RunVolumeBackups_Call struct {
1636 *mock.Call
1637}
1638
1639// RunVolumeBackups is a helper method to define mock.On call
1640// - ctx context.Context
1641// - app string
1642// - service string
1643// - volume string
1644func (_e *MockControlPlane_Expecter) RunVolumeBackups(ctx any, app any, service any, volume any) *MockControlPlane_RunVolumeBackups_Call {
1645 return &MockControlPlane_RunVolumeBackups_Call{Call: _e.mock.On("RunVolumeBackups", ctx, app, service, volume)}
1646}
1647
1648func (_c *MockControlPlane_RunVolumeBackups_Call) Run(run func(ctx context.Context, app string, service string, volume string)) *MockControlPlane_RunVolumeBackups_Call {
1649 _c.Call.Run(func(args mock.Arguments) {
1650 var arg0 context.Context
1651 if args[0] != nil {
1652 arg0 = args[0].(context.Context)
1653 }
1654 var arg1 string
1655 if args[1] != nil {
1656 arg1 = args[1].(string)
1657 }
1658 var arg2 string
1659 if args[2] != nil {
1660 arg2 = args[2].(string)
1661 }
1662 var arg3 string
1663 if args[3] != nil {
1664 arg3 = args[3].(string)
1665 }
1666 run(
1667 arg0,
1668 arg1,
1669 arg2,
1670 arg3,
1671 )
1672 })
1673 return _c
1674}
1675
1676func (_c *MockControlPlane_RunVolumeBackups_Call) Return(volumeBackupRunResponse *dto.VolumeBackupRunResponse, err error) *MockControlPlane_RunVolumeBackups_Call {
1677 _c.Call.Return(volumeBackupRunResponse, err)
1678 return _c
1679}
1680
1681func (_c *MockControlPlane_RunVolumeBackups_Call) RunAndReturn(run func(ctx context.Context, app string, service string, volume string) (*dto.VolumeBackupRunResponse, error)) *MockControlPlane_RunVolumeBackups_Call {
1682 _c.Call.Return(run)
1683 return _c
1684}
1685
1686// SetAppSecrets provides a mock function for the type MockControlPlane
1687func (_mock *MockControlPlane) SetAppSecrets(ctx context.Context, app string, req dto.AppSecretSetRequest) error {
1688 ret := _mock.Called(ctx, app, req)
1689
1690 if len(ret) == 0 {
1691 panic("no return value specified for SetAppSecrets")
1692 }
1693
1694 var r0 error
1695 if returnFunc, ok := ret.Get(0).(func(context.Context, string, dto.AppSecretSetRequest) error); ok {
1696 r0 = returnFunc(ctx, app, req)
1697 } else {
1698 r0 = ret.Error(0)
1699 }
1700 return r0
1701}
1702
1703// MockControlPlane_SetAppSecrets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetAppSecrets'
1704type MockControlPlane_SetAppSecrets_Call struct {
1705 *mock.Call
1706}
1707
1708// SetAppSecrets is a helper method to define mock.On call
1709// - ctx context.Context
1710// - app string
1711// - req dto.AppSecretSetRequest
1712func (_e *MockControlPlane_Expecter) SetAppSecrets(ctx any, app any, req any) *MockControlPlane_SetAppSecrets_Call {
1713 return &MockControlPlane_SetAppSecrets_Call{Call: _e.mock.On("SetAppSecrets", ctx, app, req)}
1714}
1715
1716func (_c *MockControlPlane_SetAppSecrets_Call) Run(run func(ctx context.Context, app string, req dto.AppSecretSetRequest)) *MockControlPlane_SetAppSecrets_Call {
1717 _c.Call.Run(func(args mock.Arguments) {
1718 var arg0 context.Context
1719 if args[0] != nil {
1720 arg0 = args[0].(context.Context)
1721 }
1722 var arg1 string
1723 if args[1] != nil {
1724 arg1 = args[1].(string)
1725 }
1726 var arg2 dto.AppSecretSetRequest
1727 if args[2] != nil {
1728 arg2 = args[2].(dto.AppSecretSetRequest)
1729 }
1730 run(
1731 arg0,
1732 arg1,
1733 arg2,
1734 )
1735 })
1736 return _c
1737}
1738
1739func (_c *MockControlPlane_SetAppSecrets_Call) Return(err error) *MockControlPlane_SetAppSecrets_Call {
1740 _c.Call.Return(err)
1741 return _c
1742}
1743
1744func (_c *MockControlPlane_SetAppSecrets_Call) RunAndReturn(run func(ctx context.Context, app string, req dto.AppSecretSetRequest) error) *MockControlPlane_SetAppSecrets_Call {
1745 _c.Call.Return(run)
1746 return _c
1747}
1748
1749// ShowApp provides a mock function for the type MockControlPlane
1750func (_mock *MockControlPlane) ShowApp(ctx context.Context, app string) (*dto.AppShowResponse, error) {
1751 ret := _mock.Called(ctx, app)
1752
1753 if len(ret) == 0 {
1754 panic("no return value specified for ShowApp")
1755 }
1756
1757 var r0 *dto.AppShowResponse
1758 var r1 error
1759 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*dto.AppShowResponse, error)); ok {
1760 return returnFunc(ctx, app)
1761 }
1762 if returnFunc, ok := ret.Get(0).(func(context.Context, string) *dto.AppShowResponse); ok {
1763 r0 = returnFunc(ctx, app)
1764 } else {
1765 if ret.Get(0) != nil {
1766 r0 = ret.Get(0).(*dto.AppShowResponse)
1767 }
1768 }
1769 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
1770 r1 = returnFunc(ctx, app)
1771 } else {
1772 r1 = ret.Error(1)
1773 }
1774 return r0, r1
1775}
1776
1777// MockControlPlane_ShowApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowApp'
1778type MockControlPlane_ShowApp_Call struct {
1779 *mock.Call
1780}
1781
1782// ShowApp is a helper method to define mock.On call
1783// - ctx context.Context
1784// - app string
1785func (_e *MockControlPlane_Expecter) ShowApp(ctx any, app any) *MockControlPlane_ShowApp_Call {
1786 return &MockControlPlane_ShowApp_Call{Call: _e.mock.On("ShowApp", ctx, app)}
1787}
1788
1789func (_c *MockControlPlane_ShowApp_Call) Run(run func(ctx context.Context, app string)) *MockControlPlane_ShowApp_Call {
1790 _c.Call.Run(func(args mock.Arguments) {
1791 var arg0 context.Context
1792 if args[0] != nil {
1793 arg0 = args[0].(context.Context)
1794 }
1795 var arg1 string
1796 if args[1] != nil {
1797 arg1 = args[1].(string)
1798 }
1799 run(
1800 arg0,
1801 arg1,
1802 )
1803 })
1804 return _c
1805}
1806
1807func (_c *MockControlPlane_ShowApp_Call) Return(appShowResponse *dto.AppShowResponse, err error) *MockControlPlane_ShowApp_Call {
1808 _c.Call.Return(appShowResponse, err)
1809 return _c
1810}
1811
1812func (_c *MockControlPlane_ShowApp_Call) RunAndReturn(run func(ctx context.Context, app string) (*dto.AppShowResponse, error)) *MockControlPlane_ShowApp_Call {
1813 _c.Call.Return(run)
1814 return _c
1815}
1816
1817// StartApp provides a mock function for the type MockControlPlane
1818func (_mock *MockControlPlane) StartApp(ctx context.Context, app string) (*dto.AppDeployResponse, string, error) {
1819 ret := _mock.Called(ctx, app)
1820
1821 if len(ret) == 0 {
1822 panic("no return value specified for StartApp")
1823 }
1824
1825 var r0 *dto.AppDeployResponse
1826 var r1 string
1827 var r2 error
1828 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*dto.AppDeployResponse, string, error)); ok {
1829 return returnFunc(ctx, app)
1830 }
1831 if returnFunc, ok := ret.Get(0).(func(context.Context, string) *dto.AppDeployResponse); ok {
1832 r0 = returnFunc(ctx, app)
1833 } else {
1834 if ret.Get(0) != nil {
1835 r0 = ret.Get(0).(*dto.AppDeployResponse)
1836 }
1837 }
1838 if returnFunc, ok := ret.Get(1).(func(context.Context, string) string); ok {
1839 r1 = returnFunc(ctx, app)
1840 } else {
1841 r1 = ret.Get(1).(string)
1842 }
1843 if returnFunc, ok := ret.Get(2).(func(context.Context, string) error); ok {
1844 r2 = returnFunc(ctx, app)
1845 } else {
1846 r2 = ret.Error(2)
1847 }
1848 return r0, r1, r2
1849}
1850
1851// MockControlPlane_StartApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartApp'
1852type MockControlPlane_StartApp_Call struct {
1853 *mock.Call
1854}
1855
1856// StartApp is a helper method to define mock.On call
1857// - ctx context.Context
1858// - app string
1859func (_e *MockControlPlane_Expecter) StartApp(ctx any, app any) *MockControlPlane_StartApp_Call {
1860 return &MockControlPlane_StartApp_Call{Call: _e.mock.On("StartApp", ctx, app)}
1861}
1862
1863func (_c *MockControlPlane_StartApp_Call) Run(run func(ctx context.Context, app string)) *MockControlPlane_StartApp_Call {
1864 _c.Call.Run(func(args mock.Arguments) {
1865 var arg0 context.Context
1866 if args[0] != nil {
1867 arg0 = args[0].(context.Context)
1868 }
1869 var arg1 string
1870 if args[1] != nil {
1871 arg1 = args[1].(string)
1872 }
1873 run(
1874 arg0,
1875 arg1,
1876 )
1877 })
1878 return _c
1879}
1880
1881func (_c *MockControlPlane_StartApp_Call) Return(appDeployResponse *dto.AppDeployResponse, s string, err error) *MockControlPlane_StartApp_Call {
1882 _c.Call.Return(appDeployResponse, s, err)
1883 return _c
1884}
1885
1886func (_c *MockControlPlane_StartApp_Call) RunAndReturn(run func(ctx context.Context, app string) (*dto.AppDeployResponse, string, error)) *MockControlPlane_StartApp_Call {
1887 _c.Call.Return(run)
1888 return _c
1889}
1890
1891// StopApp provides a mock function for the type MockControlPlane
1892func (_mock *MockControlPlane) StopApp(ctx context.Context, app string) (*dto.AppDeployResponse, string, error) {
1893 ret := _mock.Called(ctx, app)
1894
1895 if len(ret) == 0 {
1896 panic("no return value specified for StopApp")
1897 }
1898
1899 var r0 *dto.AppDeployResponse
1900 var r1 string
1901 var r2 error
1902 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*dto.AppDeployResponse, string, error)); ok {
1903 return returnFunc(ctx, app)
1904 }
1905 if returnFunc, ok := ret.Get(0).(func(context.Context, string) *dto.AppDeployResponse); ok {
1906 r0 = returnFunc(ctx, app)
1907 } else {
1908 if ret.Get(0) != nil {
1909 r0 = ret.Get(0).(*dto.AppDeployResponse)
1910 }
1911 }
1912 if returnFunc, ok := ret.Get(1).(func(context.Context, string) string); ok {
1913 r1 = returnFunc(ctx, app)
1914 } else {
1915 r1 = ret.Get(1).(string)
1916 }
1917 if returnFunc, ok := ret.Get(2).(func(context.Context, string) error); ok {
1918 r2 = returnFunc(ctx, app)
1919 } else {
1920 r2 = ret.Error(2)
1921 }
1922 return r0, r1, r2
1923}
1924
1925// MockControlPlane_StopApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StopApp'
1926type MockControlPlane_StopApp_Call struct {
1927 *mock.Call
1928}
1929
1930// StopApp is a helper method to define mock.On call
1931// - ctx context.Context
1932// - app string
1933func (_e *MockControlPlane_Expecter) StopApp(ctx any, app any) *MockControlPlane_StopApp_Call {
1934 return &MockControlPlane_StopApp_Call{Call: _e.mock.On("StopApp", ctx, app)}
1935}
1936
1937func (_c *MockControlPlane_StopApp_Call) Run(run func(ctx context.Context, app string)) *MockControlPlane_StopApp_Call {
1938 _c.Call.Run(func(args mock.Arguments) {
1939 var arg0 context.Context
1940 if args[0] != nil {
1941 arg0 = args[0].(context.Context)
1942 }
1943 var arg1 string
1944 if args[1] != nil {
1945 arg1 = args[1].(string)
1946 }
1947 run(
1948 arg0,
1949 arg1,
1950 )
1951 })
1952 return _c
1953}
1954
1955func (_c *MockControlPlane_StopApp_Call) Return(appDeployResponse *dto.AppDeployResponse, s string, err error) *MockControlPlane_StopApp_Call {
1956 _c.Call.Return(appDeployResponse, s, err)
1957 return _c
1958}
1959
1960func (_c *MockControlPlane_StopApp_Call) RunAndReturn(run func(ctx context.Context, app string) (*dto.AppDeployResponse, string, error)) *MockControlPlane_StopApp_Call {
1961 _c.Call.Return(run)
1962 return _c
1963}
1964
1965// StreamProcessLogs provides a mock function for the type MockControlPlane
1966func (_mock *MockControlPlane) StreamProcessLogs(ctx context.Context, lines int) (<-chan string, error) {
1967 ret := _mock.Called(ctx, lines)
1968
1969 if len(ret) == 0 {
1970 panic("no return value specified for StreamProcessLogs")
1971 }
1972
1973 var r0 <-chan string
1974 var r1 error
1975 if returnFunc, ok := ret.Get(0).(func(context.Context, int) (<-chan string, error)); ok {
1976 return returnFunc(ctx, lines)
1977 }
1978 if returnFunc, ok := ret.Get(0).(func(context.Context, int) <-chan string); ok {
1979 r0 = returnFunc(ctx, lines)
1980 } else {
1981 if ret.Get(0) != nil {
1982 r0 = ret.Get(0).(<-chan string)
1983 }
1984 }
1985 if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
1986 r1 = returnFunc(ctx, lines)
1987 } else {
1988 r1 = ret.Error(1)
1989 }
1990 return r0, r1
1991}
1992
1993// MockControlPlane_StreamProcessLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StreamProcessLogs'
1994type MockControlPlane_StreamProcessLogs_Call struct {
1995 *mock.Call
1996}
1997
1998// StreamProcessLogs is a helper method to define mock.On call
1999// - ctx context.Context
2000// - lines int
2001func (_e *MockControlPlane_Expecter) StreamProcessLogs(ctx any, lines any) *MockControlPlane_StreamProcessLogs_Call {
2002 return &MockControlPlane_StreamProcessLogs_Call{Call: _e.mock.On("StreamProcessLogs", ctx, lines)}
2003}
2004
2005func (_c *MockControlPlane_StreamProcessLogs_Call) Run(run func(ctx context.Context, lines int)) *MockControlPlane_StreamProcessLogs_Call {
2006 _c.Call.Run(func(args mock.Arguments) {
2007 var arg0 context.Context
2008 if args[0] != nil {
2009 arg0 = args[0].(context.Context)
2010 }
2011 var arg1 int
2012 if args[1] != nil {
2013 arg1 = args[1].(int)
2014 }
2015 run(
2016 arg0,
2017 arg1,
2018 )
2019 })
2020 return _c
2021}
2022
2023func (_c *MockControlPlane_StreamProcessLogs_Call) Return(stringCh <-chan string, err error) *MockControlPlane_StreamProcessLogs_Call {
2024 _c.Call.Return(stringCh, err)
2025 return _c
2026}
2027
2028func (_c *MockControlPlane_StreamProcessLogs_Call) RunAndReturn(run func(ctx context.Context, lines int) (<-chan string, error)) *MockControlPlane_StreamProcessLogs_Call {
2029 _c.Call.Return(run)
2030 return _c
2031}
2032
2033// VolumeBackupStatus provides a mock function for the type MockControlPlane
2034func (_mock *MockControlPlane) VolumeBackupStatus(ctx context.Context) ([]dto.VolumeBackupJob, error) {
2035 ret := _mock.Called(ctx)
2036
2037 if len(ret) == 0 {
2038 panic("no return value specified for VolumeBackupStatus")
2039 }
2040
2041 var r0 []dto.VolumeBackupJob
2042 var r1 error
2043 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]dto.VolumeBackupJob, error)); ok {
2044 return returnFunc(ctx)
2045 }
2046 if returnFunc, ok := ret.Get(0).(func(context.Context) []dto.VolumeBackupJob); ok {
2047 r0 = returnFunc(ctx)
2048 } else {
2049 if ret.Get(0) != nil {
2050 r0 = ret.Get(0).([]dto.VolumeBackupJob)
2051 }
2052 }
2053 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
2054 r1 = returnFunc(ctx)
2055 } else {
2056 r1 = ret.Error(1)
2057 }
2058 return r0, r1
2059}
2060
2061// MockControlPlane_VolumeBackupStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VolumeBackupStatus'
2062type MockControlPlane_VolumeBackupStatus_Call struct {
2063 *mock.Call
2064}
2065
2066// VolumeBackupStatus is a helper method to define mock.On call
2067// - ctx context.Context
2068func (_e *MockControlPlane_Expecter) VolumeBackupStatus(ctx any) *MockControlPlane_VolumeBackupStatus_Call {
2069 return &MockControlPlane_VolumeBackupStatus_Call{Call: _e.mock.On("VolumeBackupStatus", ctx)}
2070}
2071
2072func (_c *MockControlPlane_VolumeBackupStatus_Call) Run(run func(ctx context.Context)) *MockControlPlane_VolumeBackupStatus_Call {
2073 _c.Call.Run(func(args mock.Arguments) {
2074 var arg0 context.Context
2075 if args[0] != nil {
2076 arg0 = args[0].(context.Context)
2077 }
2078 run(
2079 arg0,
2080 )
2081 })
2082 return _c
2083}
2084
2085func (_c *MockControlPlane_VolumeBackupStatus_Call) Return(volumeBackupJobs []dto.VolumeBackupJob, err error) *MockControlPlane_VolumeBackupStatus_Call {
2086 _c.Call.Return(volumeBackupJobs, err)
2087 return _c
2088}
2089
2090func (_c *MockControlPlane_VolumeBackupStatus_Call) RunAndReturn(run func(ctx context.Context) ([]dto.VolumeBackupJob, error)) *MockControlPlane_VolumeBackupStatus_Call {
2091 _c.Call.Return(run)
2092 return _c
2093}