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