1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package portsmocks
6
7import (
8 "context"
9
10 "github.com/bnema/vev/internal/domain"
11 "github.com/bnema/vev/internal/ports"
12 mock "github.com/stretchr/testify/mock"
13)
14
15// NewMockCatalogue creates a new instance of MockCatalogue. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
16// The first argument is typically a *testing.T value.
17func NewMockCatalogue(t interface {
18 mock.TestingT
19 Cleanup(func())
20}) *MockCatalogue {
21 if helper, ok := t.(interface{ Helper() }); ok {
22 helper.Helper()
23 }
24
25 mock := &MockCatalogue{}
26 mock.Mock.Test(t)
27
28 t.Cleanup(func() {
29 if helper, ok := t.(interface{ Helper() }); ok {
30 helper.Helper()
31 }
32 mock.AssertExpectations(t)
33 })
34
35 return mock
36}
37
38// MockCatalogue is an autogenerated mock type for the Catalogue type
39type MockCatalogue struct {
40 mock.Mock
41}
42
43type MockCatalogue_Expecter struct {
44 mock *mock.Mock
45}
46
47func (_m *MockCatalogue) EXPECT() *MockCatalogue_Expecter {
48 return &MockCatalogue_Expecter{mock: &_m.Mock}
49}
50
51// Close provides a mock function for the type MockCatalogue
52func (_mock *MockCatalogue) Close() error {
53 ret := _mock.Called()
54
55 if len(ret) == 0 {
56 panic("no return value specified for Close")
57 }
58
59 var r0 error
60 if returnFunc, ok := ret.Get(0).(func() error); ok {
61 r0 = returnFunc()
62 } else {
63 r0 = ret.Error(0)
64 }
65 return r0
66}
67
68// MockCatalogue_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
69type MockCatalogue_Close_Call struct {
70 *mock.Call
71}
72
73// Close is a helper method to define mock.On call
74func (_e *MockCatalogue_Expecter) Close() *MockCatalogue_Close_Call {
75 return &MockCatalogue_Close_Call{Call: _e.mock.On("Close")}
76}
77
78func (_c *MockCatalogue_Close_Call) Run(run func()) *MockCatalogue_Close_Call {
79 _c.Call.Run(func(args mock.Arguments) {
80 run()
81 })
82 return _c
83}
84
85func (_c *MockCatalogue_Close_Call) Return(err error) *MockCatalogue_Close_Call {
86 _c.Call.Return(err)
87 return _c
88}
89
90func (_c *MockCatalogue_Close_Call) RunAndReturn(run func() error) *MockCatalogue_Close_Call {
91 _c.Call.Return(run)
92 return _c
93}
94
95// Create provides a mock function for the type MockCatalogue
96func (_mock *MockCatalogue) Create(catalogueRecord domain.CatalogueRecord) error {
97 ret := _mock.Called(catalogueRecord)
98
99 if len(ret) == 0 {
100 panic("no return value specified for Create")
101 }
102
103 var r0 error
104 if returnFunc, ok := ret.Get(0).(func(domain.CatalogueRecord) error); ok {
105 r0 = returnFunc(catalogueRecord)
106 } else {
107 r0 = ret.Error(0)
108 }
109 return r0
110}
111
112// MockCatalogue_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'
113type MockCatalogue_Create_Call struct {
114 *mock.Call
115}
116
117// Create is a helper method to define mock.On call
118// - catalogueRecord domain.CatalogueRecord
119func (_e *MockCatalogue_Expecter) Create(catalogueRecord any) *MockCatalogue_Create_Call {
120 return &MockCatalogue_Create_Call{Call: _e.mock.On("Create", catalogueRecord)}
121}
122
123func (_c *MockCatalogue_Create_Call) Run(run func(catalogueRecord domain.CatalogueRecord)) *MockCatalogue_Create_Call {
124 _c.Call.Run(func(args mock.Arguments) {
125 var arg0 domain.CatalogueRecord
126 if args[0] != nil {
127 arg0 = args[0].(domain.CatalogueRecord)
128 }
129 run(
130 arg0,
131 )
132 })
133 return _c
134}
135
136func (_c *MockCatalogue_Create_Call) Return(err error) *MockCatalogue_Create_Call {
137 _c.Call.Return(err)
138 return _c
139}
140
141func (_c *MockCatalogue_Create_Call) RunAndReturn(run func(catalogueRecord domain.CatalogueRecord) error) *MockCatalogue_Create_Call {
142 _c.Call.Return(run)
143 return _c
144}
145
146// Delete provides a mock function for the type MockCatalogue
147func (_mock *MockCatalogue) Delete(s string) error {
148 ret := _mock.Called(s)
149
150 if len(ret) == 0 {
151 panic("no return value specified for Delete")
152 }
153
154 var r0 error
155 if returnFunc, ok := ret.Get(0).(func(string) error); ok {
156 r0 = returnFunc(s)
157 } else {
158 r0 = ret.Error(0)
159 }
160 return r0
161}
162
163// MockCatalogue_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
164type MockCatalogue_Delete_Call struct {
165 *mock.Call
166}
167
168// Delete is a helper method to define mock.On call
169// - s string
170func (_e *MockCatalogue_Expecter) Delete(s any) *MockCatalogue_Delete_Call {
171 return &MockCatalogue_Delete_Call{Call: _e.mock.On("Delete", s)}
172}
173
174func (_c *MockCatalogue_Delete_Call) Run(run func(s string)) *MockCatalogue_Delete_Call {
175 _c.Call.Run(func(args mock.Arguments) {
176 var arg0 string
177 if args[0] != nil {
178 arg0 = args[0].(string)
179 }
180 run(
181 arg0,
182 )
183 })
184 return _c
185}
186
187func (_c *MockCatalogue_Delete_Call) Return(err error) *MockCatalogue_Delete_Call {
188 _c.Call.Return(err)
189 return _c
190}
191
192func (_c *MockCatalogue_Delete_Call) RunAndReturn(run func(s string) error) *MockCatalogue_Delete_Call {
193 _c.Call.Return(run)
194 return _c
195}
196
197// Record provides a mock function for the type MockCatalogue
198func (_mock *MockCatalogue) Record(s string) (domain.CatalogueRecord, bool, error) {
199 ret := _mock.Called(s)
200
201 if len(ret) == 0 {
202 panic("no return value specified for Record")
203 }
204
205 var r0 domain.CatalogueRecord
206 var r1 bool
207 var r2 error
208 if returnFunc, ok := ret.Get(0).(func(string) (domain.CatalogueRecord, bool, error)); ok {
209 return returnFunc(s)
210 }
211 if returnFunc, ok := ret.Get(0).(func(string) domain.CatalogueRecord); ok {
212 r0 = returnFunc(s)
213 } else {
214 r0 = ret.Get(0).(domain.CatalogueRecord)
215 }
216 if returnFunc, ok := ret.Get(1).(func(string) bool); ok {
217 r1 = returnFunc(s)
218 } else {
219 r1 = ret.Get(1).(bool)
220 }
221 if returnFunc, ok := ret.Get(2).(func(string) error); ok {
222 r2 = returnFunc(s)
223 } else {
224 r2 = ret.Error(2)
225 }
226 return r0, r1, r2
227}
228
229// MockCatalogue_Record_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Record'
230type MockCatalogue_Record_Call struct {
231 *mock.Call
232}
233
234// Record is a helper method to define mock.On call
235// - s string
236func (_e *MockCatalogue_Expecter) Record(s any) *MockCatalogue_Record_Call {
237 return &MockCatalogue_Record_Call{Call: _e.mock.On("Record", s)}
238}
239
240func (_c *MockCatalogue_Record_Call) Run(run func(s string)) *MockCatalogue_Record_Call {
241 _c.Call.Run(func(args mock.Arguments) {
242 var arg0 string
243 if args[0] != nil {
244 arg0 = args[0].(string)
245 }
246 run(
247 arg0,
248 )
249 })
250 return _c
251}
252
253func (_c *MockCatalogue_Record_Call) Return(catalogueRecord domain.CatalogueRecord, b bool, err error) *MockCatalogue_Record_Call {
254 _c.Call.Return(catalogueRecord, b, err)
255 return _c
256}
257
258func (_c *MockCatalogue_Record_Call) RunAndReturn(run func(s string) (domain.CatalogueRecord, bool, error)) *MockCatalogue_Record_Call {
259 _c.Call.Return(run)
260 return _c
261}
262
263// Records provides a mock function for the type MockCatalogue
264func (_mock *MockCatalogue) Records() ([]domain.CatalogueRecord, error) {
265 ret := _mock.Called()
266
267 if len(ret) == 0 {
268 panic("no return value specified for Records")
269 }
270
271 var r0 []domain.CatalogueRecord
272 var r1 error
273 if returnFunc, ok := ret.Get(0).(func() ([]domain.CatalogueRecord, error)); ok {
274 return returnFunc()
275 }
276 if returnFunc, ok := ret.Get(0).(func() []domain.CatalogueRecord); ok {
277 r0 = returnFunc()
278 } else {
279 if ret.Get(0) != nil {
280 r0 = ret.Get(0).([]domain.CatalogueRecord)
281 }
282 }
283 if returnFunc, ok := ret.Get(1).(func() error); ok {
284 r1 = returnFunc()
285 } else {
286 r1 = ret.Error(1)
287 }
288 return r0, r1
289}
290
291// MockCatalogue_Records_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Records'
292type MockCatalogue_Records_Call struct {
293 *mock.Call
294}
295
296// Records is a helper method to define mock.On call
297func (_e *MockCatalogue_Expecter) Records() *MockCatalogue_Records_Call {
298 return &MockCatalogue_Records_Call{Call: _e.mock.On("Records")}
299}
300
301func (_c *MockCatalogue_Records_Call) Run(run func()) *MockCatalogue_Records_Call {
302 _c.Call.Run(func(args mock.Arguments) {
303 run()
304 })
305 return _c
306}
307
308func (_c *MockCatalogue_Records_Call) Return(catalogueRecords []domain.CatalogueRecord, err error) *MockCatalogue_Records_Call {
309 _c.Call.Return(catalogueRecords, err)
310 return _c
311}
312
313func (_c *MockCatalogue_Records_Call) RunAndReturn(run func() ([]domain.CatalogueRecord, error)) *MockCatalogue_Records_Call {
314 _c.Call.Return(run)
315 return _c
316}
317
318// Rename provides a mock function for the type MockCatalogue
319func (_mock *MockCatalogue) Rename(s string, catalogueRecord domain.CatalogueRecord) error {
320 ret := _mock.Called(s, catalogueRecord)
321
322 if len(ret) == 0 {
323 panic("no return value specified for Rename")
324 }
325
326 var r0 error
327 if returnFunc, ok := ret.Get(0).(func(string, domain.CatalogueRecord) error); ok {
328 r0 = returnFunc(s, catalogueRecord)
329 } else {
330 r0 = ret.Error(0)
331 }
332 return r0
333}
334
335// MockCatalogue_Rename_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Rename'
336type MockCatalogue_Rename_Call struct {
337 *mock.Call
338}
339
340// Rename is a helper method to define mock.On call
341// - s string
342// - catalogueRecord domain.CatalogueRecord
343func (_e *MockCatalogue_Expecter) Rename(s any, catalogueRecord any) *MockCatalogue_Rename_Call {
344 return &MockCatalogue_Rename_Call{Call: _e.mock.On("Rename", s, catalogueRecord)}
345}
346
347func (_c *MockCatalogue_Rename_Call) Run(run func(s string, catalogueRecord domain.CatalogueRecord)) *MockCatalogue_Rename_Call {
348 _c.Call.Run(func(args mock.Arguments) {
349 var arg0 string
350 if args[0] != nil {
351 arg0 = args[0].(string)
352 }
353 var arg1 domain.CatalogueRecord
354 if args[1] != nil {
355 arg1 = args[1].(domain.CatalogueRecord)
356 }
357 run(
358 arg0,
359 arg1,
360 )
361 })
362 return _c
363}
364
365func (_c *MockCatalogue_Rename_Call) Return(err error) *MockCatalogue_Rename_Call {
366 _c.Call.Return(err)
367 return _c
368}
369
370func (_c *MockCatalogue_Rename_Call) RunAndReturn(run func(s string, catalogueRecord domain.CatalogueRecord) error) *MockCatalogue_Rename_Call {
371 _c.Call.Return(run)
372 return _c
373}
374
375// Replace provides a mock function for the type MockCatalogue
376func (_mock *MockCatalogue) Replace(s string, catalogueRecord domain.CatalogueRecord) error {
377 ret := _mock.Called(s, catalogueRecord)
378
379 if len(ret) == 0 {
380 panic("no return value specified for Replace")
381 }
382
383 var r0 error
384 if returnFunc, ok := ret.Get(0).(func(string, domain.CatalogueRecord) error); ok {
385 r0 = returnFunc(s, catalogueRecord)
386 } else {
387 r0 = ret.Error(0)
388 }
389 return r0
390}
391
392// MockCatalogue_Replace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Replace'
393type MockCatalogue_Replace_Call struct {
394 *mock.Call
395}
396
397// Replace is a helper method to define mock.On call
398// - s string
399// - catalogueRecord domain.CatalogueRecord
400func (_e *MockCatalogue_Expecter) Replace(s any, catalogueRecord any) *MockCatalogue_Replace_Call {
401 return &MockCatalogue_Replace_Call{Call: _e.mock.On("Replace", s, catalogueRecord)}
402}
403
404func (_c *MockCatalogue_Replace_Call) Run(run func(s string, catalogueRecord domain.CatalogueRecord)) *MockCatalogue_Replace_Call {
405 _c.Call.Run(func(args mock.Arguments) {
406 var arg0 string
407 if args[0] != nil {
408 arg0 = args[0].(string)
409 }
410 var arg1 domain.CatalogueRecord
411 if args[1] != nil {
412 arg1 = args[1].(domain.CatalogueRecord)
413 }
414 run(
415 arg0,
416 arg1,
417 )
418 })
419 return _c
420}
421
422func (_c *MockCatalogue_Replace_Call) Return(err error) *MockCatalogue_Replace_Call {
423 _c.Call.Return(err)
424 return _c
425}
426
427func (_c *MockCatalogue_Replace_Call) RunAndReturn(run func(s string, catalogueRecord domain.CatalogueRecord) error) *MockCatalogue_Replace_Call {
428 _c.Call.Return(run)
429 return _c
430}
431
432// Sync provides a mock function for the type MockCatalogue
433func (_mock *MockCatalogue) Sync() error {
434 ret := _mock.Called()
435
436 if len(ret) == 0 {
437 panic("no return value specified for Sync")
438 }
439
440 var r0 error
441 if returnFunc, ok := ret.Get(0).(func() error); ok {
442 r0 = returnFunc()
443 } else {
444 r0 = ret.Error(0)
445 }
446 return r0
447}
448
449// MockCatalogue_Sync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sync'
450type MockCatalogue_Sync_Call struct {
451 *mock.Call
452}
453
454// Sync is a helper method to define mock.On call
455func (_e *MockCatalogue_Expecter) Sync() *MockCatalogue_Sync_Call {
456 return &MockCatalogue_Sync_Call{Call: _e.mock.On("Sync")}
457}
458
459func (_c *MockCatalogue_Sync_Call) Run(run func()) *MockCatalogue_Sync_Call {
460 _c.Call.Run(func(args mock.Arguments) {
461 run()
462 })
463 return _c
464}
465
466func (_c *MockCatalogue_Sync_Call) Return(err error) *MockCatalogue_Sync_Call {
467 _c.Call.Return(err)
468 return _c
469}
470
471func (_c *MockCatalogue_Sync_Call) RunAndReturn(run func() error) *MockCatalogue_Sync_Call {
472 _c.Call.Return(run)
473 return _c
474}
475
476// UpdateMetadata provides a mock function for the type MockCatalogue
477func (_mock *MockCatalogue) UpdateMetadata(catalogueMetadataUpdate domain.CatalogueMetadataUpdate) error {
478 ret := _mock.Called(catalogueMetadataUpdate)
479
480 if len(ret) == 0 {
481 panic("no return value specified for UpdateMetadata")
482 }
483
484 var r0 error
485 if returnFunc, ok := ret.Get(0).(func(domain.CatalogueMetadataUpdate) error); ok {
486 r0 = returnFunc(catalogueMetadataUpdate)
487 } else {
488 r0 = ret.Error(0)
489 }
490 return r0
491}
492
493// MockCatalogue_UpdateMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateMetadata'
494type MockCatalogue_UpdateMetadata_Call struct {
495 *mock.Call
496}
497
498// UpdateMetadata is a helper method to define mock.On call
499// - catalogueMetadataUpdate domain.CatalogueMetadataUpdate
500func (_e *MockCatalogue_Expecter) UpdateMetadata(catalogueMetadataUpdate any) *MockCatalogue_UpdateMetadata_Call {
501 return &MockCatalogue_UpdateMetadata_Call{Call: _e.mock.On("UpdateMetadata", catalogueMetadataUpdate)}
502}
503
504func (_c *MockCatalogue_UpdateMetadata_Call) Run(run func(catalogueMetadataUpdate domain.CatalogueMetadataUpdate)) *MockCatalogue_UpdateMetadata_Call {
505 _c.Call.Run(func(args mock.Arguments) {
506 var arg0 domain.CatalogueMetadataUpdate
507 if args[0] != nil {
508 arg0 = args[0].(domain.CatalogueMetadataUpdate)
509 }
510 run(
511 arg0,
512 )
513 })
514 return _c
515}
516
517func (_c *MockCatalogue_UpdateMetadata_Call) Return(err error) *MockCatalogue_UpdateMetadata_Call {
518 _c.Call.Return(err)
519 return _c
520}
521
522func (_c *MockCatalogue_UpdateMetadata_Call) RunAndReturn(run func(catalogueMetadataUpdate domain.CatalogueMetadataUpdate) error) *MockCatalogue_UpdateMetadata_Call {
523 _c.Call.Return(run)
524 return _c
525}
526
527// NewMockSnapshotRepository creates a new instance of MockSnapshotRepository. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
528// The first argument is typically a *testing.T value.
529func NewMockSnapshotRepository(t interface {
530 mock.TestingT
531 Cleanup(func())
532}) *MockSnapshotRepository {
533 if helper, ok := t.(interface{ Helper() }); ok {
534 helper.Helper()
535 }
536
537 mock := &MockSnapshotRepository{}
538 mock.Mock.Test(t)
539
540 t.Cleanup(func() {
541 if helper, ok := t.(interface{ Helper() }); ok {
542 helper.Helper()
543 }
544 mock.AssertExpectations(t)
545 })
546
547 return mock
548}
549
550// MockSnapshotRepository is an autogenerated mock type for the SnapshotRepository type
551type MockSnapshotRepository struct {
552 mock.Mock
553}
554
555type MockSnapshotRepository_Expecter struct {
556 mock *mock.Mock
557}
558
559func (_m *MockSnapshotRepository) EXPECT() *MockSnapshotRepository_Expecter {
560 return &MockSnapshotRepository_Expecter{mock: &_m.Mock}
561}
562
563// CollectIncarnationGarbage provides a mock function for the type MockSnapshotRepository
564func (_mock *MockSnapshotRepository) CollectIncarnationGarbage(ctx context.Context, id domain.IncarnationID, keep *domain.CheckpointRef) error {
565 ret := _mock.Called(ctx, id, keep)
566
567 if len(ret) == 0 {
568 panic("no return value specified for CollectIncarnationGarbage")
569 }
570
571 var r0 error
572 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.IncarnationID, *domain.CheckpointRef) error); ok {
573 r0 = returnFunc(ctx, id, keep)
574 } else {
575 r0 = ret.Error(0)
576 }
577 return r0
578}
579
580// MockSnapshotRepository_CollectIncarnationGarbage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CollectIncarnationGarbage'
581type MockSnapshotRepository_CollectIncarnationGarbage_Call struct {
582 *mock.Call
583}
584
585// CollectIncarnationGarbage is a helper method to define mock.On call
586// - ctx context.Context
587// - id domain.IncarnationID
588// - keep *domain.CheckpointRef
589func (_e *MockSnapshotRepository_Expecter) CollectIncarnationGarbage(ctx any, id any, keep any) *MockSnapshotRepository_CollectIncarnationGarbage_Call {
590 return &MockSnapshotRepository_CollectIncarnationGarbage_Call{Call: _e.mock.On("CollectIncarnationGarbage", ctx, id, keep)}
591}
592
593func (_c *MockSnapshotRepository_CollectIncarnationGarbage_Call) Run(run func(ctx context.Context, id domain.IncarnationID, keep *domain.CheckpointRef)) *MockSnapshotRepository_CollectIncarnationGarbage_Call {
594 _c.Call.Run(func(args mock.Arguments) {
595 var arg0 context.Context
596 if args[0] != nil {
597 arg0 = args[0].(context.Context)
598 }
599 var arg1 domain.IncarnationID
600 if args[1] != nil {
601 arg1 = args[1].(domain.IncarnationID)
602 }
603 var arg2 *domain.CheckpointRef
604 if args[2] != nil {
605 arg2 = args[2].(*domain.CheckpointRef)
606 }
607 run(
608 arg0,
609 arg1,
610 arg2,
611 )
612 })
613 return _c
614}
615
616func (_c *MockSnapshotRepository_CollectIncarnationGarbage_Call) Return(err error) *MockSnapshotRepository_CollectIncarnationGarbage_Call {
617 _c.Call.Return(err)
618 return _c
619}
620
621func (_c *MockSnapshotRepository_CollectIncarnationGarbage_Call) RunAndReturn(run func(ctx context.Context, id domain.IncarnationID, keep *domain.CheckpointRef) error) *MockSnapshotRepository_CollectIncarnationGarbage_Call {
622 _c.Call.Return(run)
623 return _c
624}
625
626// DeleteIncarnation provides a mock function for the type MockSnapshotRepository
627func (_mock *MockSnapshotRepository) DeleteIncarnation(context1 context.Context, incarnationID domain.IncarnationID) error {
628 ret := _mock.Called(context1, incarnationID)
629
630 if len(ret) == 0 {
631 panic("no return value specified for DeleteIncarnation")
632 }
633
634 var r0 error
635 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.IncarnationID) error); ok {
636 r0 = returnFunc(context1, incarnationID)
637 } else {
638 r0 = ret.Error(0)
639 }
640 return r0
641}
642
643// MockSnapshotRepository_DeleteIncarnation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteIncarnation'
644type MockSnapshotRepository_DeleteIncarnation_Call struct {
645 *mock.Call
646}
647
648// DeleteIncarnation is a helper method to define mock.On call
649// - context1 context.Context
650// - incarnationID domain.IncarnationID
651func (_e *MockSnapshotRepository_Expecter) DeleteIncarnation(context1 any, incarnationID any) *MockSnapshotRepository_DeleteIncarnation_Call {
652 return &MockSnapshotRepository_DeleteIncarnation_Call{Call: _e.mock.On("DeleteIncarnation", context1, incarnationID)}
653}
654
655func (_c *MockSnapshotRepository_DeleteIncarnation_Call) Run(run func(context1 context.Context, incarnationID domain.IncarnationID)) *MockSnapshotRepository_DeleteIncarnation_Call {
656 _c.Call.Run(func(args mock.Arguments) {
657 var arg0 context.Context
658 if args[0] != nil {
659 arg0 = args[0].(context.Context)
660 }
661 var arg1 domain.IncarnationID
662 if args[1] != nil {
663 arg1 = args[1].(domain.IncarnationID)
664 }
665 run(
666 arg0,
667 arg1,
668 )
669 })
670 return _c
671}
672
673func (_c *MockSnapshotRepository_DeleteIncarnation_Call) Return(err error) *MockSnapshotRepository_DeleteIncarnation_Call {
674 _c.Call.Return(err)
675 return _c
676}
677
678func (_c *MockSnapshotRepository_DeleteIncarnation_Call) RunAndReturn(run func(context1 context.Context, incarnationID domain.IncarnationID) error) *MockSnapshotRepository_DeleteIncarnation_Call {
679 _c.Call.Return(run)
680 return _c
681}
682
683// LoadCheckpoint provides a mock function for the type MockSnapshotRepository
684func (_mock *MockSnapshotRepository) LoadCheckpoint(context1 context.Context, incarnationID domain.IncarnationID, s string, checkpointRef ports.CheckpointRef) (ports.SnapshotGeneration, error) {
685 ret := _mock.Called(context1, incarnationID, s, checkpointRef)
686
687 if len(ret) == 0 {
688 panic("no return value specified for LoadCheckpoint")
689 }
690
691 var r0 ports.SnapshotGeneration
692 var r1 error
693 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.IncarnationID, string, ports.CheckpointRef) (ports.SnapshotGeneration, error)); ok {
694 return returnFunc(context1, incarnationID, s, checkpointRef)
695 }
696 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.IncarnationID, string, ports.CheckpointRef) ports.SnapshotGeneration); ok {
697 r0 = returnFunc(context1, incarnationID, s, checkpointRef)
698 } else {
699 r0 = ret.Get(0).(ports.SnapshotGeneration)
700 }
701 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.IncarnationID, string, ports.CheckpointRef) error); ok {
702 r1 = returnFunc(context1, incarnationID, s, checkpointRef)
703 } else {
704 r1 = ret.Error(1)
705 }
706 return r0, r1
707}
708
709// MockSnapshotRepository_LoadCheckpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadCheckpoint'
710type MockSnapshotRepository_LoadCheckpoint_Call struct {
711 *mock.Call
712}
713
714// LoadCheckpoint is a helper method to define mock.On call
715// - context1 context.Context
716// - incarnationID domain.IncarnationID
717// - s string
718// - checkpointRef ports.CheckpointRef
719func (_e *MockSnapshotRepository_Expecter) LoadCheckpoint(context1 any, incarnationID any, s any, checkpointRef any) *MockSnapshotRepository_LoadCheckpoint_Call {
720 return &MockSnapshotRepository_LoadCheckpoint_Call{Call: _e.mock.On("LoadCheckpoint", context1, incarnationID, s, checkpointRef)}
721}
722
723func (_c *MockSnapshotRepository_LoadCheckpoint_Call) Run(run func(context1 context.Context, incarnationID domain.IncarnationID, s string, checkpointRef ports.CheckpointRef)) *MockSnapshotRepository_LoadCheckpoint_Call {
724 _c.Call.Run(func(args mock.Arguments) {
725 var arg0 context.Context
726 if args[0] != nil {
727 arg0 = args[0].(context.Context)
728 }
729 var arg1 domain.IncarnationID
730 if args[1] != nil {
731 arg1 = args[1].(domain.IncarnationID)
732 }
733 var arg2 string
734 if args[2] != nil {
735 arg2 = args[2].(string)
736 }
737 var arg3 ports.CheckpointRef
738 if args[3] != nil {
739 arg3 = args[3].(ports.CheckpointRef)
740 }
741 run(
742 arg0,
743 arg1,
744 arg2,
745 arg3,
746 )
747 })
748 return _c
749}
750
751func (_c *MockSnapshotRepository_LoadCheckpoint_Call) Return(snapshotGeneration ports.SnapshotGeneration, err error) *MockSnapshotRepository_LoadCheckpoint_Call {
752 _c.Call.Return(snapshotGeneration, err)
753 return _c
754}
755
756func (_c *MockSnapshotRepository_LoadCheckpoint_Call) RunAndReturn(run func(context1 context.Context, incarnationID domain.IncarnationID, s string, checkpointRef ports.CheckpointRef) (ports.SnapshotGeneration, error)) *MockSnapshotRepository_LoadCheckpoint_Call {
757 _c.Call.Return(run)
758 return _c
759}
760
761// Publish provides a mock function for the type MockSnapshotRepository
762func (_mock *MockSnapshotRepository) Publish(context1 context.Context, snapshotPublication ports.SnapshotPublication) error {
763 ret := _mock.Called(context1, snapshotPublication)
764
765 if len(ret) == 0 {
766 panic("no return value specified for Publish")
767 }
768
769 var r0 error
770 if returnFunc, ok := ret.Get(0).(func(context.Context, ports.SnapshotPublication) error); ok {
771 r0 = returnFunc(context1, snapshotPublication)
772 } else {
773 r0 = ret.Error(0)
774 }
775 return r0
776}
777
778// MockSnapshotRepository_Publish_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Publish'
779type MockSnapshotRepository_Publish_Call struct {
780 *mock.Call
781}
782
783// Publish is a helper method to define mock.On call
784// - context1 context.Context
785// - snapshotPublication ports.SnapshotPublication
786func (_e *MockSnapshotRepository_Expecter) Publish(context1 any, snapshotPublication any) *MockSnapshotRepository_Publish_Call {
787 return &MockSnapshotRepository_Publish_Call{Call: _e.mock.On("Publish", context1, snapshotPublication)}
788}
789
790func (_c *MockSnapshotRepository_Publish_Call) Run(run func(context1 context.Context, snapshotPublication ports.SnapshotPublication)) *MockSnapshotRepository_Publish_Call {
791 _c.Call.Run(func(args mock.Arguments) {
792 var arg0 context.Context
793 if args[0] != nil {
794 arg0 = args[0].(context.Context)
795 }
796 var arg1 ports.SnapshotPublication
797 if args[1] != nil {
798 arg1 = args[1].(ports.SnapshotPublication)
799 }
800 run(
801 arg0,
802 arg1,
803 )
804 })
805 return _c
806}
807
808func (_c *MockSnapshotRepository_Publish_Call) Return(err error) *MockSnapshotRepository_Publish_Call {
809 _c.Call.Return(err)
810 return _c
811}
812
813func (_c *MockSnapshotRepository_Publish_Call) RunAndReturn(run func(context1 context.Context, snapshotPublication ports.SnapshotPublication) error) *MockSnapshotRepository_Publish_Call {
814 _c.Call.Return(run)
815 return _c
816}
817
818// ReconcileCheckpoint provides a mock function for the type MockSnapshotRepository
819func (_mock *MockSnapshotRepository) ReconcileCheckpoint(context1 context.Context, incarnationID domain.IncarnationID, checkpointRef ports.CheckpointRef) error {
820 ret := _mock.Called(context1, incarnationID, checkpointRef)
821
822 if len(ret) == 0 {
823 panic("no return value specified for ReconcileCheckpoint")
824 }
825
826 var r0 error
827 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.IncarnationID, ports.CheckpointRef) error); ok {
828 r0 = returnFunc(context1, incarnationID, checkpointRef)
829 } else {
830 r0 = ret.Error(0)
831 }
832 return r0
833}
834
835// MockSnapshotRepository_ReconcileCheckpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReconcileCheckpoint'
836type MockSnapshotRepository_ReconcileCheckpoint_Call struct {
837 *mock.Call
838}
839
840// ReconcileCheckpoint is a helper method to define mock.On call
841// - context1 context.Context
842// - incarnationID domain.IncarnationID
843// - checkpointRef ports.CheckpointRef
844func (_e *MockSnapshotRepository_Expecter) ReconcileCheckpoint(context1 any, incarnationID any, checkpointRef any) *MockSnapshotRepository_ReconcileCheckpoint_Call {
845 return &MockSnapshotRepository_ReconcileCheckpoint_Call{Call: _e.mock.On("ReconcileCheckpoint", context1, incarnationID, checkpointRef)}
846}
847
848func (_c *MockSnapshotRepository_ReconcileCheckpoint_Call) Run(run func(context1 context.Context, incarnationID domain.IncarnationID, checkpointRef ports.CheckpointRef)) *MockSnapshotRepository_ReconcileCheckpoint_Call {
849 _c.Call.Run(func(args mock.Arguments) {
850 var arg0 context.Context
851 if args[0] != nil {
852 arg0 = args[0].(context.Context)
853 }
854 var arg1 domain.IncarnationID
855 if args[1] != nil {
856 arg1 = args[1].(domain.IncarnationID)
857 }
858 var arg2 ports.CheckpointRef
859 if args[2] != nil {
860 arg2 = args[2].(ports.CheckpointRef)
861 }
862 run(
863 arg0,
864 arg1,
865 arg2,
866 )
867 })
868 return _c
869}
870
871func (_c *MockSnapshotRepository_ReconcileCheckpoint_Call) Return(err error) *MockSnapshotRepository_ReconcileCheckpoint_Call {
872 _c.Call.Return(err)
873 return _c
874}
875
876func (_c *MockSnapshotRepository_ReconcileCheckpoint_Call) RunAndReturn(run func(context1 context.Context, incarnationID domain.IncarnationID, checkpointRef ports.CheckpointRef) error) *MockSnapshotRepository_ReconcileCheckpoint_Call {
877 _c.Call.Return(run)
878 return _c
879}
880
881// SnapshotIncarnations provides a mock function for the type MockSnapshotRepository
882func (_mock *MockSnapshotRepository) SnapshotIncarnations(context1 context.Context) ([]domain.IncarnationID, error) {
883 ret := _mock.Called(context1)
884
885 if len(ret) == 0 {
886 panic("no return value specified for SnapshotIncarnations")
887 }
888
889 var r0 []domain.IncarnationID
890 var r1 error
891 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]domain.IncarnationID, error)); ok {
892 return returnFunc(context1)
893 }
894 if returnFunc, ok := ret.Get(0).(func(context.Context) []domain.IncarnationID); ok {
895 r0 = returnFunc(context1)
896 } else {
897 if ret.Get(0) != nil {
898 r0 = ret.Get(0).([]domain.IncarnationID)
899 }
900 }
901 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
902 r1 = returnFunc(context1)
903 } else {
904 r1 = ret.Error(1)
905 }
906 return r0, r1
907}
908
909// MockSnapshotRepository_SnapshotIncarnations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SnapshotIncarnations'
910type MockSnapshotRepository_SnapshotIncarnations_Call struct {
911 *mock.Call
912}
913
914// SnapshotIncarnations is a helper method to define mock.On call
915// - context1 context.Context
916func (_e *MockSnapshotRepository_Expecter) SnapshotIncarnations(context1 any) *MockSnapshotRepository_SnapshotIncarnations_Call {
917 return &MockSnapshotRepository_SnapshotIncarnations_Call{Call: _e.mock.On("SnapshotIncarnations", context1)}
918}
919
920func (_c *MockSnapshotRepository_SnapshotIncarnations_Call) Run(run func(context1 context.Context)) *MockSnapshotRepository_SnapshotIncarnations_Call {
921 _c.Call.Run(func(args mock.Arguments) {
922 var arg0 context.Context
923 if args[0] != nil {
924 arg0 = args[0].(context.Context)
925 }
926 run(
927 arg0,
928 )
929 })
930 return _c
931}
932
933func (_c *MockSnapshotRepository_SnapshotIncarnations_Call) Return(incarnationIDs []domain.IncarnationID, err error) *MockSnapshotRepository_SnapshotIncarnations_Call {
934 _c.Call.Return(incarnationIDs, err)
935 return _c
936}
937
938func (_c *MockSnapshotRepository_SnapshotIncarnations_Call) RunAndReturn(run func(context1 context.Context) ([]domain.IncarnationID, error)) *MockSnapshotRepository_SnapshotIncarnations_Call {
939 _c.Call.Return(run)
940 return _c
941}