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