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