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