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 "bnema.dev/ermite/internal/domain"
11 "bnema.dev/ermite/internal/ports"
12 mock "github.com/stretchr/testify/mock"
13)
14
15// NewReleaseStore creates a new instance of ReleaseStore. 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 NewReleaseStore(t interface {
18 mock.TestingT
19 Cleanup(func())
20}) *ReleaseStore {
21 if helper, ok := t.(interface{ Helper() }); ok {
22 helper.Helper()
23 }
24
25 mock := &ReleaseStore{}
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// ReleaseStore is an autogenerated mock type for the ReleaseStore type
39type ReleaseStore struct {
40 mock.Mock
41}
42
43type ReleaseStore_Expecter struct {
44 mock *mock.Mock
45}
46
47func (_m *ReleaseStore) EXPECT() *ReleaseStore_Expecter {
48 return &ReleaseStore_Expecter{mock: &_m.Mock}
49}
50
51// AllAssets provides a mock function for the type ReleaseStore
52func (_mock *ReleaseStore) AllAssets(ctx context.Context) ([]domain.ReleaseAsset, error) {
53 ret := _mock.Called(ctx)
54
55 if len(ret) == 0 {
56 panic("no return value specified for AllAssets")
57 }
58
59 var r0 []domain.ReleaseAsset
60 var r1 error
61 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]domain.ReleaseAsset, error)); ok {
62 return returnFunc(ctx)
63 }
64 if returnFunc, ok := ret.Get(0).(func(context.Context) []domain.ReleaseAsset); ok {
65 r0 = returnFunc(ctx)
66 } else {
67 if ret.Get(0) != nil {
68 r0 = ret.Get(0).([]domain.ReleaseAsset)
69 }
70 }
71 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
72 r1 = returnFunc(ctx)
73 } else {
74 r1 = ret.Error(1)
75 }
76 return r0, r1
77}
78
79// ReleaseStore_AllAssets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllAssets'
80type ReleaseStore_AllAssets_Call struct {
81 *mock.Call
82}
83
84// AllAssets is a helper method to define mock.On call
85// - ctx context.Context
86func (_e *ReleaseStore_Expecter) AllAssets(ctx any) *ReleaseStore_AllAssets_Call {
87 return &ReleaseStore_AllAssets_Call{Call: _e.mock.On("AllAssets", ctx)}
88}
89
90func (_c *ReleaseStore_AllAssets_Call) Run(run func(ctx context.Context)) *ReleaseStore_AllAssets_Call {
91 _c.Call.Run(func(args mock.Arguments) {
92 var arg0 context.Context
93 if args[0] != nil {
94 arg0 = args[0].(context.Context)
95 }
96 run(
97 arg0,
98 )
99 })
100 return _c
101}
102
103func (_c *ReleaseStore_AllAssets_Call) Return(releaseAssets []domain.ReleaseAsset, err error) *ReleaseStore_AllAssets_Call {
104 _c.Call.Return(releaseAssets, err)
105 return _c
106}
107
108func (_c *ReleaseStore_AllAssets_Call) RunAndReturn(run func(ctx context.Context) ([]domain.ReleaseAsset, error)) *ReleaseStore_AllAssets_Call {
109 _c.Call.Return(run)
110 return _c
111}
112
113// ApplyReleases provides a mock function for the type ReleaseStore
114func (_mock *ReleaseStore) ApplyReleases(ctx context.Context, w ports.ReleaseWrite) error {
115 ret := _mock.Called(ctx, w)
116
117 if len(ret) == 0 {
118 panic("no return value specified for ApplyReleases")
119 }
120
121 var r0 error
122 if returnFunc, ok := ret.Get(0).(func(context.Context, ports.ReleaseWrite) error); ok {
123 r0 = returnFunc(ctx, w)
124 } else {
125 r0 = ret.Error(0)
126 }
127 return r0
128}
129
130// ReleaseStore_ApplyReleases_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ApplyReleases'
131type ReleaseStore_ApplyReleases_Call struct {
132 *mock.Call
133}
134
135// ApplyReleases is a helper method to define mock.On call
136// - ctx context.Context
137// - w ports.ReleaseWrite
138func (_e *ReleaseStore_Expecter) ApplyReleases(ctx any, w any) *ReleaseStore_ApplyReleases_Call {
139 return &ReleaseStore_ApplyReleases_Call{Call: _e.mock.On("ApplyReleases", ctx, w)}
140}
141
142func (_c *ReleaseStore_ApplyReleases_Call) Run(run func(ctx context.Context, w ports.ReleaseWrite)) *ReleaseStore_ApplyReleases_Call {
143 _c.Call.Run(func(args mock.Arguments) {
144 var arg0 context.Context
145 if args[0] != nil {
146 arg0 = args[0].(context.Context)
147 }
148 var arg1 ports.ReleaseWrite
149 if args[1] != nil {
150 arg1 = args[1].(ports.ReleaseWrite)
151 }
152 run(
153 arg0,
154 arg1,
155 )
156 })
157 return _c
158}
159
160func (_c *ReleaseStore_ApplyReleases_Call) Return(err error) *ReleaseStore_ApplyReleases_Call {
161 _c.Call.Return(err)
162 return _c
163}
164
165func (_c *ReleaseStore_ApplyReleases_Call) RunAndReturn(run func(ctx context.Context, w ports.ReleaseWrite) error) *ReleaseStore_ApplyReleases_Call {
166 _c.Call.Return(run)
167 return _c
168}
169
170// GetAsset provides a mock function for the type ReleaseStore
171func (_mock *ReleaseStore) GetAsset(ctx context.Context, id int64) (domain.ReleaseAsset, error) {
172 ret := _mock.Called(ctx, id)
173
174 if len(ret) == 0 {
175 panic("no return value specified for GetAsset")
176 }
177
178 var r0 domain.ReleaseAsset
179 var r1 error
180 if returnFunc, ok := ret.Get(0).(func(context.Context, int64) (domain.ReleaseAsset, error)); ok {
181 return returnFunc(ctx, id)
182 }
183 if returnFunc, ok := ret.Get(0).(func(context.Context, int64) domain.ReleaseAsset); ok {
184 r0 = returnFunc(ctx, id)
185 } else {
186 r0 = ret.Get(0).(domain.ReleaseAsset)
187 }
188 if returnFunc, ok := ret.Get(1).(func(context.Context, int64) error); ok {
189 r1 = returnFunc(ctx, id)
190 } else {
191 r1 = ret.Error(1)
192 }
193 return r0, r1
194}
195
196// ReleaseStore_GetAsset_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAsset'
197type ReleaseStore_GetAsset_Call struct {
198 *mock.Call
199}
200
201// GetAsset is a helper method to define mock.On call
202// - ctx context.Context
203// - id int64
204func (_e *ReleaseStore_Expecter) GetAsset(ctx any, id any) *ReleaseStore_GetAsset_Call {
205 return &ReleaseStore_GetAsset_Call{Call: _e.mock.On("GetAsset", ctx, id)}
206}
207
208func (_c *ReleaseStore_GetAsset_Call) Run(run func(ctx context.Context, id int64)) *ReleaseStore_GetAsset_Call {
209 _c.Call.Run(func(args mock.Arguments) {
210 var arg0 context.Context
211 if args[0] != nil {
212 arg0 = args[0].(context.Context)
213 }
214 var arg1 int64
215 if args[1] != nil {
216 arg1 = args[1].(int64)
217 }
218 run(
219 arg0,
220 arg1,
221 )
222 })
223 return _c
224}
225
226func (_c *ReleaseStore_GetAsset_Call) Return(releaseAsset domain.ReleaseAsset, err error) *ReleaseStore_GetAsset_Call {
227 _c.Call.Return(releaseAsset, err)
228 return _c
229}
230
231func (_c *ReleaseStore_GetAsset_Call) RunAndReturn(run func(ctx context.Context, id int64) (domain.ReleaseAsset, error)) *ReleaseStore_GetAsset_Call {
232 _c.Call.Return(run)
233 return _c
234}
235
236// GetAssetByName provides a mock function for the type ReleaseStore
237func (_mock *ReleaseStore) GetAssetByName(ctx context.Context, repo domain.RepoName, releaseID int64, name string) (domain.ReleaseAsset, error) {
238 ret := _mock.Called(ctx, repo, releaseID, name)
239
240 if len(ret) == 0 {
241 panic("no return value specified for GetAssetByName")
242 }
243
244 var r0 domain.ReleaseAsset
245 var r1 error
246 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, int64, string) (domain.ReleaseAsset, error)); ok {
247 return returnFunc(ctx, repo, releaseID, name)
248 }
249 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, int64, string) domain.ReleaseAsset); ok {
250 r0 = returnFunc(ctx, repo, releaseID, name)
251 } else {
252 r0 = ret.Get(0).(domain.ReleaseAsset)
253 }
254 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RepoName, int64, string) error); ok {
255 r1 = returnFunc(ctx, repo, releaseID, name)
256 } else {
257 r1 = ret.Error(1)
258 }
259 return r0, r1
260}
261
262// ReleaseStore_GetAssetByName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAssetByName'
263type ReleaseStore_GetAssetByName_Call struct {
264 *mock.Call
265}
266
267// GetAssetByName is a helper method to define mock.On call
268// - ctx context.Context
269// - repo domain.RepoName
270// - releaseID int64
271// - name string
272func (_e *ReleaseStore_Expecter) GetAssetByName(ctx any, repo any, releaseID any, name any) *ReleaseStore_GetAssetByName_Call {
273 return &ReleaseStore_GetAssetByName_Call{Call: _e.mock.On("GetAssetByName", ctx, repo, releaseID, name)}
274}
275
276func (_c *ReleaseStore_GetAssetByName_Call) Run(run func(ctx context.Context, repo domain.RepoName, releaseID int64, name string)) *ReleaseStore_GetAssetByName_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 domain.RepoName
283 if args[1] != nil {
284 arg1 = args[1].(domain.RepoName)
285 }
286 var arg2 int64
287 if args[2] != nil {
288 arg2 = args[2].(int64)
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 *ReleaseStore_GetAssetByName_Call) Return(releaseAsset domain.ReleaseAsset, err error) *ReleaseStore_GetAssetByName_Call {
305 _c.Call.Return(releaseAsset, err)
306 return _c
307}
308
309func (_c *ReleaseStore_GetAssetByName_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName, releaseID int64, name string) (domain.ReleaseAsset, error)) *ReleaseStore_GetAssetByName_Call {
310 _c.Call.Return(run)
311 return _c
312}
313
314// GetRelease provides a mock function for the type ReleaseStore
315func (_mock *ReleaseStore) GetRelease(ctx context.Context, repo domain.RepoName, id int64) (domain.Release, error) {
316 ret := _mock.Called(ctx, repo, id)
317
318 if len(ret) == 0 {
319 panic("no return value specified for GetRelease")
320 }
321
322 var r0 domain.Release
323 var r1 error
324 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, int64) (domain.Release, error)); ok {
325 return returnFunc(ctx, repo, id)
326 }
327 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, int64) domain.Release); ok {
328 r0 = returnFunc(ctx, repo, id)
329 } else {
330 r0 = ret.Get(0).(domain.Release)
331 }
332 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RepoName, int64) error); ok {
333 r1 = returnFunc(ctx, repo, id)
334 } else {
335 r1 = ret.Error(1)
336 }
337 return r0, r1
338}
339
340// ReleaseStore_GetRelease_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRelease'
341type ReleaseStore_GetRelease_Call struct {
342 *mock.Call
343}
344
345// GetRelease is a helper method to define mock.On call
346// - ctx context.Context
347// - repo domain.RepoName
348// - id int64
349func (_e *ReleaseStore_Expecter) GetRelease(ctx any, repo any, id any) *ReleaseStore_GetRelease_Call {
350 return &ReleaseStore_GetRelease_Call{Call: _e.mock.On("GetRelease", ctx, repo, id)}
351}
352
353func (_c *ReleaseStore_GetRelease_Call) Run(run func(ctx context.Context, repo domain.RepoName, id int64)) *ReleaseStore_GetRelease_Call {
354 _c.Call.Run(func(args mock.Arguments) {
355 var arg0 context.Context
356 if args[0] != nil {
357 arg0 = args[0].(context.Context)
358 }
359 var arg1 domain.RepoName
360 if args[1] != nil {
361 arg1 = args[1].(domain.RepoName)
362 }
363 var arg2 int64
364 if args[2] != nil {
365 arg2 = args[2].(int64)
366 }
367 run(
368 arg0,
369 arg1,
370 arg2,
371 )
372 })
373 return _c
374}
375
376func (_c *ReleaseStore_GetRelease_Call) Return(release domain.Release, err error) *ReleaseStore_GetRelease_Call {
377 _c.Call.Return(release, err)
378 return _c
379}
380
381func (_c *ReleaseStore_GetRelease_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName, id int64) (domain.Release, error)) *ReleaseStore_GetRelease_Call {
382 _c.Call.Return(run)
383 return _c
384}
385
386// GetReleaseByTag provides a mock function for the type ReleaseStore
387func (_mock *ReleaseStore) GetReleaseByTag(ctx context.Context, repo domain.RepoName, tag string) (domain.Release, error) {
388 ret := _mock.Called(ctx, repo, tag)
389
390 if len(ret) == 0 {
391 panic("no return value specified for GetReleaseByTag")
392 }
393
394 var r0 domain.Release
395 var r1 error
396 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, string) (domain.Release, error)); ok {
397 return returnFunc(ctx, repo, tag)
398 }
399 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, string) domain.Release); ok {
400 r0 = returnFunc(ctx, repo, tag)
401 } else {
402 r0 = ret.Get(0).(domain.Release)
403 }
404 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RepoName, string) error); ok {
405 r1 = returnFunc(ctx, repo, tag)
406 } else {
407 r1 = ret.Error(1)
408 }
409 return r0, r1
410}
411
412// ReleaseStore_GetReleaseByTag_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReleaseByTag'
413type ReleaseStore_GetReleaseByTag_Call struct {
414 *mock.Call
415}
416
417// GetReleaseByTag is a helper method to define mock.On call
418// - ctx context.Context
419// - repo domain.RepoName
420// - tag string
421func (_e *ReleaseStore_Expecter) GetReleaseByTag(ctx any, repo any, tag any) *ReleaseStore_GetReleaseByTag_Call {
422 return &ReleaseStore_GetReleaseByTag_Call{Call: _e.mock.On("GetReleaseByTag", ctx, repo, tag)}
423}
424
425func (_c *ReleaseStore_GetReleaseByTag_Call) Run(run func(ctx context.Context, repo domain.RepoName, tag string)) *ReleaseStore_GetReleaseByTag_Call {
426 _c.Call.Run(func(args mock.Arguments) {
427 var arg0 context.Context
428 if args[0] != nil {
429 arg0 = args[0].(context.Context)
430 }
431 var arg1 domain.RepoName
432 if args[1] != nil {
433 arg1 = args[1].(domain.RepoName)
434 }
435 var arg2 string
436 if args[2] != nil {
437 arg2 = args[2].(string)
438 }
439 run(
440 arg0,
441 arg1,
442 arg2,
443 )
444 })
445 return _c
446}
447
448func (_c *ReleaseStore_GetReleaseByTag_Call) Return(release domain.Release, err error) *ReleaseStore_GetReleaseByTag_Call {
449 _c.Call.Return(release, err)
450 return _c
451}
452
453func (_c *ReleaseStore_GetReleaseByTag_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName, tag string) (domain.Release, error)) *ReleaseStore_GetReleaseByTag_Call {
454 _c.Call.Return(run)
455 return _c
456}
457
458// ListAssets provides a mock function for the type ReleaseStore
459func (_mock *ReleaseStore) ListAssets(ctx context.Context, repo domain.RepoName, releaseID int64) ([]domain.ReleaseAsset, error) {
460 ret := _mock.Called(ctx, repo, releaseID)
461
462 if len(ret) == 0 {
463 panic("no return value specified for ListAssets")
464 }
465
466 var r0 []domain.ReleaseAsset
467 var r1 error
468 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, int64) ([]domain.ReleaseAsset, error)); ok {
469 return returnFunc(ctx, repo, releaseID)
470 }
471 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, int64) []domain.ReleaseAsset); ok {
472 r0 = returnFunc(ctx, repo, releaseID)
473 } else {
474 if ret.Get(0) != nil {
475 r0 = ret.Get(0).([]domain.ReleaseAsset)
476 }
477 }
478 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RepoName, int64) error); ok {
479 r1 = returnFunc(ctx, repo, releaseID)
480 } else {
481 r1 = ret.Error(1)
482 }
483 return r0, r1
484}
485
486// ReleaseStore_ListAssets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAssets'
487type ReleaseStore_ListAssets_Call struct {
488 *mock.Call
489}
490
491// ListAssets is a helper method to define mock.On call
492// - ctx context.Context
493// - repo domain.RepoName
494// - releaseID int64
495func (_e *ReleaseStore_Expecter) ListAssets(ctx any, repo any, releaseID any) *ReleaseStore_ListAssets_Call {
496 return &ReleaseStore_ListAssets_Call{Call: _e.mock.On("ListAssets", ctx, repo, releaseID)}
497}
498
499func (_c *ReleaseStore_ListAssets_Call) Run(run func(ctx context.Context, repo domain.RepoName, releaseID int64)) *ReleaseStore_ListAssets_Call {
500 _c.Call.Run(func(args mock.Arguments) {
501 var arg0 context.Context
502 if args[0] != nil {
503 arg0 = args[0].(context.Context)
504 }
505 var arg1 domain.RepoName
506 if args[1] != nil {
507 arg1 = args[1].(domain.RepoName)
508 }
509 var arg2 int64
510 if args[2] != nil {
511 arg2 = args[2].(int64)
512 }
513 run(
514 arg0,
515 arg1,
516 arg2,
517 )
518 })
519 return _c
520}
521
522func (_c *ReleaseStore_ListAssets_Call) Return(releaseAssets []domain.ReleaseAsset, err error) *ReleaseStore_ListAssets_Call {
523 _c.Call.Return(releaseAssets, err)
524 return _c
525}
526
527func (_c *ReleaseStore_ListAssets_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName, releaseID int64) ([]domain.ReleaseAsset, error)) *ReleaseStore_ListAssets_Call {
528 _c.Call.Return(run)
529 return _c
530}
531
532// ListReleases provides a mock function for the type ReleaseStore
533func (_mock *ReleaseStore) ListReleases(ctx context.Context, repo domain.RepoName) ([]domain.Release, error) {
534 ret := _mock.Called(ctx, repo)
535
536 if len(ret) == 0 {
537 panic("no return value specified for ListReleases")
538 }
539
540 var r0 []domain.Release
541 var r1 error
542 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName) ([]domain.Release, error)); ok {
543 return returnFunc(ctx, repo)
544 }
545 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName) []domain.Release); ok {
546 r0 = returnFunc(ctx, repo)
547 } else {
548 if ret.Get(0) != nil {
549 r0 = ret.Get(0).([]domain.Release)
550 }
551 }
552 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RepoName) error); ok {
553 r1 = returnFunc(ctx, repo)
554 } else {
555 r1 = ret.Error(1)
556 }
557 return r0, r1
558}
559
560// ReleaseStore_ListReleases_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListReleases'
561type ReleaseStore_ListReleases_Call struct {
562 *mock.Call
563}
564
565// ListReleases is a helper method to define mock.On call
566// - ctx context.Context
567// - repo domain.RepoName
568func (_e *ReleaseStore_Expecter) ListReleases(ctx any, repo any) *ReleaseStore_ListReleases_Call {
569 return &ReleaseStore_ListReleases_Call{Call: _e.mock.On("ListReleases", ctx, repo)}
570}
571
572func (_c *ReleaseStore_ListReleases_Call) Run(run func(ctx context.Context, repo domain.RepoName)) *ReleaseStore_ListReleases_Call {
573 _c.Call.Run(func(args mock.Arguments) {
574 var arg0 context.Context
575 if args[0] != nil {
576 arg0 = args[0].(context.Context)
577 }
578 var arg1 domain.RepoName
579 if args[1] != nil {
580 arg1 = args[1].(domain.RepoName)
581 }
582 run(
583 arg0,
584 arg1,
585 )
586 })
587 return _c
588}
589
590func (_c *ReleaseStore_ListReleases_Call) Return(releases []domain.Release, err error) *ReleaseStore_ListReleases_Call {
591 _c.Call.Return(releases, err)
592 return _c
593}
594
595func (_c *ReleaseStore_ListReleases_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName) ([]domain.Release, error)) *ReleaseStore_ListReleases_Call {
596 _c.Call.Return(run)
597 return _c
598}
599
600// NextReleaseID provides a mock function for the type ReleaseStore
601func (_mock *ReleaseStore) NextReleaseID(ctx context.Context) (int64, error) {
602 ret := _mock.Called(ctx)
603
604 if len(ret) == 0 {
605 panic("no return value specified for NextReleaseID")
606 }
607
608 var r0 int64
609 var r1 error
610 if returnFunc, ok := ret.Get(0).(func(context.Context) (int64, error)); ok {
611 return returnFunc(ctx)
612 }
613 if returnFunc, ok := ret.Get(0).(func(context.Context) int64); ok {
614 r0 = returnFunc(ctx)
615 } else {
616 r0 = ret.Get(0).(int64)
617 }
618 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
619 r1 = returnFunc(ctx)
620 } else {
621 r1 = ret.Error(1)
622 }
623 return r0, r1
624}
625
626// ReleaseStore_NextReleaseID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NextReleaseID'
627type ReleaseStore_NextReleaseID_Call struct {
628 *mock.Call
629}
630
631// NextReleaseID is a helper method to define mock.On call
632// - ctx context.Context
633func (_e *ReleaseStore_Expecter) NextReleaseID(ctx any) *ReleaseStore_NextReleaseID_Call {
634 return &ReleaseStore_NextReleaseID_Call{Call: _e.mock.On("NextReleaseID", ctx)}
635}
636
637func (_c *ReleaseStore_NextReleaseID_Call) Run(run func(ctx context.Context)) *ReleaseStore_NextReleaseID_Call {
638 _c.Call.Run(func(args mock.Arguments) {
639 var arg0 context.Context
640 if args[0] != nil {
641 arg0 = args[0].(context.Context)
642 }
643 run(
644 arg0,
645 )
646 })
647 return _c
648}
649
650func (_c *ReleaseStore_NextReleaseID_Call) Return(n int64, err error) *ReleaseStore_NextReleaseID_Call {
651 _c.Call.Return(n, err)
652 return _c
653}
654
655func (_c *ReleaseStore_NextReleaseID_Call) RunAndReturn(run func(ctx context.Context) (int64, error)) *ReleaseStore_NextReleaseID_Call {
656 _c.Call.Return(run)
657 return _c
658}
659
660// ReleaseRepo provides a mock function for the type ReleaseStore
661func (_mock *ReleaseStore) ReleaseRepo(ctx context.Context, id int64) (domain.RepoName, error) {
662 ret := _mock.Called(ctx, id)
663
664 if len(ret) == 0 {
665 panic("no return value specified for ReleaseRepo")
666 }
667
668 var r0 domain.RepoName
669 var r1 error
670 if returnFunc, ok := ret.Get(0).(func(context.Context, int64) (domain.RepoName, error)); ok {
671 return returnFunc(ctx, id)
672 }
673 if returnFunc, ok := ret.Get(0).(func(context.Context, int64) domain.RepoName); ok {
674 r0 = returnFunc(ctx, id)
675 } else {
676 r0 = ret.Get(0).(domain.RepoName)
677 }
678 if returnFunc, ok := ret.Get(1).(func(context.Context, int64) error); ok {
679 r1 = returnFunc(ctx, id)
680 } else {
681 r1 = ret.Error(1)
682 }
683 return r0, r1
684}
685
686// ReleaseStore_ReleaseRepo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReleaseRepo'
687type ReleaseStore_ReleaseRepo_Call struct {
688 *mock.Call
689}
690
691// ReleaseRepo is a helper method to define mock.On call
692// - ctx context.Context
693// - id int64
694func (_e *ReleaseStore_Expecter) ReleaseRepo(ctx any, id any) *ReleaseStore_ReleaseRepo_Call {
695 return &ReleaseStore_ReleaseRepo_Call{Call: _e.mock.On("ReleaseRepo", ctx, id)}
696}
697
698func (_c *ReleaseStore_ReleaseRepo_Call) Run(run func(ctx context.Context, id int64)) *ReleaseStore_ReleaseRepo_Call {
699 _c.Call.Run(func(args mock.Arguments) {
700 var arg0 context.Context
701 if args[0] != nil {
702 arg0 = args[0].(context.Context)
703 }
704 var arg1 int64
705 if args[1] != nil {
706 arg1 = args[1].(int64)
707 }
708 run(
709 arg0,
710 arg1,
711 )
712 })
713 return _c
714}
715
716func (_c *ReleaseStore_ReleaseRepo_Call) Return(repoName domain.RepoName, err error) *ReleaseStore_ReleaseRepo_Call {
717 _c.Call.Return(repoName, err)
718 return _c
719}
720
721func (_c *ReleaseStore_ReleaseRepo_Call) RunAndReturn(run func(ctx context.Context, id int64) (domain.RepoName, error)) *ReleaseStore_ReleaseRepo_Call {
722 _c.Call.Return(run)
723 return _c
724}
725
726// ReleaseUsage provides a mock function for the type ReleaseStore
727func (_mock *ReleaseStore) ReleaseUsage(ctx context.Context, repo domain.RepoName) (int64, uint64, error) {
728 ret := _mock.Called(ctx, repo)
729
730 if len(ret) == 0 {
731 panic("no return value specified for ReleaseUsage")
732 }
733
734 var r0 int64
735 var r1 uint64
736 var r2 error
737 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName) (int64, uint64, error)); ok {
738 return returnFunc(ctx, repo)
739 }
740 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName) int64); ok {
741 r0 = returnFunc(ctx, repo)
742 } else {
743 r0 = ret.Get(0).(int64)
744 }
745 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RepoName) uint64); ok {
746 r1 = returnFunc(ctx, repo)
747 } else {
748 r1 = ret.Get(1).(uint64)
749 }
750 if returnFunc, ok := ret.Get(2).(func(context.Context, domain.RepoName) error); ok {
751 r2 = returnFunc(ctx, repo)
752 } else {
753 r2 = ret.Error(2)
754 }
755 return r0, r1, r2
756}
757
758// ReleaseStore_ReleaseUsage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReleaseUsage'
759type ReleaseStore_ReleaseUsage_Call struct {
760 *mock.Call
761}
762
763// ReleaseUsage is a helper method to define mock.On call
764// - ctx context.Context
765// - repo domain.RepoName
766func (_e *ReleaseStore_Expecter) ReleaseUsage(ctx any, repo any) *ReleaseStore_ReleaseUsage_Call {
767 return &ReleaseStore_ReleaseUsage_Call{Call: _e.mock.On("ReleaseUsage", ctx, repo)}
768}
769
770func (_c *ReleaseStore_ReleaseUsage_Call) Run(run func(ctx context.Context, repo domain.RepoName)) *ReleaseStore_ReleaseUsage_Call {
771 _c.Call.Run(func(args mock.Arguments) {
772 var arg0 context.Context
773 if args[0] != nil {
774 arg0 = args[0].(context.Context)
775 }
776 var arg1 domain.RepoName
777 if args[1] != nil {
778 arg1 = args[1].(domain.RepoName)
779 }
780 run(
781 arg0,
782 arg1,
783 )
784 })
785 return _c
786}
787
788func (_c *ReleaseStore_ReleaseUsage_Call) Return(used int64, version uint64, err error) *ReleaseStore_ReleaseUsage_Call {
789 _c.Call.Return(used, version, err)
790 return _c
791}
792
793func (_c *ReleaseStore_ReleaseUsage_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName) (int64, uint64, error)) *ReleaseStore_ReleaseUsage_Call {
794 _c.Call.Return(run)
795 return _c
796}