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, digest string) (string, error) {
442 ret := _mock.Called(ctx, 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, error)); ok {
451 return returnFunc(ctx, digest)
452 }
453 if returnFunc, ok := ret.Get(0).(func(context.Context, string) string); ok {
454 r0 = returnFunc(ctx, digest)
455 } else {
456 r0 = ret.Get(0).(string)
457 }
458 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
459 r1 = returnFunc(ctx, 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// - digest string
474func (_e *MockRegistryService_Expecter) GetBlobPath(ctx any, digest any) *MockRegistryService_GetBlobPath_Call {
475 return &MockRegistryService_GetBlobPath_Call{Call: _e.mock.On("GetBlobPath", ctx, digest)}
476}
477
478func (_c *MockRegistryService_GetBlobPath_Call) Run(run func(ctx context.Context, digest string)) *MockRegistryService_GetBlobPath_Call {
479 _c.Call.Run(func(args mock.Arguments) {
480 var arg0 context.Context
481 if args[0] != nil {
482 arg0 = args[0].(context.Context)
483 }
484 var arg1 string
485 if args[1] != nil {
486 arg1 = args[1].(string)
487 }
488 run(
489 arg0,
490 arg1,
491 )
492 })
493 return _c
494}
495
496func (_c *MockRegistryService_GetBlobPath_Call) Return(s string, err error) *MockRegistryService_GetBlobPath_Call {
497 _c.Call.Return(s, err)
498 return _c
499}
500
501func (_c *MockRegistryService_GetBlobPath_Call) RunAndReturn(run func(ctx context.Context, digest string) (string, error)) *MockRegistryService_GetBlobPath_Call {
502 _c.Call.Return(run)
503 return _c
504}
505
506// GetManifest provides a mock function for the type MockRegistryService
507func (_mock *MockRegistryService) GetManifest(ctx context.Context, name string, reference string) (*domain.Manifest, error) {
508 ret := _mock.Called(ctx, name, reference)
509
510 if len(ret) == 0 {
511 panic("no return value specified for GetManifest")
512 }
513
514 var r0 *domain.Manifest
515 var r1 error
516 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*domain.Manifest, error)); ok {
517 return returnFunc(ctx, name, reference)
518 }
519 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *domain.Manifest); ok {
520 r0 = returnFunc(ctx, name, reference)
521 } else {
522 if ret.Get(0) != nil {
523 r0 = ret.Get(0).(*domain.Manifest)
524 }
525 }
526 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
527 r1 = returnFunc(ctx, name, reference)
528 } else {
529 r1 = ret.Error(1)
530 }
531 return r0, r1
532}
533
534// MockRegistryService_GetManifest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetManifest'
535type MockRegistryService_GetManifest_Call struct {
536 *mock.Call
537}
538
539// GetManifest is a helper method to define mock.On call
540// - ctx context.Context
541// - name string
542// - reference string
543func (_e *MockRegistryService_Expecter) GetManifest(ctx any, name any, reference any) *MockRegistryService_GetManifest_Call {
544 return &MockRegistryService_GetManifest_Call{Call: _e.mock.On("GetManifest", ctx, name, reference)}
545}
546
547func (_c *MockRegistryService_GetManifest_Call) Run(run func(ctx context.Context, name string, reference string)) *MockRegistryService_GetManifest_Call {
548 _c.Call.Run(func(args mock.Arguments) {
549 var arg0 context.Context
550 if args[0] != nil {
551 arg0 = args[0].(context.Context)
552 }
553 var arg1 string
554 if args[1] != nil {
555 arg1 = args[1].(string)
556 }
557 var arg2 string
558 if args[2] != nil {
559 arg2 = args[2].(string)
560 }
561 run(
562 arg0,
563 arg1,
564 arg2,
565 )
566 })
567 return _c
568}
569
570func (_c *MockRegistryService_GetManifest_Call) Return(manifest *domain.Manifest, err error) *MockRegistryService_GetManifest_Call {
571 _c.Call.Return(manifest, err)
572 return _c
573}
574
575func (_c *MockRegistryService_GetManifest_Call) RunAndReturn(run func(ctx context.Context, name string, reference string) (*domain.Manifest, error)) *MockRegistryService_GetManifest_Call {
576 _c.Call.Return(run)
577 return _c
578}
579
580// ListRepositories provides a mock function for the type MockRegistryService
581func (_mock *MockRegistryService) ListRepositories(ctx context.Context) ([]string, error) {
582 ret := _mock.Called(ctx)
583
584 if len(ret) == 0 {
585 panic("no return value specified for ListRepositories")
586 }
587
588 var r0 []string
589 var r1 error
590 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]string, error)); ok {
591 return returnFunc(ctx)
592 }
593 if returnFunc, ok := ret.Get(0).(func(context.Context) []string); ok {
594 r0 = returnFunc(ctx)
595 } else {
596 if ret.Get(0) != nil {
597 r0 = ret.Get(0).([]string)
598 }
599 }
600 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
601 r1 = returnFunc(ctx)
602 } else {
603 r1 = ret.Error(1)
604 }
605 return r0, r1
606}
607
608// MockRegistryService_ListRepositories_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRepositories'
609type MockRegistryService_ListRepositories_Call struct {
610 *mock.Call
611}
612
613// ListRepositories is a helper method to define mock.On call
614// - ctx context.Context
615func (_e *MockRegistryService_Expecter) ListRepositories(ctx any) *MockRegistryService_ListRepositories_Call {
616 return &MockRegistryService_ListRepositories_Call{Call: _e.mock.On("ListRepositories", ctx)}
617}
618
619func (_c *MockRegistryService_ListRepositories_Call) Run(run func(ctx context.Context)) *MockRegistryService_ListRepositories_Call {
620 _c.Call.Run(func(args mock.Arguments) {
621 var arg0 context.Context
622 if args[0] != nil {
623 arg0 = args[0].(context.Context)
624 }
625 run(
626 arg0,
627 )
628 })
629 return _c
630}
631
632func (_c *MockRegistryService_ListRepositories_Call) Return(strings []string, err error) *MockRegistryService_ListRepositories_Call {
633 _c.Call.Return(strings, err)
634 return _c
635}
636
637func (_c *MockRegistryService_ListRepositories_Call) RunAndReturn(run func(ctx context.Context) ([]string, error)) *MockRegistryService_ListRepositories_Call {
638 _c.Call.Return(run)
639 return _c
640}
641
642// ListTags provides a mock function for the type MockRegistryService
643func (_mock *MockRegistryService) ListTags(ctx context.Context, name string) ([]string, error) {
644 ret := _mock.Called(ctx, name)
645
646 if len(ret) == 0 {
647 panic("no return value specified for ListTags")
648 }
649
650 var r0 []string
651 var r1 error
652 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]string, error)); ok {
653 return returnFunc(ctx, name)
654 }
655 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []string); ok {
656 r0 = returnFunc(ctx, name)
657 } else {
658 if ret.Get(0) != nil {
659 r0 = ret.Get(0).([]string)
660 }
661 }
662 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
663 r1 = returnFunc(ctx, name)
664 } else {
665 r1 = ret.Error(1)
666 }
667 return r0, r1
668}
669
670// MockRegistryService_ListTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTags'
671type MockRegistryService_ListTags_Call struct {
672 *mock.Call
673}
674
675// ListTags is a helper method to define mock.On call
676// - ctx context.Context
677// - name string
678func (_e *MockRegistryService_Expecter) ListTags(ctx any, name any) *MockRegistryService_ListTags_Call {
679 return &MockRegistryService_ListTags_Call{Call: _e.mock.On("ListTags", ctx, name)}
680}
681
682func (_c *MockRegistryService_ListTags_Call) Run(run func(ctx context.Context, name string)) *MockRegistryService_ListTags_Call {
683 _c.Call.Run(func(args mock.Arguments) {
684 var arg0 context.Context
685 if args[0] != nil {
686 arg0 = args[0].(context.Context)
687 }
688 var arg1 string
689 if args[1] != nil {
690 arg1 = args[1].(string)
691 }
692 run(
693 arg0,
694 arg1,
695 )
696 })
697 return _c
698}
699
700func (_c *MockRegistryService_ListTags_Call) Return(strings []string, err error) *MockRegistryService_ListTags_Call {
701 _c.Call.Return(strings, err)
702 return _c
703}
704
705func (_c *MockRegistryService_ListTags_Call) RunAndReturn(run func(ctx context.Context, name string) ([]string, error)) *MockRegistryService_ListTags_Call {
706 _c.Call.Return(run)
707 return _c
708}
709
710// PutBlob provides a mock function for the type MockRegistryService
711func (_mock *MockRegistryService) PutBlob(ctx context.Context, digest string, data io.Reader, size int64) error {
712 ret := _mock.Called(ctx, digest, data, size)
713
714 if len(ret) == 0 {
715 panic("no return value specified for PutBlob")
716 }
717
718 var r0 error
719 if returnFunc, ok := ret.Get(0).(func(context.Context, string, io.Reader, int64) error); ok {
720 r0 = returnFunc(ctx, digest, data, size)
721 } else {
722 r0 = ret.Error(0)
723 }
724 return r0
725}
726
727// MockRegistryService_PutBlob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBlob'
728type MockRegistryService_PutBlob_Call struct {
729 *mock.Call
730}
731
732// PutBlob is a helper method to define mock.On call
733// - ctx context.Context
734// - digest string
735// - data io.Reader
736// - size int64
737func (_e *MockRegistryService_Expecter) PutBlob(ctx any, digest any, data any, size any) *MockRegistryService_PutBlob_Call {
738 return &MockRegistryService_PutBlob_Call{Call: _e.mock.On("PutBlob", ctx, digest, data, size)}
739}
740
741func (_c *MockRegistryService_PutBlob_Call) Run(run func(ctx context.Context, digest string, data io.Reader, size int64)) *MockRegistryService_PutBlob_Call {
742 _c.Call.Run(func(args mock.Arguments) {
743 var arg0 context.Context
744 if args[0] != nil {
745 arg0 = args[0].(context.Context)
746 }
747 var arg1 string
748 if args[1] != nil {
749 arg1 = args[1].(string)
750 }
751 var arg2 io.Reader
752 if args[2] != nil {
753 arg2 = args[2].(io.Reader)
754 }
755 var arg3 int64
756 if args[3] != nil {
757 arg3 = args[3].(int64)
758 }
759 run(
760 arg0,
761 arg1,
762 arg2,
763 arg3,
764 )
765 })
766 return _c
767}
768
769func (_c *MockRegistryService_PutBlob_Call) Return(err error) *MockRegistryService_PutBlob_Call {
770 _c.Call.Return(err)
771 return _c
772}
773
774func (_c *MockRegistryService_PutBlob_Call) RunAndReturn(run func(ctx context.Context, digest string, data io.Reader, size int64) error) *MockRegistryService_PutBlob_Call {
775 _c.Call.Return(run)
776 return _c
777}
778
779// PutManifest provides a mock function for the type MockRegistryService
780func (_mock *MockRegistryService) PutManifest(ctx context.Context, manifest *domain.Manifest) (string, error) {
781 ret := _mock.Called(ctx, manifest)
782
783 if len(ret) == 0 {
784 panic("no return value specified for PutManifest")
785 }
786
787 var r0 string
788 var r1 error
789 if returnFunc, ok := ret.Get(0).(func(context.Context, *domain.Manifest) (string, error)); ok {
790 return returnFunc(ctx, manifest)
791 }
792 if returnFunc, ok := ret.Get(0).(func(context.Context, *domain.Manifest) string); ok {
793 r0 = returnFunc(ctx, manifest)
794 } else {
795 r0 = ret.Get(0).(string)
796 }
797 if returnFunc, ok := ret.Get(1).(func(context.Context, *domain.Manifest) error); ok {
798 r1 = returnFunc(ctx, manifest)
799 } else {
800 r1 = ret.Error(1)
801 }
802 return r0, r1
803}
804
805// MockRegistryService_PutManifest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutManifest'
806type MockRegistryService_PutManifest_Call struct {
807 *mock.Call
808}
809
810// PutManifest is a helper method to define mock.On call
811// - ctx context.Context
812// - manifest *domain.Manifest
813func (_e *MockRegistryService_Expecter) PutManifest(ctx any, manifest any) *MockRegistryService_PutManifest_Call {
814 return &MockRegistryService_PutManifest_Call{Call: _e.mock.On("PutManifest", ctx, manifest)}
815}
816
817func (_c *MockRegistryService_PutManifest_Call) Run(run func(ctx context.Context, manifest *domain.Manifest)) *MockRegistryService_PutManifest_Call {
818 _c.Call.Run(func(args mock.Arguments) {
819 var arg0 context.Context
820 if args[0] != nil {
821 arg0 = args[0].(context.Context)
822 }
823 var arg1 *domain.Manifest
824 if args[1] != nil {
825 arg1 = args[1].(*domain.Manifest)
826 }
827 run(
828 arg0,
829 arg1,
830 )
831 })
832 return _c
833}
834
835func (_c *MockRegistryService_PutManifest_Call) Return(digest string, err error) *MockRegistryService_PutManifest_Call {
836 _c.Call.Return(digest, err)
837 return _c
838}
839
840func (_c *MockRegistryService_PutManifest_Call) RunAndReturn(run func(ctx context.Context, manifest *domain.Manifest) (string, error)) *MockRegistryService_PutManifest_Call {
841 _c.Call.Return(run)
842 return _c
843}
844
845// StartUpload provides a mock function for the type MockRegistryService
846func (_mock *MockRegistryService) StartUpload(ctx context.Context, name string) (string, error) {
847 ret := _mock.Called(ctx, name)
848
849 if len(ret) == 0 {
850 panic("no return value specified for StartUpload")
851 }
852
853 var r0 string
854 var r1 error
855 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (string, error)); ok {
856 return returnFunc(ctx, name)
857 }
858 if returnFunc, ok := ret.Get(0).(func(context.Context, string) string); ok {
859 r0 = returnFunc(ctx, name)
860 } else {
861 r0 = ret.Get(0).(string)
862 }
863 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
864 r1 = returnFunc(ctx, name)
865 } else {
866 r1 = ret.Error(1)
867 }
868 return r0, r1
869}
870
871// MockRegistryService_StartUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartUpload'
872type MockRegistryService_StartUpload_Call struct {
873 *mock.Call
874}
875
876// StartUpload is a helper method to define mock.On call
877// - ctx context.Context
878// - name string
879func (_e *MockRegistryService_Expecter) StartUpload(ctx any, name any) *MockRegistryService_StartUpload_Call {
880 return &MockRegistryService_StartUpload_Call{Call: _e.mock.On("StartUpload", ctx, name)}
881}
882
883func (_c *MockRegistryService_StartUpload_Call) Run(run func(ctx context.Context, name string)) *MockRegistryService_StartUpload_Call {
884 _c.Call.Run(func(args mock.Arguments) {
885 var arg0 context.Context
886 if args[0] != nil {
887 arg0 = args[0].(context.Context)
888 }
889 var arg1 string
890 if args[1] != nil {
891 arg1 = args[1].(string)
892 }
893 run(
894 arg0,
895 arg1,
896 )
897 })
898 return _c
899}
900
901func (_c *MockRegistryService_StartUpload_Call) Return(s string, err error) *MockRegistryService_StartUpload_Call {
902 _c.Call.Return(s, err)
903 return _c
904}
905
906func (_c *MockRegistryService_StartUpload_Call) RunAndReturn(run func(ctx context.Context, name string) (string, error)) *MockRegistryService_StartUpload_Call {
907 _c.Call.Return(run)
908 return _c
909}