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, uuid string) error {
191 ret := _mock.Called(ctx, 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) error); ok {
199 r0 = returnFunc(ctx, 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// - uuid string
214func (_e *MockRegistryService_Expecter) CancelUpload(ctx any, uuid any) *MockRegistryService_CancelUpload_Call {
215 return &MockRegistryService_CancelUpload_Call{Call: _e.mock.On("CancelUpload", ctx, uuid)}
216}
217
218func (_c *MockRegistryService_CancelUpload_Call) Run(run func(ctx context.Context, uuid string)) *MockRegistryService_CancelUpload_Call {
219 _c.Call.Run(func(args mock.Arguments) {
220 var arg0 context.Context
221 if args[0] != nil {
222 arg0 = args[0].(context.Context)
223 }
224 var arg1 string
225 if args[1] != nil {
226 arg1 = args[1].(string)
227 }
228 run(
229 arg0,
230 arg1,
231 )
232 })
233 return _c
234}
235
236func (_c *MockRegistryService_CancelUpload_Call) Return(err error) *MockRegistryService_CancelUpload_Call {
237 _c.Call.Return(err)
238 return _c
239}
240
241func (_c *MockRegistryService_CancelUpload_Call) RunAndReturn(run func(ctx context.Context, uuid string) error) *MockRegistryService_CancelUpload_Call {
242 _c.Call.Return(run)
243 return _c
244}
245
246// DeleteManifest provides a mock function for the type MockRegistryService
247func (_mock *MockRegistryService) DeleteManifest(ctx context.Context, name string, reference string) error {
248 ret := _mock.Called(ctx, name, reference)
249
250 if len(ret) == 0 {
251 panic("no return value specified for DeleteManifest")
252 }
253
254 var r0 error
255 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
256 r0 = returnFunc(ctx, name, reference)
257 } else {
258 r0 = ret.Error(0)
259 }
260 return r0
261}
262
263// MockRegistryService_DeleteManifest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteManifest'
264type MockRegistryService_DeleteManifest_Call struct {
265 *mock.Call
266}
267
268// DeleteManifest is a helper method to define mock.On call
269// - ctx context.Context
270// - name string
271// - reference string
272func (_e *MockRegistryService_Expecter) DeleteManifest(ctx any, name any, reference any) *MockRegistryService_DeleteManifest_Call {
273 return &MockRegistryService_DeleteManifest_Call{Call: _e.mock.On("DeleteManifest", ctx, name, reference)}
274}
275
276func (_c *MockRegistryService_DeleteManifest_Call) Run(run func(ctx context.Context, name string, reference string)) *MockRegistryService_DeleteManifest_Call {
277 _c.Call.Run(func(args mock.Arguments) {
278 var arg0 context.Context
279 if args[0] != nil {
280 arg0 = args[0].(context.Context)
281 }
282 var arg1 string
283 if args[1] != nil {
284 arg1 = args[1].(string)
285 }
286 var arg2 string
287 if args[2] != nil {
288 arg2 = args[2].(string)
289 }
290 run(
291 arg0,
292 arg1,
293 arg2,
294 )
295 })
296 return _c
297}
298
299func (_c *MockRegistryService_DeleteManifest_Call) Return(err error) *MockRegistryService_DeleteManifest_Call {
300 _c.Call.Return(err)
301 return _c
302}
303
304func (_c *MockRegistryService_DeleteManifest_Call) RunAndReturn(run func(ctx context.Context, name string, reference string) error) *MockRegistryService_DeleteManifest_Call {
305 _c.Call.Return(run)
306 return _c
307}
308
309// FinishUpload provides a mock function for the type MockRegistryService
310func (_mock *MockRegistryService) FinishUpload(ctx context.Context, uuid string, digest string) error {
311 ret := _mock.Called(ctx, uuid, digest)
312
313 if len(ret) == 0 {
314 panic("no return value specified for FinishUpload")
315 }
316
317 var r0 error
318 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
319 r0 = returnFunc(ctx, uuid, digest)
320 } else {
321 r0 = ret.Error(0)
322 }
323 return r0
324}
325
326// MockRegistryService_FinishUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FinishUpload'
327type MockRegistryService_FinishUpload_Call struct {
328 *mock.Call
329}
330
331// FinishUpload is a helper method to define mock.On call
332// - ctx context.Context
333// - uuid string
334// - digest string
335func (_e *MockRegistryService_Expecter) FinishUpload(ctx any, uuid any, digest any) *MockRegistryService_FinishUpload_Call {
336 return &MockRegistryService_FinishUpload_Call{Call: _e.mock.On("FinishUpload", ctx, uuid, digest)}
337}
338
339func (_c *MockRegistryService_FinishUpload_Call) Run(run func(ctx context.Context, uuid string, digest string)) *MockRegistryService_FinishUpload_Call {
340 _c.Call.Run(func(args mock.Arguments) {
341 var arg0 context.Context
342 if args[0] != nil {
343 arg0 = args[0].(context.Context)
344 }
345 var arg1 string
346 if args[1] != nil {
347 arg1 = args[1].(string)
348 }
349 var arg2 string
350 if args[2] != nil {
351 arg2 = args[2].(string)
352 }
353 run(
354 arg0,
355 arg1,
356 arg2,
357 )
358 })
359 return _c
360}
361
362func (_c *MockRegistryService_FinishUpload_Call) Return(err error) *MockRegistryService_FinishUpload_Call {
363 _c.Call.Return(err)
364 return _c
365}
366
367func (_c *MockRegistryService_FinishUpload_Call) RunAndReturn(run func(ctx context.Context, uuid string, digest string) error) *MockRegistryService_FinishUpload_Call {
368 _c.Call.Return(run)
369 return _c
370}
371
372// GetBlob provides a mock function for the type MockRegistryService
373func (_mock *MockRegistryService) GetBlob(ctx context.Context, digest string) (io.ReadCloser, error) {
374 ret := _mock.Called(ctx, digest)
375
376 if len(ret) == 0 {
377 panic("no return value specified for GetBlob")
378 }
379
380 var r0 io.ReadCloser
381 var r1 error
382 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (io.ReadCloser, error)); ok {
383 return returnFunc(ctx, digest)
384 }
385 if returnFunc, ok := ret.Get(0).(func(context.Context, string) io.ReadCloser); ok {
386 r0 = returnFunc(ctx, digest)
387 } else {
388 if ret.Get(0) != nil {
389 r0 = ret.Get(0).(io.ReadCloser)
390 }
391 }
392 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
393 r1 = returnFunc(ctx, digest)
394 } else {
395 r1 = ret.Error(1)
396 }
397 return r0, r1
398}
399
400// MockRegistryService_GetBlob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlob'
401type MockRegistryService_GetBlob_Call struct {
402 *mock.Call
403}
404
405// GetBlob is a helper method to define mock.On call
406// - ctx context.Context
407// - digest string
408func (_e *MockRegistryService_Expecter) GetBlob(ctx any, digest any) *MockRegistryService_GetBlob_Call {
409 return &MockRegistryService_GetBlob_Call{Call: _e.mock.On("GetBlob", ctx, digest)}
410}
411
412func (_c *MockRegistryService_GetBlob_Call) Run(run func(ctx context.Context, digest string)) *MockRegistryService_GetBlob_Call {
413 _c.Call.Run(func(args mock.Arguments) {
414 var arg0 context.Context
415 if args[0] != nil {
416 arg0 = args[0].(context.Context)
417 }
418 var arg1 string
419 if args[1] != nil {
420 arg1 = args[1].(string)
421 }
422 run(
423 arg0,
424 arg1,
425 )
426 })
427 return _c
428}
429
430func (_c *MockRegistryService_GetBlob_Call) Return(readCloser io.ReadCloser, err error) *MockRegistryService_GetBlob_Call {
431 _c.Call.Return(readCloser, err)
432 return _c
433}
434
435func (_c *MockRegistryService_GetBlob_Call) RunAndReturn(run func(ctx context.Context, digest string) (io.ReadCloser, error)) *MockRegistryService_GetBlob_Call {
436 _c.Call.Return(run)
437 return _c
438}
439
440// GetBlobPath provides a mock function for the type MockRegistryService
441func (_mock *MockRegistryService) GetBlobPath(ctx context.Context, name string, digest string) (string, error) {
442 ret := _mock.Called(ctx, name, digest)
443
444 if len(ret) == 0 {
445 panic("no return value specified for GetBlobPath")
446 }
447
448 var r0 string
449 var r1 error
450 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (string, error)); ok {
451 return returnFunc(ctx, name, digest)
452 }
453 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) string); ok {
454 r0 = returnFunc(ctx, name, digest)
455 } else {
456 r0 = ret.Get(0).(string)
457 }
458 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
459 r1 = returnFunc(ctx, name, digest)
460 } else {
461 r1 = ret.Error(1)
462 }
463 return r0, r1
464}
465
466// MockRegistryService_GetBlobPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlobPath'
467type MockRegistryService_GetBlobPath_Call struct {
468 *mock.Call
469}
470
471// GetBlobPath is a helper method to define mock.On call
472// - ctx context.Context
473// - name string
474// - digest string
475func (_e *MockRegistryService_Expecter) GetBlobPath(ctx any, name any, digest any) *MockRegistryService_GetBlobPath_Call {
476 return &MockRegistryService_GetBlobPath_Call{Call: _e.mock.On("GetBlobPath", ctx, name, digest)}
477}
478
479func (_c *MockRegistryService_GetBlobPath_Call) Run(run func(ctx context.Context, name string, digest string)) *MockRegistryService_GetBlobPath_Call {
480 _c.Call.Run(func(args mock.Arguments) {
481 var arg0 context.Context
482 if args[0] != nil {
483 arg0 = args[0].(context.Context)
484 }
485 var arg1 string
486 if args[1] != nil {
487 arg1 = args[1].(string)
488 }
489 var arg2 string
490 if args[2] != nil {
491 arg2 = args[2].(string)
492 }
493 run(
494 arg0,
495 arg1,
496 arg2,
497 )
498 })
499 return _c
500}
501
502func (_c *MockRegistryService_GetBlobPath_Call) Return(s string, err error) *MockRegistryService_GetBlobPath_Call {
503 _c.Call.Return(s, err)
504 return _c
505}
506
507func (_c *MockRegistryService_GetBlobPath_Call) RunAndReturn(run func(ctx context.Context, name string, digest string) (string, error)) *MockRegistryService_GetBlobPath_Call {
508 _c.Call.Return(run)
509 return _c
510}
511
512// GetManifest provides a mock function for the type MockRegistryService
513func (_mock *MockRegistryService) GetManifest(ctx context.Context, name string, reference string) (*domain.Manifest, error) {
514 ret := _mock.Called(ctx, name, reference)
515
516 if len(ret) == 0 {
517 panic("no return value specified for GetManifest")
518 }
519
520 var r0 *domain.Manifest
521 var r1 error
522 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*domain.Manifest, error)); ok {
523 return returnFunc(ctx, name, reference)
524 }
525 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *domain.Manifest); ok {
526 r0 = returnFunc(ctx, name, reference)
527 } else {
528 if ret.Get(0) != nil {
529 r0 = ret.Get(0).(*domain.Manifest)
530 }
531 }
532 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
533 r1 = returnFunc(ctx, name, reference)
534 } else {
535 r1 = ret.Error(1)
536 }
537 return r0, r1
538}
539
540// MockRegistryService_GetManifest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetManifest'
541type MockRegistryService_GetManifest_Call struct {
542 *mock.Call
543}
544
545// GetManifest is a helper method to define mock.On call
546// - ctx context.Context
547// - name string
548// - reference string
549func (_e *MockRegistryService_Expecter) GetManifest(ctx any, name any, reference any) *MockRegistryService_GetManifest_Call {
550 return &MockRegistryService_GetManifest_Call{Call: _e.mock.On("GetManifest", ctx, name, reference)}
551}
552
553func (_c *MockRegistryService_GetManifest_Call) Run(run func(ctx context.Context, name string, reference string)) *MockRegistryService_GetManifest_Call {
554 _c.Call.Run(func(args mock.Arguments) {
555 var arg0 context.Context
556 if args[0] != nil {
557 arg0 = args[0].(context.Context)
558 }
559 var arg1 string
560 if args[1] != nil {
561 arg1 = args[1].(string)
562 }
563 var arg2 string
564 if args[2] != nil {
565 arg2 = args[2].(string)
566 }
567 run(
568 arg0,
569 arg1,
570 arg2,
571 )
572 })
573 return _c
574}
575
576func (_c *MockRegistryService_GetManifest_Call) Return(manifest *domain.Manifest, err error) *MockRegistryService_GetManifest_Call {
577 _c.Call.Return(manifest, err)
578 return _c
579}
580
581func (_c *MockRegistryService_GetManifest_Call) RunAndReturn(run func(ctx context.Context, name string, reference string) (*domain.Manifest, error)) *MockRegistryService_GetManifest_Call {
582 _c.Call.Return(run)
583 return _c
584}
585
586// ListRepositories provides a mock function for the type MockRegistryService
587func (_mock *MockRegistryService) ListRepositories(ctx context.Context) ([]string, error) {
588 ret := _mock.Called(ctx)
589
590 if len(ret) == 0 {
591 panic("no return value specified for ListRepositories")
592 }
593
594 var r0 []string
595 var r1 error
596 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]string, error)); ok {
597 return returnFunc(ctx)
598 }
599 if returnFunc, ok := ret.Get(0).(func(context.Context) []string); ok {
600 r0 = returnFunc(ctx)
601 } else {
602 if ret.Get(0) != nil {
603 r0 = ret.Get(0).([]string)
604 }
605 }
606 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
607 r1 = returnFunc(ctx)
608 } else {
609 r1 = ret.Error(1)
610 }
611 return r0, r1
612}
613
614// MockRegistryService_ListRepositories_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRepositories'
615type MockRegistryService_ListRepositories_Call struct {
616 *mock.Call
617}
618
619// ListRepositories is a helper method to define mock.On call
620// - ctx context.Context
621func (_e *MockRegistryService_Expecter) ListRepositories(ctx any) *MockRegistryService_ListRepositories_Call {
622 return &MockRegistryService_ListRepositories_Call{Call: _e.mock.On("ListRepositories", ctx)}
623}
624
625func (_c *MockRegistryService_ListRepositories_Call) Run(run func(ctx context.Context)) *MockRegistryService_ListRepositories_Call {
626 _c.Call.Run(func(args mock.Arguments) {
627 var arg0 context.Context
628 if args[0] != nil {
629 arg0 = args[0].(context.Context)
630 }
631 run(
632 arg0,
633 )
634 })
635 return _c
636}
637
638func (_c *MockRegistryService_ListRepositories_Call) Return(strings []string, err error) *MockRegistryService_ListRepositories_Call {
639 _c.Call.Return(strings, err)
640 return _c
641}
642
643func (_c *MockRegistryService_ListRepositories_Call) RunAndReturn(run func(ctx context.Context) ([]string, error)) *MockRegistryService_ListRepositories_Call {
644 _c.Call.Return(run)
645 return _c
646}
647
648// ListTags provides a mock function for the type MockRegistryService
649func (_mock *MockRegistryService) ListTags(ctx context.Context, name string) ([]string, error) {
650 ret := _mock.Called(ctx, name)
651
652 if len(ret) == 0 {
653 panic("no return value specified for ListTags")
654 }
655
656 var r0 []string
657 var r1 error
658 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]string, error)); ok {
659 return returnFunc(ctx, name)
660 }
661 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []string); ok {
662 r0 = returnFunc(ctx, name)
663 } else {
664 if ret.Get(0) != nil {
665 r0 = ret.Get(0).([]string)
666 }
667 }
668 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
669 r1 = returnFunc(ctx, name)
670 } else {
671 r1 = ret.Error(1)
672 }
673 return r0, r1
674}
675
676// MockRegistryService_ListTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTags'
677type MockRegistryService_ListTags_Call struct {
678 *mock.Call
679}
680
681// ListTags is a helper method to define mock.On call
682// - ctx context.Context
683// - name string
684func (_e *MockRegistryService_Expecter) ListTags(ctx any, name any) *MockRegistryService_ListTags_Call {
685 return &MockRegistryService_ListTags_Call{Call: _e.mock.On("ListTags", ctx, name)}
686}
687
688func (_c *MockRegistryService_ListTags_Call) Run(run func(ctx context.Context, name string)) *MockRegistryService_ListTags_Call {
689 _c.Call.Run(func(args mock.Arguments) {
690 var arg0 context.Context
691 if args[0] != nil {
692 arg0 = args[0].(context.Context)
693 }
694 var arg1 string
695 if args[1] != nil {
696 arg1 = args[1].(string)
697 }
698 run(
699 arg0,
700 arg1,
701 )
702 })
703 return _c
704}
705
706func (_c *MockRegistryService_ListTags_Call) Return(strings []string, err error) *MockRegistryService_ListTags_Call {
707 _c.Call.Return(strings, err)
708 return _c
709}
710
711func (_c *MockRegistryService_ListTags_Call) RunAndReturn(run func(ctx context.Context, name string) ([]string, error)) *MockRegistryService_ListTags_Call {
712 _c.Call.Return(run)
713 return _c
714}
715
716// PutBlob provides a mock function for the type MockRegistryService
717func (_mock *MockRegistryService) PutBlob(ctx context.Context, digest string, data io.Reader, size int64) error {
718 ret := _mock.Called(ctx, digest, data, size)
719
720 if len(ret) == 0 {
721 panic("no return value specified for PutBlob")
722 }
723
724 var r0 error
725 if returnFunc, ok := ret.Get(0).(func(context.Context, string, io.Reader, int64) error); ok {
726 r0 = returnFunc(ctx, digest, data, size)
727 } else {
728 r0 = ret.Error(0)
729 }
730 return r0
731}
732
733// MockRegistryService_PutBlob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBlob'
734type MockRegistryService_PutBlob_Call struct {
735 *mock.Call
736}
737
738// PutBlob is a helper method to define mock.On call
739// - ctx context.Context
740// - digest string
741// - data io.Reader
742// - size int64
743func (_e *MockRegistryService_Expecter) PutBlob(ctx any, digest any, data any, size any) *MockRegistryService_PutBlob_Call {
744 return &MockRegistryService_PutBlob_Call{Call: _e.mock.On("PutBlob", ctx, digest, data, size)}
745}
746
747func (_c *MockRegistryService_PutBlob_Call) Run(run func(ctx context.Context, digest string, data io.Reader, size int64)) *MockRegistryService_PutBlob_Call {
748 _c.Call.Run(func(args mock.Arguments) {
749 var arg0 context.Context
750 if args[0] != nil {
751 arg0 = args[0].(context.Context)
752 }
753 var arg1 string
754 if args[1] != nil {
755 arg1 = args[1].(string)
756 }
757 var arg2 io.Reader
758 if args[2] != nil {
759 arg2 = args[2].(io.Reader)
760 }
761 var arg3 int64
762 if args[3] != nil {
763 arg3 = args[3].(int64)
764 }
765 run(
766 arg0,
767 arg1,
768 arg2,
769 arg3,
770 )
771 })
772 return _c
773}
774
775func (_c *MockRegistryService_PutBlob_Call) Return(err error) *MockRegistryService_PutBlob_Call {
776 _c.Call.Return(err)
777 return _c
778}
779
780func (_c *MockRegistryService_PutBlob_Call) RunAndReturn(run func(ctx context.Context, digest string, data io.Reader, size int64) error) *MockRegistryService_PutBlob_Call {
781 _c.Call.Return(run)
782 return _c
783}
784
785// PutManifest provides a mock function for the type MockRegistryService
786func (_mock *MockRegistryService) PutManifest(ctx context.Context, manifest *domain.Manifest) (string, error) {
787 ret := _mock.Called(ctx, manifest)
788
789 if len(ret) == 0 {
790 panic("no return value specified for PutManifest")
791 }
792
793 var r0 string
794 var r1 error
795 if returnFunc, ok := ret.Get(0).(func(context.Context, *domain.Manifest) (string, error)); ok {
796 return returnFunc(ctx, manifest)
797 }
798 if returnFunc, ok := ret.Get(0).(func(context.Context, *domain.Manifest) string); ok {
799 r0 = returnFunc(ctx, manifest)
800 } else {
801 r0 = ret.Get(0).(string)
802 }
803 if returnFunc, ok := ret.Get(1).(func(context.Context, *domain.Manifest) error); ok {
804 r1 = returnFunc(ctx, manifest)
805 } else {
806 r1 = ret.Error(1)
807 }
808 return r0, r1
809}
810
811// MockRegistryService_PutManifest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutManifest'
812type MockRegistryService_PutManifest_Call struct {
813 *mock.Call
814}
815
816// PutManifest is a helper method to define mock.On call
817// - ctx context.Context
818// - manifest *domain.Manifest
819func (_e *MockRegistryService_Expecter) PutManifest(ctx any, manifest any) *MockRegistryService_PutManifest_Call {
820 return &MockRegistryService_PutManifest_Call{Call: _e.mock.On("PutManifest", ctx, manifest)}
821}
822
823func (_c *MockRegistryService_PutManifest_Call) Run(run func(ctx context.Context, manifest *domain.Manifest)) *MockRegistryService_PutManifest_Call {
824 _c.Call.Run(func(args mock.Arguments) {
825 var arg0 context.Context
826 if args[0] != nil {
827 arg0 = args[0].(context.Context)
828 }
829 var arg1 *domain.Manifest
830 if args[1] != nil {
831 arg1 = args[1].(*domain.Manifest)
832 }
833 run(
834 arg0,
835 arg1,
836 )
837 })
838 return _c
839}
840
841func (_c *MockRegistryService_PutManifest_Call) Return(digest string, err error) *MockRegistryService_PutManifest_Call {
842 _c.Call.Return(digest, err)
843 return _c
844}
845
846func (_c *MockRegistryService_PutManifest_Call) RunAndReturn(run func(ctx context.Context, manifest *domain.Manifest) (string, error)) *MockRegistryService_PutManifest_Call {
847 _c.Call.Return(run)
848 return _c
849}
850
851// StartUpload provides a mock function for the type MockRegistryService
852func (_mock *MockRegistryService) StartUpload(ctx context.Context, name string) (string, error) {
853 ret := _mock.Called(ctx, name)
854
855 if len(ret) == 0 {
856 panic("no return value specified for StartUpload")
857 }
858
859 var r0 string
860 var r1 error
861 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (string, error)); ok {
862 return returnFunc(ctx, name)
863 }
864 if returnFunc, ok := ret.Get(0).(func(context.Context, string) string); ok {
865 r0 = returnFunc(ctx, name)
866 } else {
867 r0 = ret.Get(0).(string)
868 }
869 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
870 r1 = returnFunc(ctx, name)
871 } else {
872 r1 = ret.Error(1)
873 }
874 return r0, r1
875}
876
877// MockRegistryService_StartUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartUpload'
878type MockRegistryService_StartUpload_Call struct {
879 *mock.Call
880}
881
882// StartUpload is a helper method to define mock.On call
883// - ctx context.Context
884// - name string
885func (_e *MockRegistryService_Expecter) StartUpload(ctx any, name any) *MockRegistryService_StartUpload_Call {
886 return &MockRegistryService_StartUpload_Call{Call: _e.mock.On("StartUpload", ctx, name)}
887}
888
889func (_c *MockRegistryService_StartUpload_Call) Run(run func(ctx context.Context, name string)) *MockRegistryService_StartUpload_Call {
890 _c.Call.Run(func(args mock.Arguments) {
891 var arg0 context.Context
892 if args[0] != nil {
893 arg0 = args[0].(context.Context)
894 }
895 var arg1 string
896 if args[1] != nil {
897 arg1 = args[1].(string)
898 }
899 run(
900 arg0,
901 arg1,
902 )
903 })
904 return _c
905}
906
907func (_c *MockRegistryService_StartUpload_Call) Return(s string, err error) *MockRegistryService_StartUpload_Call {
908 _c.Call.Return(s, err)
909 return _c
910}
911
912func (_c *MockRegistryService_StartUpload_Call) RunAndReturn(run func(ctx context.Context, name string) (string, error)) *MockRegistryService_StartUpload_Call {
913 _c.Call.Return(run)
914 return _c
915}