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/domain"
11 mock "github.com/stretchr/testify/mock"
12)
13
14// NewMockAppState creates a new instance of MockAppState. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15// The first argument is typically a *testing.T value.
16func NewMockAppState(t interface {
17 mock.TestingT
18 Cleanup(func())
19}) *MockAppState {
20 if helper, ok := t.(interface{ Helper() }); ok {
21 helper.Helper()
22 }
23
24 mock := &MockAppState{}
25 mock.Mock.Test(t)
26
27 t.Cleanup(func() {
28 if helper, ok := t.(interface{ Helper() }); ok {
29 helper.Helper()
30 }
31 mock.AssertExpectations(t)
32 })
33
34 return mock
35}
36
37// MockAppState is an autogenerated mock type for the AppState type
38type MockAppState struct {
39 mock.Mock
40}
41
42type MockAppState_Expecter struct {
43 mock *mock.Mock
44}
45
46func (_m *MockAppState) EXPECT() *MockAppState_Expecter {
47 return &MockAppState_Expecter{mock: &_m.Mock}
48}
49
50// AcceptApply provides a mock function for the type MockAppState
51func (_mock *MockAppState) AcceptApply(ctx context.Context, intent domain.AppApplyIntent) error {
52 ret := _mock.Called(ctx, intent)
53
54 if len(ret) == 0 {
55 panic("no return value specified for AcceptApply")
56 }
57
58 var r0 error
59 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.AppApplyIntent) error); ok {
60 r0 = returnFunc(ctx, intent)
61 } else {
62 r0 = ret.Error(0)
63 }
64 return r0
65}
66
67// MockAppState_AcceptApply_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AcceptApply'
68type MockAppState_AcceptApply_Call struct {
69 *mock.Call
70}
71
72// AcceptApply is a helper method to define mock.On call
73// - ctx context.Context
74// - intent domain.AppApplyIntent
75func (_e *MockAppState_Expecter) AcceptApply(ctx any, intent any) *MockAppState_AcceptApply_Call {
76 return &MockAppState_AcceptApply_Call{Call: _e.mock.On("AcceptApply", ctx, intent)}
77}
78
79func (_c *MockAppState_AcceptApply_Call) Run(run func(ctx context.Context, intent domain.AppApplyIntent)) *MockAppState_AcceptApply_Call {
80 _c.Call.Run(func(args mock.Arguments) {
81 var arg0 context.Context
82 if args[0] != nil {
83 arg0 = args[0].(context.Context)
84 }
85 var arg1 domain.AppApplyIntent
86 if args[1] != nil {
87 arg1 = args[1].(domain.AppApplyIntent)
88 }
89 run(
90 arg0,
91 arg1,
92 )
93 })
94 return _c
95}
96
97func (_c *MockAppState_AcceptApply_Call) Return(err error) *MockAppState_AcceptApply_Call {
98 _c.Call.Return(err)
99 return _c
100}
101
102func (_c *MockAppState_AcceptApply_Call) RunAndReturn(run func(ctx context.Context, intent domain.AppApplyIntent) error) *MockAppState_AcceptApply_Call {
103 _c.Call.Return(run)
104 return _c
105}
106
107// AppExists provides a mock function for the type MockAppState
108func (_mock *MockAppState) AppExists(ctx context.Context, app string) (bool, error) {
109 ret := _mock.Called(ctx, app)
110
111 if len(ret) == 0 {
112 panic("no return value specified for AppExists")
113 }
114
115 var r0 bool
116 var r1 error
117 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (bool, error)); ok {
118 return returnFunc(ctx, app)
119 }
120 if returnFunc, ok := ret.Get(0).(func(context.Context, string) bool); ok {
121 r0 = returnFunc(ctx, app)
122 } else {
123 r0 = ret.Get(0).(bool)
124 }
125 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
126 r1 = returnFunc(ctx, app)
127 } else {
128 r1 = ret.Error(1)
129 }
130 return r0, r1
131}
132
133// MockAppState_AppExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AppExists'
134type MockAppState_AppExists_Call struct {
135 *mock.Call
136}
137
138// AppExists is a helper method to define mock.On call
139// - ctx context.Context
140// - app string
141func (_e *MockAppState_Expecter) AppExists(ctx any, app any) *MockAppState_AppExists_Call {
142 return &MockAppState_AppExists_Call{Call: _e.mock.On("AppExists", ctx, app)}
143}
144
145func (_c *MockAppState_AppExists_Call) Run(run func(ctx context.Context, app string)) *MockAppState_AppExists_Call {
146 _c.Call.Run(func(args mock.Arguments) {
147 var arg0 context.Context
148 if args[0] != nil {
149 arg0 = args[0].(context.Context)
150 }
151 var arg1 string
152 if args[1] != nil {
153 arg1 = args[1].(string)
154 }
155 run(
156 arg0,
157 arg1,
158 )
159 })
160 return _c
161}
162
163func (_c *MockAppState_AppExists_Call) Return(b bool, err error) *MockAppState_AppExists_Call {
164 _c.Call.Return(b, err)
165 return _c
166}
167
168func (_c *MockAppState_AppExists_Call) RunAndReturn(run func(ctx context.Context, app string) (bool, error)) *MockAppState_AppExists_Call {
169 _c.Call.Return(run)
170 return _c
171}
172
173// ClaimOperation provides a mock function for the type MockAppState
174func (_mock *MockAppState) ClaimOperation(ctx context.Context, candidate domain.AppOperation) (domain.AppOperation, bool, error) {
175 ret := _mock.Called(ctx, candidate)
176
177 if len(ret) == 0 {
178 panic("no return value specified for ClaimOperation")
179 }
180
181 var r0 domain.AppOperation
182 var r1 bool
183 var r2 error
184 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.AppOperation) (domain.AppOperation, bool, error)); ok {
185 return returnFunc(ctx, candidate)
186 }
187 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.AppOperation) domain.AppOperation); ok {
188 r0 = returnFunc(ctx, candidate)
189 } else {
190 r0 = ret.Get(0).(domain.AppOperation)
191 }
192 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.AppOperation) bool); ok {
193 r1 = returnFunc(ctx, candidate)
194 } else {
195 r1 = ret.Get(1).(bool)
196 }
197 if returnFunc, ok := ret.Get(2).(func(context.Context, domain.AppOperation) error); ok {
198 r2 = returnFunc(ctx, candidate)
199 } else {
200 r2 = ret.Error(2)
201 }
202 return r0, r1, r2
203}
204
205// MockAppState_ClaimOperation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClaimOperation'
206type MockAppState_ClaimOperation_Call struct {
207 *mock.Call
208}
209
210// ClaimOperation is a helper method to define mock.On call
211// - ctx context.Context
212// - candidate domain.AppOperation
213func (_e *MockAppState_Expecter) ClaimOperation(ctx any, candidate any) *MockAppState_ClaimOperation_Call {
214 return &MockAppState_ClaimOperation_Call{Call: _e.mock.On("ClaimOperation", ctx, candidate)}
215}
216
217func (_c *MockAppState_ClaimOperation_Call) Run(run func(ctx context.Context, candidate domain.AppOperation)) *MockAppState_ClaimOperation_Call {
218 _c.Call.Run(func(args mock.Arguments) {
219 var arg0 context.Context
220 if args[0] != nil {
221 arg0 = args[0].(context.Context)
222 }
223 var arg1 domain.AppOperation
224 if args[1] != nil {
225 arg1 = args[1].(domain.AppOperation)
226 }
227 run(
228 arg0,
229 arg1,
230 )
231 })
232 return _c
233}
234
235func (_c *MockAppState_ClaimOperation_Call) Return(existing domain.AppOperation, claimed bool, err error) *MockAppState_ClaimOperation_Call {
236 _c.Call.Return(existing, claimed, err)
237 return _c
238}
239
240func (_c *MockAppState_ClaimOperation_Call) RunAndReturn(run func(ctx context.Context, candidate domain.AppOperation) (domain.AppOperation, bool, error)) *MockAppState_ClaimOperation_Call {
241 _c.Call.Return(run)
242 return _c
243}
244
245// ClearRecoveryInhibition provides a mock function for the type MockAppState
246func (_mock *MockAppState) ClearRecoveryInhibition(ctx context.Context, app string, service string, containerID string) error {
247 ret := _mock.Called(ctx, app, service, containerID)
248
249 if len(ret) == 0 {
250 panic("no return value specified for ClearRecoveryInhibition")
251 }
252
253 var r0 error
254 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
255 r0 = returnFunc(ctx, app, service, containerID)
256 } else {
257 r0 = ret.Error(0)
258 }
259 return r0
260}
261
262// MockAppState_ClearRecoveryInhibition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClearRecoveryInhibition'
263type MockAppState_ClearRecoveryInhibition_Call struct {
264 *mock.Call
265}
266
267// ClearRecoveryInhibition is a helper method to define mock.On call
268// - ctx context.Context
269// - app string
270// - service string
271// - containerID string
272func (_e *MockAppState_Expecter) ClearRecoveryInhibition(ctx any, app any, service any, containerID any) *MockAppState_ClearRecoveryInhibition_Call {
273 return &MockAppState_ClearRecoveryInhibition_Call{Call: _e.mock.On("ClearRecoveryInhibition", ctx, app, service, containerID)}
274}
275
276func (_c *MockAppState_ClearRecoveryInhibition_Call) Run(run func(ctx context.Context, app string, service string, containerID string)) *MockAppState_ClearRecoveryInhibition_Call {
277 _c.Call.Run(func(args mock.Arguments) {
278 var arg0 context.Context
279 if args[0] != nil {
280 arg0 = args[0].(context.Context)
281 }
282 var arg1 string
283 if args[1] != nil {
284 arg1 = args[1].(string)
285 }
286 var arg2 string
287 if args[2] != nil {
288 arg2 = args[2].(string)
289 }
290 var arg3 string
291 if args[3] != nil {
292 arg3 = args[3].(string)
293 }
294 run(
295 arg0,
296 arg1,
297 arg2,
298 arg3,
299 )
300 })
301 return _c
302}
303
304func (_c *MockAppState_ClearRecoveryInhibition_Call) Return(err error) *MockAppState_ClearRecoveryInhibition_Call {
305 _c.Call.Return(err)
306 return _c
307}
308
309func (_c *MockAppState_ClearRecoveryInhibition_Call) RunAndReturn(run func(ctx context.Context, app string, service string, containerID string) error) *MockAppState_ClearRecoveryInhibition_Call {
310 _c.Call.Return(run)
311 return _c
312}
313
314// Close provides a mock function for the type MockAppState
315func (_mock *MockAppState) Close() error {
316 ret := _mock.Called()
317
318 if len(ret) == 0 {
319 panic("no return value specified for Close")
320 }
321
322 var r0 error
323 if returnFunc, ok := ret.Get(0).(func() error); ok {
324 r0 = returnFunc()
325 } else {
326 r0 = ret.Error(0)
327 }
328 return r0
329}
330
331// MockAppState_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
332type MockAppState_Close_Call struct {
333 *mock.Call
334}
335
336// Close is a helper method to define mock.On call
337func (_e *MockAppState_Expecter) Close() *MockAppState_Close_Call {
338 return &MockAppState_Close_Call{Call: _e.mock.On("Close")}
339}
340
341func (_c *MockAppState_Close_Call) Run(run func()) *MockAppState_Close_Call {
342 _c.Call.Run(func(args mock.Arguments) {
343 run()
344 })
345 return _c
346}
347
348func (_c *MockAppState_Close_Call) Return(err error) *MockAppState_Close_Call {
349 _c.Call.Return(err)
350 return _c
351}
352
353func (_c *MockAppState_Close_Call) RunAndReturn(run func() error) *MockAppState_Close_Call {
354 _c.Call.Return(run)
355 return _c
356}
357
358// ListApps provides a mock function for the type MockAppState
359func (_mock *MockAppState) ListApps(ctx context.Context) ([]string, error) {
360 ret := _mock.Called(ctx)
361
362 if len(ret) == 0 {
363 panic("no return value specified for ListApps")
364 }
365
366 var r0 []string
367 var r1 error
368 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]string, error)); ok {
369 return returnFunc(ctx)
370 }
371 if returnFunc, ok := ret.Get(0).(func(context.Context) []string); ok {
372 r0 = returnFunc(ctx)
373 } else {
374 if ret.Get(0) != nil {
375 r0 = ret.Get(0).([]string)
376 }
377 }
378 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
379 r1 = returnFunc(ctx)
380 } else {
381 r1 = ret.Error(1)
382 }
383 return r0, r1
384}
385
386// MockAppState_ListApps_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListApps'
387type MockAppState_ListApps_Call struct {
388 *mock.Call
389}
390
391// ListApps is a helper method to define mock.On call
392// - ctx context.Context
393func (_e *MockAppState_Expecter) ListApps(ctx any) *MockAppState_ListApps_Call {
394 return &MockAppState_ListApps_Call{Call: _e.mock.On("ListApps", ctx)}
395}
396
397func (_c *MockAppState_ListApps_Call) Run(run func(ctx context.Context)) *MockAppState_ListApps_Call {
398 _c.Call.Run(func(args mock.Arguments) {
399 var arg0 context.Context
400 if args[0] != nil {
401 arg0 = args[0].(context.Context)
402 }
403 run(
404 arg0,
405 )
406 })
407 return _c
408}
409
410func (_c *MockAppState_ListApps_Call) Return(strings []string, err error) *MockAppState_ListApps_Call {
411 _c.Call.Return(strings, err)
412 return _c
413}
414
415func (_c *MockAppState_ListApps_Call) RunAndReturn(run func(ctx context.Context) ([]string, error)) *MockAppState_ListApps_Call {
416 _c.Call.Return(run)
417 return _c
418}
419
420// LoadActive provides a mock function for the type MockAppState
421func (_mock *MockAppState) LoadActive(ctx context.Context, app string) (domain.AppActive, bool, error) {
422 ret := _mock.Called(ctx, app)
423
424 if len(ret) == 0 {
425 panic("no return value specified for LoadActive")
426 }
427
428 var r0 domain.AppActive
429 var r1 bool
430 var r2 error
431 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (domain.AppActive, bool, error)); ok {
432 return returnFunc(ctx, app)
433 }
434 if returnFunc, ok := ret.Get(0).(func(context.Context, string) domain.AppActive); ok {
435 r0 = returnFunc(ctx, app)
436 } else {
437 r0 = ret.Get(0).(domain.AppActive)
438 }
439 if returnFunc, ok := ret.Get(1).(func(context.Context, string) bool); ok {
440 r1 = returnFunc(ctx, app)
441 } else {
442 r1 = ret.Get(1).(bool)
443 }
444 if returnFunc, ok := ret.Get(2).(func(context.Context, string) error); ok {
445 r2 = returnFunc(ctx, app)
446 } else {
447 r2 = ret.Error(2)
448 }
449 return r0, r1, r2
450}
451
452// MockAppState_LoadActive_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadActive'
453type MockAppState_LoadActive_Call struct {
454 *mock.Call
455}
456
457// LoadActive is a helper method to define mock.On call
458// - ctx context.Context
459// - app string
460func (_e *MockAppState_Expecter) LoadActive(ctx any, app any) *MockAppState_LoadActive_Call {
461 return &MockAppState_LoadActive_Call{Call: _e.mock.On("LoadActive", ctx, app)}
462}
463
464func (_c *MockAppState_LoadActive_Call) Run(run func(ctx context.Context, app string)) *MockAppState_LoadActive_Call {
465 _c.Call.Run(func(args mock.Arguments) {
466 var arg0 context.Context
467 if args[0] != nil {
468 arg0 = args[0].(context.Context)
469 }
470 var arg1 string
471 if args[1] != nil {
472 arg1 = args[1].(string)
473 }
474 run(
475 arg0,
476 arg1,
477 )
478 })
479 return _c
480}
481
482func (_c *MockAppState_LoadActive_Call) Return(appActive domain.AppActive, b bool, err error) *MockAppState_LoadActive_Call {
483 _c.Call.Return(appActive, b, err)
484 return _c
485}
486
487func (_c *MockAppState_LoadActive_Call) RunAndReturn(run func(ctx context.Context, app string) (domain.AppActive, bool, error)) *MockAppState_LoadActive_Call {
488 _c.Call.Return(run)
489 return _c
490}
491
492// LoadCheckpoint provides a mock function for the type MockAppState
493func (_mock *MockAppState) LoadCheckpoint(ctx context.Context) (domain.AppStoreCheckpoint, error) {
494 ret := _mock.Called(ctx)
495
496 if len(ret) == 0 {
497 panic("no return value specified for LoadCheckpoint")
498 }
499
500 var r0 domain.AppStoreCheckpoint
501 var r1 error
502 if returnFunc, ok := ret.Get(0).(func(context.Context) (domain.AppStoreCheckpoint, error)); ok {
503 return returnFunc(ctx)
504 }
505 if returnFunc, ok := ret.Get(0).(func(context.Context) domain.AppStoreCheckpoint); ok {
506 r0 = returnFunc(ctx)
507 } else {
508 r0 = ret.Get(0).(domain.AppStoreCheckpoint)
509 }
510 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
511 r1 = returnFunc(ctx)
512 } else {
513 r1 = ret.Error(1)
514 }
515 return r0, r1
516}
517
518// MockAppState_LoadCheckpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadCheckpoint'
519type MockAppState_LoadCheckpoint_Call struct {
520 *mock.Call
521}
522
523// LoadCheckpoint is a helper method to define mock.On call
524// - ctx context.Context
525func (_e *MockAppState_Expecter) LoadCheckpoint(ctx any) *MockAppState_LoadCheckpoint_Call {
526 return &MockAppState_LoadCheckpoint_Call{Call: _e.mock.On("LoadCheckpoint", ctx)}
527}
528
529func (_c *MockAppState_LoadCheckpoint_Call) Run(run func(ctx context.Context)) *MockAppState_LoadCheckpoint_Call {
530 _c.Call.Run(func(args mock.Arguments) {
531 var arg0 context.Context
532 if args[0] != nil {
533 arg0 = args[0].(context.Context)
534 }
535 run(
536 arg0,
537 )
538 })
539 return _c
540}
541
542func (_c *MockAppState_LoadCheckpoint_Call) Return(appStoreCheckpoint domain.AppStoreCheckpoint, err error) *MockAppState_LoadCheckpoint_Call {
543 _c.Call.Return(appStoreCheckpoint, err)
544 return _c
545}
546
547func (_c *MockAppState_LoadCheckpoint_Call) RunAndReturn(run func(ctx context.Context) (domain.AppStoreCheckpoint, error)) *MockAppState_LoadCheckpoint_Call {
548 _c.Call.Return(run)
549 return _c
550}
551
552// LoadDesired provides a mock function for the type MockAppState
553func (_mock *MockAppState) LoadDesired(ctx context.Context, app string) (domain.AppDesiredRevision, bool, error) {
554 ret := _mock.Called(ctx, app)
555
556 if len(ret) == 0 {
557 panic("no return value specified for LoadDesired")
558 }
559
560 var r0 domain.AppDesiredRevision
561 var r1 bool
562 var r2 error
563 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (domain.AppDesiredRevision, bool, error)); ok {
564 return returnFunc(ctx, app)
565 }
566 if returnFunc, ok := ret.Get(0).(func(context.Context, string) domain.AppDesiredRevision); ok {
567 r0 = returnFunc(ctx, app)
568 } else {
569 r0 = ret.Get(0).(domain.AppDesiredRevision)
570 }
571 if returnFunc, ok := ret.Get(1).(func(context.Context, string) bool); ok {
572 r1 = returnFunc(ctx, app)
573 } else {
574 r1 = ret.Get(1).(bool)
575 }
576 if returnFunc, ok := ret.Get(2).(func(context.Context, string) error); ok {
577 r2 = returnFunc(ctx, app)
578 } else {
579 r2 = ret.Error(2)
580 }
581 return r0, r1, r2
582}
583
584// MockAppState_LoadDesired_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadDesired'
585type MockAppState_LoadDesired_Call struct {
586 *mock.Call
587}
588
589// LoadDesired is a helper method to define mock.On call
590// - ctx context.Context
591// - app string
592func (_e *MockAppState_Expecter) LoadDesired(ctx any, app any) *MockAppState_LoadDesired_Call {
593 return &MockAppState_LoadDesired_Call{Call: _e.mock.On("LoadDesired", ctx, app)}
594}
595
596func (_c *MockAppState_LoadDesired_Call) Run(run func(ctx context.Context, app string)) *MockAppState_LoadDesired_Call {
597 _c.Call.Run(func(args mock.Arguments) {
598 var arg0 context.Context
599 if args[0] != nil {
600 arg0 = args[0].(context.Context)
601 }
602 var arg1 string
603 if args[1] != nil {
604 arg1 = args[1].(string)
605 }
606 run(
607 arg0,
608 arg1,
609 )
610 })
611 return _c
612}
613
614func (_c *MockAppState_LoadDesired_Call) Return(appDesiredRevision domain.AppDesiredRevision, b bool, err error) *MockAppState_LoadDesired_Call {
615 _c.Call.Return(appDesiredRevision, b, err)
616 return _c
617}
618
619func (_c *MockAppState_LoadDesired_Call) RunAndReturn(run func(ctx context.Context, app string) (domain.AppDesiredRevision, bool, error)) *MockAppState_LoadDesired_Call {
620 _c.Call.Return(run)
621 return _c
622}
623
624// LoadIntent provides a mock function for the type MockAppState
625func (_mock *MockAppState) LoadIntent(ctx context.Context, app string) (domain.AppStopIntent, error) {
626 ret := _mock.Called(ctx, app)
627
628 if len(ret) == 0 {
629 panic("no return value specified for LoadIntent")
630 }
631
632 var r0 domain.AppStopIntent
633 var r1 error
634 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (domain.AppStopIntent, error)); ok {
635 return returnFunc(ctx, app)
636 }
637 if returnFunc, ok := ret.Get(0).(func(context.Context, string) domain.AppStopIntent); ok {
638 r0 = returnFunc(ctx, app)
639 } else {
640 r0 = ret.Get(0).(domain.AppStopIntent)
641 }
642 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
643 r1 = returnFunc(ctx, app)
644 } else {
645 r1 = ret.Error(1)
646 }
647 return r0, r1
648}
649
650// MockAppState_LoadIntent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadIntent'
651type MockAppState_LoadIntent_Call struct {
652 *mock.Call
653}
654
655// LoadIntent is a helper method to define mock.On call
656// - ctx context.Context
657// - app string
658func (_e *MockAppState_Expecter) LoadIntent(ctx any, app any) *MockAppState_LoadIntent_Call {
659 return &MockAppState_LoadIntent_Call{Call: _e.mock.On("LoadIntent", ctx, app)}
660}
661
662func (_c *MockAppState_LoadIntent_Call) Run(run func(ctx context.Context, app string)) *MockAppState_LoadIntent_Call {
663 _c.Call.Run(func(args mock.Arguments) {
664 var arg0 context.Context
665 if args[0] != nil {
666 arg0 = args[0].(context.Context)
667 }
668 var arg1 string
669 if args[1] != nil {
670 arg1 = args[1].(string)
671 }
672 run(
673 arg0,
674 arg1,
675 )
676 })
677 return _c
678}
679
680func (_c *MockAppState_LoadIntent_Call) Return(appStopIntent domain.AppStopIntent, err error) *MockAppState_LoadIntent_Call {
681 _c.Call.Return(appStopIntent, err)
682 return _c
683}
684
685func (_c *MockAppState_LoadIntent_Call) RunAndReturn(run func(ctx context.Context, app string) (domain.AppStopIntent, error)) *MockAppState_LoadIntent_Call {
686 _c.Call.Return(run)
687 return _c
688}
689
690// LoadLatestOperation provides a mock function for the type MockAppState
691func (_mock *MockAppState) LoadLatestOperation(ctx context.Context, app string) (domain.AppOperation, bool, error) {
692 ret := _mock.Called(ctx, app)
693
694 if len(ret) == 0 {
695 panic("no return value specified for LoadLatestOperation")
696 }
697
698 var r0 domain.AppOperation
699 var r1 bool
700 var r2 error
701 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (domain.AppOperation, bool, error)); ok {
702 return returnFunc(ctx, app)
703 }
704 if returnFunc, ok := ret.Get(0).(func(context.Context, string) domain.AppOperation); ok {
705 r0 = returnFunc(ctx, app)
706 } else {
707 r0 = ret.Get(0).(domain.AppOperation)
708 }
709 if returnFunc, ok := ret.Get(1).(func(context.Context, string) bool); ok {
710 r1 = returnFunc(ctx, app)
711 } else {
712 r1 = ret.Get(1).(bool)
713 }
714 if returnFunc, ok := ret.Get(2).(func(context.Context, string) error); ok {
715 r2 = returnFunc(ctx, app)
716 } else {
717 r2 = ret.Error(2)
718 }
719 return r0, r1, r2
720}
721
722// MockAppState_LoadLatestOperation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadLatestOperation'
723type MockAppState_LoadLatestOperation_Call struct {
724 *mock.Call
725}
726
727// LoadLatestOperation is a helper method to define mock.On call
728// - ctx context.Context
729// - app string
730func (_e *MockAppState_Expecter) LoadLatestOperation(ctx any, app any) *MockAppState_LoadLatestOperation_Call {
731 return &MockAppState_LoadLatestOperation_Call{Call: _e.mock.On("LoadLatestOperation", ctx, app)}
732}
733
734func (_c *MockAppState_LoadLatestOperation_Call) Run(run func(ctx context.Context, app string)) *MockAppState_LoadLatestOperation_Call {
735 _c.Call.Run(func(args mock.Arguments) {
736 var arg0 context.Context
737 if args[0] != nil {
738 arg0 = args[0].(context.Context)
739 }
740 var arg1 string
741 if args[1] != nil {
742 arg1 = args[1].(string)
743 }
744 run(
745 arg0,
746 arg1,
747 )
748 })
749 return _c
750}
751
752func (_c *MockAppState_LoadLatestOperation_Call) Return(appOperation domain.AppOperation, b bool, err error) *MockAppState_LoadLatestOperation_Call {
753 _c.Call.Return(appOperation, b, err)
754 return _c
755}
756
757func (_c *MockAppState_LoadLatestOperation_Call) RunAndReturn(run func(ctx context.Context, app string) (domain.AppOperation, bool, error)) *MockAppState_LoadLatestOperation_Call {
758 _c.Call.Return(run)
759 return _c
760}
761
762// LoadOperation provides a mock function for the type MockAppState
763func (_mock *MockAppState) LoadOperation(ctx context.Context, app string, opID string) (domain.AppOperation, error) {
764 ret := _mock.Called(ctx, app, opID)
765
766 if len(ret) == 0 {
767 panic("no return value specified for LoadOperation")
768 }
769
770 var r0 domain.AppOperation
771 var r1 error
772 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (domain.AppOperation, error)); ok {
773 return returnFunc(ctx, app, opID)
774 }
775 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) domain.AppOperation); ok {
776 r0 = returnFunc(ctx, app, opID)
777 } else {
778 r0 = ret.Get(0).(domain.AppOperation)
779 }
780 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
781 r1 = returnFunc(ctx, app, opID)
782 } else {
783 r1 = ret.Error(1)
784 }
785 return r0, r1
786}
787
788// MockAppState_LoadOperation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadOperation'
789type MockAppState_LoadOperation_Call struct {
790 *mock.Call
791}
792
793// LoadOperation is a helper method to define mock.On call
794// - ctx context.Context
795// - app string
796// - opID string
797func (_e *MockAppState_Expecter) LoadOperation(ctx any, app any, opID any) *MockAppState_LoadOperation_Call {
798 return &MockAppState_LoadOperation_Call{Call: _e.mock.On("LoadOperation", ctx, app, opID)}
799}
800
801func (_c *MockAppState_LoadOperation_Call) Run(run func(ctx context.Context, app string, opID string)) *MockAppState_LoadOperation_Call {
802 _c.Call.Run(func(args mock.Arguments) {
803 var arg0 context.Context
804 if args[0] != nil {
805 arg0 = args[0].(context.Context)
806 }
807 var arg1 string
808 if args[1] != nil {
809 arg1 = args[1].(string)
810 }
811 var arg2 string
812 if args[2] != nil {
813 arg2 = args[2].(string)
814 }
815 run(
816 arg0,
817 arg1,
818 arg2,
819 )
820 })
821 return _c
822}
823
824func (_c *MockAppState_LoadOperation_Call) Return(appOperation domain.AppOperation, err error) *MockAppState_LoadOperation_Call {
825 _c.Call.Return(appOperation, err)
826 return _c
827}
828
829func (_c *MockAppState_LoadOperation_Call) RunAndReturn(run func(ctx context.Context, app string, opID string) (domain.AppOperation, error)) *MockAppState_LoadOperation_Call {
830 _c.Call.Return(run)
831 return _c
832}
833
834// LoadOwnership provides a mock function for the type MockAppState
835func (_mock *MockAppState) LoadOwnership(ctx context.Context, app string) (domain.AppOwnership, error) {
836 ret := _mock.Called(ctx, app)
837
838 if len(ret) == 0 {
839 panic("no return value specified for LoadOwnership")
840 }
841
842 var r0 domain.AppOwnership
843 var r1 error
844 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (domain.AppOwnership, error)); ok {
845 return returnFunc(ctx, app)
846 }
847 if returnFunc, ok := ret.Get(0).(func(context.Context, string) domain.AppOwnership); ok {
848 r0 = returnFunc(ctx, app)
849 } else {
850 r0 = ret.Get(0).(domain.AppOwnership)
851 }
852 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
853 r1 = returnFunc(ctx, app)
854 } else {
855 r1 = ret.Error(1)
856 }
857 return r0, r1
858}
859
860// MockAppState_LoadOwnership_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadOwnership'
861type MockAppState_LoadOwnership_Call struct {
862 *mock.Call
863}
864
865// LoadOwnership is a helper method to define mock.On call
866// - ctx context.Context
867// - app string
868func (_e *MockAppState_Expecter) LoadOwnership(ctx any, app any) *MockAppState_LoadOwnership_Call {
869 return &MockAppState_LoadOwnership_Call{Call: _e.mock.On("LoadOwnership", ctx, app)}
870}
871
872func (_c *MockAppState_LoadOwnership_Call) Run(run func(ctx context.Context, app string)) *MockAppState_LoadOwnership_Call {
873 _c.Call.Run(func(args mock.Arguments) {
874 var arg0 context.Context
875 if args[0] != nil {
876 arg0 = args[0].(context.Context)
877 }
878 var arg1 string
879 if args[1] != nil {
880 arg1 = args[1].(string)
881 }
882 run(
883 arg0,
884 arg1,
885 )
886 })
887 return _c
888}
889
890func (_c *MockAppState_LoadOwnership_Call) Return(appOwnership domain.AppOwnership, err error) *MockAppState_LoadOwnership_Call {
891 _c.Call.Return(appOwnership, err)
892 return _c
893}
894
895func (_c *MockAppState_LoadOwnership_Call) RunAndReturn(run func(ctx context.Context, app string) (domain.AppOwnership, error)) *MockAppState_LoadOwnership_Call {
896 _c.Call.Return(run)
897 return _c
898}
899
900// LoadRecoveryInhibitions provides a mock function for the type MockAppState
901func (_mock *MockAppState) LoadRecoveryInhibitions(ctx context.Context, app string) ([]domain.AppRecoveryInhibition, error) {
902 ret := _mock.Called(ctx, app)
903
904 if len(ret) == 0 {
905 panic("no return value specified for LoadRecoveryInhibitions")
906 }
907
908 var r0 []domain.AppRecoveryInhibition
909 var r1 error
910 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]domain.AppRecoveryInhibition, error)); ok {
911 return returnFunc(ctx, app)
912 }
913 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []domain.AppRecoveryInhibition); ok {
914 r0 = returnFunc(ctx, app)
915 } else {
916 if ret.Get(0) != nil {
917 r0 = ret.Get(0).([]domain.AppRecoveryInhibition)
918 }
919 }
920 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
921 r1 = returnFunc(ctx, app)
922 } else {
923 r1 = ret.Error(1)
924 }
925 return r0, r1
926}
927
928// MockAppState_LoadRecoveryInhibitions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadRecoveryInhibitions'
929type MockAppState_LoadRecoveryInhibitions_Call struct {
930 *mock.Call
931}
932
933// LoadRecoveryInhibitions is a helper method to define mock.On call
934// - ctx context.Context
935// - app string
936func (_e *MockAppState_Expecter) LoadRecoveryInhibitions(ctx any, app any) *MockAppState_LoadRecoveryInhibitions_Call {
937 return &MockAppState_LoadRecoveryInhibitions_Call{Call: _e.mock.On("LoadRecoveryInhibitions", ctx, app)}
938}
939
940func (_c *MockAppState_LoadRecoveryInhibitions_Call) Run(run func(ctx context.Context, app string)) *MockAppState_LoadRecoveryInhibitions_Call {
941 _c.Call.Run(func(args mock.Arguments) {
942 var arg0 context.Context
943 if args[0] != nil {
944 arg0 = args[0].(context.Context)
945 }
946 var arg1 string
947 if args[1] != nil {
948 arg1 = args[1].(string)
949 }
950 run(
951 arg0,
952 arg1,
953 )
954 })
955 return _c
956}
957
958func (_c *MockAppState_LoadRecoveryInhibitions_Call) Return(appRecoveryInhibitions []domain.AppRecoveryInhibition, err error) *MockAppState_LoadRecoveryInhibitions_Call {
959 _c.Call.Return(appRecoveryInhibitions, err)
960 return _c
961}
962
963func (_c *MockAppState_LoadRecoveryInhibitions_Call) RunAndReturn(run func(ctx context.Context, app string) ([]domain.AppRecoveryInhibition, error)) *MockAppState_LoadRecoveryInhibitions_Call {
964 _c.Call.Return(run)
965 return _c
966}
967
968// LoadRevision provides a mock function for the type MockAppState
969func (_mock *MockAppState) LoadRevision(ctx context.Context, app string, revision string) (domain.AppDesiredRevision, error) {
970 ret := _mock.Called(ctx, app, revision)
971
972 if len(ret) == 0 {
973 panic("no return value specified for LoadRevision")
974 }
975
976 var r0 domain.AppDesiredRevision
977 var r1 error
978 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (domain.AppDesiredRevision, error)); ok {
979 return returnFunc(ctx, app, revision)
980 }
981 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) domain.AppDesiredRevision); ok {
982 r0 = returnFunc(ctx, app, revision)
983 } else {
984 r0 = ret.Get(0).(domain.AppDesiredRevision)
985 }
986 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
987 r1 = returnFunc(ctx, app, revision)
988 } else {
989 r1 = ret.Error(1)
990 }
991 return r0, r1
992}
993
994// MockAppState_LoadRevision_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadRevision'
995type MockAppState_LoadRevision_Call struct {
996 *mock.Call
997}
998
999// LoadRevision is a helper method to define mock.On call
1000// - ctx context.Context
1001// - app string
1002// - revision string
1003func (_e *MockAppState_Expecter) LoadRevision(ctx any, app any, revision any) *MockAppState_LoadRevision_Call {
1004 return &MockAppState_LoadRevision_Call{Call: _e.mock.On("LoadRevision", ctx, app, revision)}
1005}
1006
1007func (_c *MockAppState_LoadRevision_Call) Run(run func(ctx context.Context, app string, revision string)) *MockAppState_LoadRevision_Call {
1008 _c.Call.Run(func(args mock.Arguments) {
1009 var arg0 context.Context
1010 if args[0] != nil {
1011 arg0 = args[0].(context.Context)
1012 }
1013 var arg1 string
1014 if args[1] != nil {
1015 arg1 = args[1].(string)
1016 }
1017 var arg2 string
1018 if args[2] != nil {
1019 arg2 = args[2].(string)
1020 }
1021 run(
1022 arg0,
1023 arg1,
1024 arg2,
1025 )
1026 })
1027 return _c
1028}
1029
1030func (_c *MockAppState_LoadRevision_Call) Return(appDesiredRevision domain.AppDesiredRevision, err error) *MockAppState_LoadRevision_Call {
1031 _c.Call.Return(appDesiredRevision, err)
1032 return _c
1033}
1034
1035func (_c *MockAppState_LoadRevision_Call) RunAndReturn(run func(ctx context.Context, app string, revision string) (domain.AppDesiredRevision, error)) *MockAppState_LoadRevision_Call {
1036 _c.Call.Return(run)
1037 return _c
1038}
1039
1040// Recover provides a mock function for the type MockAppState
1041func (_mock *MockAppState) Recover(ctx context.Context) error {
1042 ret := _mock.Called(ctx)
1043
1044 if len(ret) == 0 {
1045 panic("no return value specified for Recover")
1046 }
1047
1048 var r0 error
1049 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1050 r0 = returnFunc(ctx)
1051 } else {
1052 r0 = ret.Error(0)
1053 }
1054 return r0
1055}
1056
1057// MockAppState_Recover_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recover'
1058type MockAppState_Recover_Call struct {
1059 *mock.Call
1060}
1061
1062// Recover is a helper method to define mock.On call
1063// - ctx context.Context
1064func (_e *MockAppState_Expecter) Recover(ctx any) *MockAppState_Recover_Call {
1065 return &MockAppState_Recover_Call{Call: _e.mock.On("Recover", ctx)}
1066}
1067
1068func (_c *MockAppState_Recover_Call) Run(run func(ctx context.Context)) *MockAppState_Recover_Call {
1069 _c.Call.Run(func(args mock.Arguments) {
1070 var arg0 context.Context
1071 if args[0] != nil {
1072 arg0 = args[0].(context.Context)
1073 }
1074 run(
1075 arg0,
1076 )
1077 })
1078 return _c
1079}
1080
1081func (_c *MockAppState_Recover_Call) Return(err error) *MockAppState_Recover_Call {
1082 _c.Call.Return(err)
1083 return _c
1084}
1085
1086func (_c *MockAppState_Recover_Call) RunAndReturn(run func(ctx context.Context) error) *MockAppState_Recover_Call {
1087 _c.Call.Return(run)
1088 return _c
1089}
1090
1091// RegisterBackendBinds provides a mock function for the type MockAppState
1092func (_mock *MockAppState) RegisterBackendBinds(ctx context.Context, binds []domain.AppListenerReservation) error {
1093 ret := _mock.Called(ctx, binds)
1094
1095 if len(ret) == 0 {
1096 panic("no return value specified for RegisterBackendBinds")
1097 }
1098
1099 var r0 error
1100 if returnFunc, ok := ret.Get(0).(func(context.Context, []domain.AppListenerReservation) error); ok {
1101 r0 = returnFunc(ctx, binds)
1102 } else {
1103 r0 = ret.Error(0)
1104 }
1105 return r0
1106}
1107
1108// MockAppState_RegisterBackendBinds_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterBackendBinds'
1109type MockAppState_RegisterBackendBinds_Call struct {
1110 *mock.Call
1111}
1112
1113// RegisterBackendBinds is a helper method to define mock.On call
1114// - ctx context.Context
1115// - binds []domain.AppListenerReservation
1116func (_e *MockAppState_Expecter) RegisterBackendBinds(ctx any, binds any) *MockAppState_RegisterBackendBinds_Call {
1117 return &MockAppState_RegisterBackendBinds_Call{Call: _e.mock.On("RegisterBackendBinds", ctx, binds)}
1118}
1119
1120func (_c *MockAppState_RegisterBackendBinds_Call) Run(run func(ctx context.Context, binds []domain.AppListenerReservation)) *MockAppState_RegisterBackendBinds_Call {
1121 _c.Call.Run(func(args mock.Arguments) {
1122 var arg0 context.Context
1123 if args[0] != nil {
1124 arg0 = args[0].(context.Context)
1125 }
1126 var arg1 []domain.AppListenerReservation
1127 if args[1] != nil {
1128 arg1 = args[1].([]domain.AppListenerReservation)
1129 }
1130 run(
1131 arg0,
1132 arg1,
1133 )
1134 })
1135 return _c
1136}
1137
1138func (_c *MockAppState_RegisterBackendBinds_Call) Return(err error) *MockAppState_RegisterBackendBinds_Call {
1139 _c.Call.Return(err)
1140 return _c
1141}
1142
1143func (_c *MockAppState_RegisterBackendBinds_Call) RunAndReturn(run func(ctx context.Context, binds []domain.AppListenerReservation) error) *MockAppState_RegisterBackendBinds_Call {
1144 _c.Call.Return(run)
1145 return _c
1146}
1147
1148// ReleaseBackendBinds provides a mock function for the type MockAppState
1149func (_mock *MockAppState) ReleaseBackendBinds(ctx context.Context, app string, containerID string) error {
1150 ret := _mock.Called(ctx, app, containerID)
1151
1152 if len(ret) == 0 {
1153 panic("no return value specified for ReleaseBackendBinds")
1154 }
1155
1156 var r0 error
1157 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
1158 r0 = returnFunc(ctx, app, containerID)
1159 } else {
1160 r0 = ret.Error(0)
1161 }
1162 return r0
1163}
1164
1165// MockAppState_ReleaseBackendBinds_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReleaseBackendBinds'
1166type MockAppState_ReleaseBackendBinds_Call struct {
1167 *mock.Call
1168}
1169
1170// ReleaseBackendBinds is a helper method to define mock.On call
1171// - ctx context.Context
1172// - app string
1173// - containerID string
1174func (_e *MockAppState_Expecter) ReleaseBackendBinds(ctx any, app any, containerID any) *MockAppState_ReleaseBackendBinds_Call {
1175 return &MockAppState_ReleaseBackendBinds_Call{Call: _e.mock.On("ReleaseBackendBinds", ctx, app, containerID)}
1176}
1177
1178func (_c *MockAppState_ReleaseBackendBinds_Call) Run(run func(ctx context.Context, app string, containerID string)) *MockAppState_ReleaseBackendBinds_Call {
1179 _c.Call.Run(func(args mock.Arguments) {
1180 var arg0 context.Context
1181 if args[0] != nil {
1182 arg0 = args[0].(context.Context)
1183 }
1184 var arg1 string
1185 if args[1] != nil {
1186 arg1 = args[1].(string)
1187 }
1188 var arg2 string
1189 if args[2] != nil {
1190 arg2 = args[2].(string)
1191 }
1192 run(
1193 arg0,
1194 arg1,
1195 arg2,
1196 )
1197 })
1198 return _c
1199}
1200
1201func (_c *MockAppState_ReleaseBackendBinds_Call) Return(err error) *MockAppState_ReleaseBackendBinds_Call {
1202 _c.Call.Return(err)
1203 return _c
1204}
1205
1206func (_c *MockAppState_ReleaseBackendBinds_Call) RunAndReturn(run func(ctx context.Context, app string, containerID string) error) *MockAppState_ReleaseBackendBinds_Call {
1207 _c.Call.Return(run)
1208 return _c
1209}
1210
1211// RetireApp provides a mock function for the type MockAppState
1212func (_mock *MockAppState) RetireApp(ctx context.Context, app string) error {
1213 ret := _mock.Called(ctx, app)
1214
1215 if len(ret) == 0 {
1216 panic("no return value specified for RetireApp")
1217 }
1218
1219 var r0 error
1220 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
1221 r0 = returnFunc(ctx, app)
1222 } else {
1223 r0 = ret.Error(0)
1224 }
1225 return r0
1226}
1227
1228// MockAppState_RetireApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetireApp'
1229type MockAppState_RetireApp_Call struct {
1230 *mock.Call
1231}
1232
1233// RetireApp is a helper method to define mock.On call
1234// - ctx context.Context
1235// - app string
1236func (_e *MockAppState_Expecter) RetireApp(ctx any, app any) *MockAppState_RetireApp_Call {
1237 return &MockAppState_RetireApp_Call{Call: _e.mock.On("RetireApp", ctx, app)}
1238}
1239
1240func (_c *MockAppState_RetireApp_Call) Run(run func(ctx context.Context, app string)) *MockAppState_RetireApp_Call {
1241 _c.Call.Run(func(args mock.Arguments) {
1242 var arg0 context.Context
1243 if args[0] != nil {
1244 arg0 = args[0].(context.Context)
1245 }
1246 var arg1 string
1247 if args[1] != nil {
1248 arg1 = args[1].(string)
1249 }
1250 run(
1251 arg0,
1252 arg1,
1253 )
1254 })
1255 return _c
1256}
1257
1258func (_c *MockAppState_RetireApp_Call) Return(err error) *MockAppState_RetireApp_Call {
1259 _c.Call.Return(err)
1260 return _c
1261}
1262
1263func (_c *MockAppState_RetireApp_Call) RunAndReturn(run func(ctx context.Context, app string) error) *MockAppState_RetireApp_Call {
1264 _c.Call.Return(run)
1265 return _c
1266}
1267
1268// SaveActive provides a mock function for the type MockAppState
1269func (_mock *MockAppState) SaveActive(ctx context.Context, active domain.AppActive) error {
1270 ret := _mock.Called(ctx, active)
1271
1272 if len(ret) == 0 {
1273 panic("no return value specified for SaveActive")
1274 }
1275
1276 var r0 error
1277 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.AppActive) error); ok {
1278 r0 = returnFunc(ctx, active)
1279 } else {
1280 r0 = ret.Error(0)
1281 }
1282 return r0
1283}
1284
1285// MockAppState_SaveActive_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveActive'
1286type MockAppState_SaveActive_Call struct {
1287 *mock.Call
1288}
1289
1290// SaveActive is a helper method to define mock.On call
1291// - ctx context.Context
1292// - active domain.AppActive
1293func (_e *MockAppState_Expecter) SaveActive(ctx any, active any) *MockAppState_SaveActive_Call {
1294 return &MockAppState_SaveActive_Call{Call: _e.mock.On("SaveActive", ctx, active)}
1295}
1296
1297func (_c *MockAppState_SaveActive_Call) Run(run func(ctx context.Context, active domain.AppActive)) *MockAppState_SaveActive_Call {
1298 _c.Call.Run(func(args mock.Arguments) {
1299 var arg0 context.Context
1300 if args[0] != nil {
1301 arg0 = args[0].(context.Context)
1302 }
1303 var arg1 domain.AppActive
1304 if args[1] != nil {
1305 arg1 = args[1].(domain.AppActive)
1306 }
1307 run(
1308 arg0,
1309 arg1,
1310 )
1311 })
1312 return _c
1313}
1314
1315func (_c *MockAppState_SaveActive_Call) Return(err error) *MockAppState_SaveActive_Call {
1316 _c.Call.Return(err)
1317 return _c
1318}
1319
1320func (_c *MockAppState_SaveActive_Call) RunAndReturn(run func(ctx context.Context, active domain.AppActive) error) *MockAppState_SaveActive_Call {
1321 _c.Call.Return(run)
1322 return _c
1323}
1324
1325// SaveIntent provides a mock function for the type MockAppState
1326func (_mock *MockAppState) SaveIntent(ctx context.Context, intent domain.AppStopIntent) error {
1327 ret := _mock.Called(ctx, intent)
1328
1329 if len(ret) == 0 {
1330 panic("no return value specified for SaveIntent")
1331 }
1332
1333 var r0 error
1334 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.AppStopIntent) error); ok {
1335 r0 = returnFunc(ctx, intent)
1336 } else {
1337 r0 = ret.Error(0)
1338 }
1339 return r0
1340}
1341
1342// MockAppState_SaveIntent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveIntent'
1343type MockAppState_SaveIntent_Call struct {
1344 *mock.Call
1345}
1346
1347// SaveIntent is a helper method to define mock.On call
1348// - ctx context.Context
1349// - intent domain.AppStopIntent
1350func (_e *MockAppState_Expecter) SaveIntent(ctx any, intent any) *MockAppState_SaveIntent_Call {
1351 return &MockAppState_SaveIntent_Call{Call: _e.mock.On("SaveIntent", ctx, intent)}
1352}
1353
1354func (_c *MockAppState_SaveIntent_Call) Run(run func(ctx context.Context, intent domain.AppStopIntent)) *MockAppState_SaveIntent_Call {
1355 _c.Call.Run(func(args mock.Arguments) {
1356 var arg0 context.Context
1357 if args[0] != nil {
1358 arg0 = args[0].(context.Context)
1359 }
1360 var arg1 domain.AppStopIntent
1361 if args[1] != nil {
1362 arg1 = args[1].(domain.AppStopIntent)
1363 }
1364 run(
1365 arg0,
1366 arg1,
1367 )
1368 })
1369 return _c
1370}
1371
1372func (_c *MockAppState_SaveIntent_Call) Return(err error) *MockAppState_SaveIntent_Call {
1373 _c.Call.Return(err)
1374 return _c
1375}
1376
1377func (_c *MockAppState_SaveIntent_Call) RunAndReturn(run func(ctx context.Context, intent domain.AppStopIntent) error) *MockAppState_SaveIntent_Call {
1378 _c.Call.Return(run)
1379 return _c
1380}
1381
1382// SaveOperation provides a mock function for the type MockAppState
1383func (_mock *MockAppState) SaveOperation(ctx context.Context, op domain.AppOperation) error {
1384 ret := _mock.Called(ctx, op)
1385
1386 if len(ret) == 0 {
1387 panic("no return value specified for SaveOperation")
1388 }
1389
1390 var r0 error
1391 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.AppOperation) error); ok {
1392 r0 = returnFunc(ctx, op)
1393 } else {
1394 r0 = ret.Error(0)
1395 }
1396 return r0
1397}
1398
1399// MockAppState_SaveOperation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveOperation'
1400type MockAppState_SaveOperation_Call struct {
1401 *mock.Call
1402}
1403
1404// SaveOperation is a helper method to define mock.On call
1405// - ctx context.Context
1406// - op domain.AppOperation
1407func (_e *MockAppState_Expecter) SaveOperation(ctx any, op any) *MockAppState_SaveOperation_Call {
1408 return &MockAppState_SaveOperation_Call{Call: _e.mock.On("SaveOperation", ctx, op)}
1409}
1410
1411func (_c *MockAppState_SaveOperation_Call) Run(run func(ctx context.Context, op domain.AppOperation)) *MockAppState_SaveOperation_Call {
1412 _c.Call.Run(func(args mock.Arguments) {
1413 var arg0 context.Context
1414 if args[0] != nil {
1415 arg0 = args[0].(context.Context)
1416 }
1417 var arg1 domain.AppOperation
1418 if args[1] != nil {
1419 arg1 = args[1].(domain.AppOperation)
1420 }
1421 run(
1422 arg0,
1423 arg1,
1424 )
1425 })
1426 return _c
1427}
1428
1429func (_c *MockAppState_SaveOperation_Call) Return(err error) *MockAppState_SaveOperation_Call {
1430 _c.Call.Return(err)
1431 return _c
1432}
1433
1434func (_c *MockAppState_SaveOperation_Call) RunAndReturn(run func(ctx context.Context, op domain.AppOperation) error) *MockAppState_SaveOperation_Call {
1435 _c.Call.Return(run)
1436 return _c
1437}
1438
1439// SaveOwnership provides a mock function for the type MockAppState
1440func (_mock *MockAppState) SaveOwnership(ctx context.Context, ownership domain.AppOwnership) error {
1441 ret := _mock.Called(ctx, ownership)
1442
1443 if len(ret) == 0 {
1444 panic("no return value specified for SaveOwnership")
1445 }
1446
1447 var r0 error
1448 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.AppOwnership) error); ok {
1449 r0 = returnFunc(ctx, ownership)
1450 } else {
1451 r0 = ret.Error(0)
1452 }
1453 return r0
1454}
1455
1456// MockAppState_SaveOwnership_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveOwnership'
1457type MockAppState_SaveOwnership_Call struct {
1458 *mock.Call
1459}
1460
1461// SaveOwnership is a helper method to define mock.On call
1462// - ctx context.Context
1463// - ownership domain.AppOwnership
1464func (_e *MockAppState_Expecter) SaveOwnership(ctx any, ownership any) *MockAppState_SaveOwnership_Call {
1465 return &MockAppState_SaveOwnership_Call{Call: _e.mock.On("SaveOwnership", ctx, ownership)}
1466}
1467
1468func (_c *MockAppState_SaveOwnership_Call) Run(run func(ctx context.Context, ownership domain.AppOwnership)) *MockAppState_SaveOwnership_Call {
1469 _c.Call.Run(func(args mock.Arguments) {
1470 var arg0 context.Context
1471 if args[0] != nil {
1472 arg0 = args[0].(context.Context)
1473 }
1474 var arg1 domain.AppOwnership
1475 if args[1] != nil {
1476 arg1 = args[1].(domain.AppOwnership)
1477 }
1478 run(
1479 arg0,
1480 arg1,
1481 )
1482 })
1483 return _c
1484}
1485
1486func (_c *MockAppState_SaveOwnership_Call) Return(err error) *MockAppState_SaveOwnership_Call {
1487 _c.Call.Return(err)
1488 return _c
1489}
1490
1491func (_c *MockAppState_SaveOwnership_Call) RunAndReturn(run func(ctx context.Context, ownership domain.AppOwnership) error) *MockAppState_SaveOwnership_Call {
1492 _c.Call.Return(run)
1493 return _c
1494}
1495
1496// SaveRecoveryInhibition provides a mock function for the type MockAppState
1497func (_mock *MockAppState) SaveRecoveryInhibition(ctx context.Context, inhibition domain.AppRecoveryInhibition) error {
1498 ret := _mock.Called(ctx, inhibition)
1499
1500 if len(ret) == 0 {
1501 panic("no return value specified for SaveRecoveryInhibition")
1502 }
1503
1504 var r0 error
1505 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.AppRecoveryInhibition) error); ok {
1506 r0 = returnFunc(ctx, inhibition)
1507 } else {
1508 r0 = ret.Error(0)
1509 }
1510 return r0
1511}
1512
1513// MockAppState_SaveRecoveryInhibition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveRecoveryInhibition'
1514type MockAppState_SaveRecoveryInhibition_Call struct {
1515 *mock.Call
1516}
1517
1518// SaveRecoveryInhibition is a helper method to define mock.On call
1519// - ctx context.Context
1520// - inhibition domain.AppRecoveryInhibition
1521func (_e *MockAppState_Expecter) SaveRecoveryInhibition(ctx any, inhibition any) *MockAppState_SaveRecoveryInhibition_Call {
1522 return &MockAppState_SaveRecoveryInhibition_Call{Call: _e.mock.On("SaveRecoveryInhibition", ctx, inhibition)}
1523}
1524
1525func (_c *MockAppState_SaveRecoveryInhibition_Call) Run(run func(ctx context.Context, inhibition domain.AppRecoveryInhibition)) *MockAppState_SaveRecoveryInhibition_Call {
1526 _c.Call.Run(func(args mock.Arguments) {
1527 var arg0 context.Context
1528 if args[0] != nil {
1529 arg0 = args[0].(context.Context)
1530 }
1531 var arg1 domain.AppRecoveryInhibition
1532 if args[1] != nil {
1533 arg1 = args[1].(domain.AppRecoveryInhibition)
1534 }
1535 run(
1536 arg0,
1537 arg1,
1538 )
1539 })
1540 return _c
1541}
1542
1543func (_c *MockAppState_SaveRecoveryInhibition_Call) Return(err error) *MockAppState_SaveRecoveryInhibition_Call {
1544 _c.Call.Return(err)
1545 return _c
1546}
1547
1548func (_c *MockAppState_SaveRecoveryInhibition_Call) RunAndReturn(run func(ctx context.Context, inhibition domain.AppRecoveryInhibition) error) *MockAppState_SaveRecoveryInhibition_Call {
1549 _c.Call.Return(run)
1550 return _c
1551}