1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package mocks
6
7import (
8 "context"
9 "gordon/internal/domain"
10 "io"
11
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// BlobExists provides a mock function for the type MockRegistryService
43func (_mock *MockRegistryService) BlobExists(ctx context.Context, digest string) bool {
44 ret := _mock.Called(ctx, digest)
45
46 if len(ret) == 0 {
47 panic("no return value specified for BlobExists")
48 }
49
50 var r0 bool
51 if returnFunc, ok := ret.Get(0).(func(context.Context, string) bool); ok {
52 r0 = returnFunc(ctx, digest)
53 } else {
54 r0 = ret.Get(0).(bool)
55 }
56 return r0
57}
58
59// MockRegistryService_BlobExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlobExists'
60type MockRegistryService_BlobExists_Call struct {
61 *mock.Call
62}
63
64// BlobExists is a helper method to define mock.On call
65// - ctx context.Context
66// - digest string
67func (_e *MockRegistryService_Expecter) BlobExists(ctx interface{}, digest interface{}) *MockRegistryService_BlobExists_Call {
68 return &MockRegistryService_BlobExists_Call{Call: _e.mock.On("BlobExists", ctx, digest)}
69}
70
71func (_c *MockRegistryService_BlobExists_Call) Run(run func(ctx context.Context, digest string)) *MockRegistryService_BlobExists_Call {
72 _c.Call.Run(func(args mock.Arguments) {
73 var arg0 context.Context
74 if args[0] != nil {
75 arg0 = args[0].(context.Context)
76 }
77 var arg1 string
78 if args[1] != nil {
79 arg1 = args[1].(string)
80 }
81 run(
82 arg0,
83 arg1,
84 )
85 })
86 return _c
87}
88
89func (_c *MockRegistryService_BlobExists_Call) Return(b bool) *MockRegistryService_BlobExists_Call {
90 _c.Call.Return(b)
91 return _c
92}
93
94func (_c *MockRegistryService_BlobExists_Call) RunAndReturn(run func(ctx context.Context, digest string) bool) *MockRegistryService_BlobExists_Call {
95 _c.Call.Return(run)
96 return _c
97}
98
99// CancelUpload provides a mock function for the type MockRegistryService
100func (_mock *MockRegistryService) CancelUpload(ctx context.Context, uuid string) error {
101 ret := _mock.Called(ctx, uuid)
102
103 if len(ret) == 0 {
104 panic("no return value specified for CancelUpload")
105 }
106
107 var r0 error
108 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
109 r0 = returnFunc(ctx, uuid)
110 } else {
111 r0 = ret.Error(0)
112 }
113 return r0
114}
115
116// MockRegistryService_CancelUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelUpload'
117type MockRegistryService_CancelUpload_Call struct {
118 *mock.Call
119}
120
121// CancelUpload is a helper method to define mock.On call
122// - ctx context.Context
123// - uuid string
124func (_e *MockRegistryService_Expecter) CancelUpload(ctx interface{}, uuid interface{}) *MockRegistryService_CancelUpload_Call {
125 return &MockRegistryService_CancelUpload_Call{Call: _e.mock.On("CancelUpload", ctx, uuid)}
126}
127
128func (_c *MockRegistryService_CancelUpload_Call) Run(run func(ctx context.Context, uuid string)) *MockRegistryService_CancelUpload_Call {
129 _c.Call.Run(func(args mock.Arguments) {
130 var arg0 context.Context
131 if args[0] != nil {
132 arg0 = args[0].(context.Context)
133 }
134 var arg1 string
135 if args[1] != nil {
136 arg1 = args[1].(string)
137 }
138 run(
139 arg0,
140 arg1,
141 )
142 })
143 return _c
144}
145
146func (_c *MockRegistryService_CancelUpload_Call) Return(err error) *MockRegistryService_CancelUpload_Call {
147 _c.Call.Return(err)
148 return _c
149}
150
151func (_c *MockRegistryService_CancelUpload_Call) RunAndReturn(run func(ctx context.Context, uuid string) error) *MockRegistryService_CancelUpload_Call {
152 _c.Call.Return(run)
153 return _c
154}
155
156// DeleteManifest provides a mock function for the type MockRegistryService
157func (_mock *MockRegistryService) DeleteManifest(ctx context.Context, name string, reference string) error {
158 ret := _mock.Called(ctx, name, reference)
159
160 if len(ret) == 0 {
161 panic("no return value specified for DeleteManifest")
162 }
163
164 var r0 error
165 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
166 r0 = returnFunc(ctx, name, reference)
167 } else {
168 r0 = ret.Error(0)
169 }
170 return r0
171}
172
173// MockRegistryService_DeleteManifest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteManifest'
174type MockRegistryService_DeleteManifest_Call struct {
175 *mock.Call
176}
177
178// DeleteManifest is a helper method to define mock.On call
179// - ctx context.Context
180// - name string
181// - reference string
182func (_e *MockRegistryService_Expecter) DeleteManifest(ctx interface{}, name interface{}, reference interface{}) *MockRegistryService_DeleteManifest_Call {
183 return &MockRegistryService_DeleteManifest_Call{Call: _e.mock.On("DeleteManifest", ctx, name, reference)}
184}
185
186func (_c *MockRegistryService_DeleteManifest_Call) Run(run func(ctx context.Context, name string, reference string)) *MockRegistryService_DeleteManifest_Call {
187 _c.Call.Run(func(args mock.Arguments) {
188 var arg0 context.Context
189 if args[0] != nil {
190 arg0 = args[0].(context.Context)
191 }
192 var arg1 string
193 if args[1] != nil {
194 arg1 = args[1].(string)
195 }
196 var arg2 string
197 if args[2] != nil {
198 arg2 = args[2].(string)
199 }
200 run(
201 arg0,
202 arg1,
203 arg2,
204 )
205 })
206 return _c
207}
208
209func (_c *MockRegistryService_DeleteManifest_Call) Return(err error) *MockRegistryService_DeleteManifest_Call {
210 _c.Call.Return(err)
211 return _c
212}
213
214func (_c *MockRegistryService_DeleteManifest_Call) RunAndReturn(run func(ctx context.Context, name string, reference string) error) *MockRegistryService_DeleteManifest_Call {
215 _c.Call.Return(run)
216 return _c
217}
218
219// FinishUpload provides a mock function for the type MockRegistryService
220func (_mock *MockRegistryService) FinishUpload(ctx context.Context, uuid string, digest string) error {
221 ret := _mock.Called(ctx, uuid, digest)
222
223 if len(ret) == 0 {
224 panic("no return value specified for FinishUpload")
225 }
226
227 var r0 error
228 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
229 r0 = returnFunc(ctx, uuid, digest)
230 } else {
231 r0 = ret.Error(0)
232 }
233 return r0
234}
235
236// MockRegistryService_FinishUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FinishUpload'
237type MockRegistryService_FinishUpload_Call struct {
238 *mock.Call
239}
240
241// FinishUpload is a helper method to define mock.On call
242// - ctx context.Context
243// - uuid string
244// - digest string
245func (_e *MockRegistryService_Expecter) FinishUpload(ctx interface{}, uuid interface{}, digest interface{}) *MockRegistryService_FinishUpload_Call {
246 return &MockRegistryService_FinishUpload_Call{Call: _e.mock.On("FinishUpload", ctx, uuid, digest)}
247}
248
249func (_c *MockRegistryService_FinishUpload_Call) Run(run func(ctx context.Context, uuid string, digest string)) *MockRegistryService_FinishUpload_Call {
250 _c.Call.Run(func(args mock.Arguments) {
251 var arg0 context.Context
252 if args[0] != nil {
253 arg0 = args[0].(context.Context)
254 }
255 var arg1 string
256 if args[1] != nil {
257 arg1 = args[1].(string)
258 }
259 var arg2 string
260 if args[2] != nil {
261 arg2 = args[2].(string)
262 }
263 run(
264 arg0,
265 arg1,
266 arg2,
267 )
268 })
269 return _c
270}
271
272func (_c *MockRegistryService_FinishUpload_Call) Return(err error) *MockRegistryService_FinishUpload_Call {
273 _c.Call.Return(err)
274 return _c
275}
276
277func (_c *MockRegistryService_FinishUpload_Call) RunAndReturn(run func(ctx context.Context, uuid string, digest string) error) *MockRegistryService_FinishUpload_Call {
278 _c.Call.Return(run)
279 return _c
280}
281
282// GetBlob provides a mock function for the type MockRegistryService
283func (_mock *MockRegistryService) GetBlob(ctx context.Context, digest string) (io.ReadCloser, error) {
284 ret := _mock.Called(ctx, digest)
285
286 if len(ret) == 0 {
287 panic("no return value specified for GetBlob")
288 }
289
290 var r0 io.ReadCloser
291 var r1 error
292 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (io.ReadCloser, error)); ok {
293 return returnFunc(ctx, digest)
294 }
295 if returnFunc, ok := ret.Get(0).(func(context.Context, string) io.ReadCloser); ok {
296 r0 = returnFunc(ctx, digest)
297 } else {
298 if ret.Get(0) != nil {
299 r0 = ret.Get(0).(io.ReadCloser)
300 }
301 }
302 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
303 r1 = returnFunc(ctx, digest)
304 } else {
305 r1 = ret.Error(1)
306 }
307 return r0, r1
308}
309
310// MockRegistryService_GetBlob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlob'
311type MockRegistryService_GetBlob_Call struct {
312 *mock.Call
313}
314
315// GetBlob is a helper method to define mock.On call
316// - ctx context.Context
317// - digest string
318func (_e *MockRegistryService_Expecter) GetBlob(ctx interface{}, digest interface{}) *MockRegistryService_GetBlob_Call {
319 return &MockRegistryService_GetBlob_Call{Call: _e.mock.On("GetBlob", ctx, digest)}
320}
321
322func (_c *MockRegistryService_GetBlob_Call) Run(run func(ctx context.Context, digest string)) *MockRegistryService_GetBlob_Call {
323 _c.Call.Run(func(args mock.Arguments) {
324 var arg0 context.Context
325 if args[0] != nil {
326 arg0 = args[0].(context.Context)
327 }
328 var arg1 string
329 if args[1] != nil {
330 arg1 = args[1].(string)
331 }
332 run(
333 arg0,
334 arg1,
335 )
336 })
337 return _c
338}
339
340func (_c *MockRegistryService_GetBlob_Call) Return(readCloser io.ReadCloser, err error) *MockRegistryService_GetBlob_Call {
341 _c.Call.Return(readCloser, err)
342 return _c
343}
344
345func (_c *MockRegistryService_GetBlob_Call) RunAndReturn(run func(ctx context.Context, digest string) (io.ReadCloser, error)) *MockRegistryService_GetBlob_Call {
346 _c.Call.Return(run)
347 return _c
348}
349
350// GetManifest provides a mock function for the type MockRegistryService
351func (_mock *MockRegistryService) GetManifest(ctx context.Context, name string, reference string) (*domain.Manifest, error) {
352 ret := _mock.Called(ctx, name, reference)
353
354 if len(ret) == 0 {
355 panic("no return value specified for GetManifest")
356 }
357
358 var r0 *domain.Manifest
359 var r1 error
360 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*domain.Manifest, error)); ok {
361 return returnFunc(ctx, name, reference)
362 }
363 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *domain.Manifest); ok {
364 r0 = returnFunc(ctx, name, reference)
365 } else {
366 if ret.Get(0) != nil {
367 r0 = ret.Get(0).(*domain.Manifest)
368 }
369 }
370 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
371 r1 = returnFunc(ctx, name, reference)
372 } else {
373 r1 = ret.Error(1)
374 }
375 return r0, r1
376}
377
378// MockRegistryService_GetManifest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetManifest'
379type MockRegistryService_GetManifest_Call struct {
380 *mock.Call
381}
382
383// GetManifest is a helper method to define mock.On call
384// - ctx context.Context
385// - name string
386// - reference string
387func (_e *MockRegistryService_Expecter) GetManifest(ctx interface{}, name interface{}, reference interface{}) *MockRegistryService_GetManifest_Call {
388 return &MockRegistryService_GetManifest_Call{Call: _e.mock.On("GetManifest", ctx, name, reference)}
389}
390
391func (_c *MockRegistryService_GetManifest_Call) Run(run func(ctx context.Context, name string, reference string)) *MockRegistryService_GetManifest_Call {
392 _c.Call.Run(func(args mock.Arguments) {
393 var arg0 context.Context
394 if args[0] != nil {
395 arg0 = args[0].(context.Context)
396 }
397 var arg1 string
398 if args[1] != nil {
399 arg1 = args[1].(string)
400 }
401 var arg2 string
402 if args[2] != nil {
403 arg2 = args[2].(string)
404 }
405 run(
406 arg0,
407 arg1,
408 arg2,
409 )
410 })
411 return _c
412}
413
414func (_c *MockRegistryService_GetManifest_Call) Return(manifest *domain.Manifest, err error) *MockRegistryService_GetManifest_Call {
415 _c.Call.Return(manifest, err)
416 return _c
417}
418
419func (_c *MockRegistryService_GetManifest_Call) RunAndReturn(run func(ctx context.Context, name string, reference string) (*domain.Manifest, error)) *MockRegistryService_GetManifest_Call {
420 _c.Call.Return(run)
421 return _c
422}
423
424// ListRepositories provides a mock function for the type MockRegistryService
425func (_mock *MockRegistryService) ListRepositories(ctx context.Context) ([]string, error) {
426 ret := _mock.Called(ctx)
427
428 if len(ret) == 0 {
429 panic("no return value specified for ListRepositories")
430 }
431
432 var r0 []string
433 var r1 error
434 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]string, error)); ok {
435 return returnFunc(ctx)
436 }
437 if returnFunc, ok := ret.Get(0).(func(context.Context) []string); ok {
438 r0 = returnFunc(ctx)
439 } else {
440 if ret.Get(0) != nil {
441 r0 = ret.Get(0).([]string)
442 }
443 }
444 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
445 r1 = returnFunc(ctx)
446 } else {
447 r1 = ret.Error(1)
448 }
449 return r0, r1
450}
451
452// MockRegistryService_ListRepositories_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRepositories'
453type MockRegistryService_ListRepositories_Call struct {
454 *mock.Call
455}
456
457// ListRepositories is a helper method to define mock.On call
458// - ctx context.Context
459func (_e *MockRegistryService_Expecter) ListRepositories(ctx interface{}) *MockRegistryService_ListRepositories_Call {
460 return &MockRegistryService_ListRepositories_Call{Call: _e.mock.On("ListRepositories", ctx)}
461}
462
463func (_c *MockRegistryService_ListRepositories_Call) Run(run func(ctx context.Context)) *MockRegistryService_ListRepositories_Call {
464 _c.Call.Run(func(args mock.Arguments) {
465 var arg0 context.Context
466 if args[0] != nil {
467 arg0 = args[0].(context.Context)
468 }
469 run(
470 arg0,
471 )
472 })
473 return _c
474}
475
476func (_c *MockRegistryService_ListRepositories_Call) Return(strings []string, err error) *MockRegistryService_ListRepositories_Call {
477 _c.Call.Return(strings, err)
478 return _c
479}
480
481func (_c *MockRegistryService_ListRepositories_Call) RunAndReturn(run func(ctx context.Context) ([]string, error)) *MockRegistryService_ListRepositories_Call {
482 _c.Call.Return(run)
483 return _c
484}
485
486// ListTags provides a mock function for the type MockRegistryService
487func (_mock *MockRegistryService) ListTags(ctx context.Context, name string) ([]string, error) {
488 ret := _mock.Called(ctx, name)
489
490 if len(ret) == 0 {
491 panic("no return value specified for ListTags")
492 }
493
494 var r0 []string
495 var r1 error
496 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]string, error)); ok {
497 return returnFunc(ctx, name)
498 }
499 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []string); ok {
500 r0 = returnFunc(ctx, name)
501 } else {
502 if ret.Get(0) != nil {
503 r0 = ret.Get(0).([]string)
504 }
505 }
506 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
507 r1 = returnFunc(ctx, name)
508 } else {
509 r1 = ret.Error(1)
510 }
511 return r0, r1
512}
513
514// MockRegistryService_ListTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTags'
515type MockRegistryService_ListTags_Call struct {
516 *mock.Call
517}
518
519// ListTags is a helper method to define mock.On call
520// - ctx context.Context
521// - name string
522func (_e *MockRegistryService_Expecter) ListTags(ctx interface{}, name interface{}) *MockRegistryService_ListTags_Call {
523 return &MockRegistryService_ListTags_Call{Call: _e.mock.On("ListTags", ctx, name)}
524}
525
526func (_c *MockRegistryService_ListTags_Call) Run(run func(ctx context.Context, name string)) *MockRegistryService_ListTags_Call {
527 _c.Call.Run(func(args mock.Arguments) {
528 var arg0 context.Context
529 if args[0] != nil {
530 arg0 = args[0].(context.Context)
531 }
532 var arg1 string
533 if args[1] != nil {
534 arg1 = args[1].(string)
535 }
536 run(
537 arg0,
538 arg1,
539 )
540 })
541 return _c
542}
543
544func (_c *MockRegistryService_ListTags_Call) Return(strings []string, err error) *MockRegistryService_ListTags_Call {
545 _c.Call.Return(strings, err)
546 return _c
547}
548
549func (_c *MockRegistryService_ListTags_Call) RunAndReturn(run func(ctx context.Context, name string) ([]string, error)) *MockRegistryService_ListTags_Call {
550 _c.Call.Return(run)
551 return _c
552}
553
554// PutBlob provides a mock function for the type MockRegistryService
555func (_mock *MockRegistryService) PutBlob(ctx context.Context, digest string, data io.Reader, size int64) error {
556 ret := _mock.Called(ctx, digest, data, size)
557
558 if len(ret) == 0 {
559 panic("no return value specified for PutBlob")
560 }
561
562 var r0 error
563 if returnFunc, ok := ret.Get(0).(func(context.Context, string, io.Reader, int64) error); ok {
564 r0 = returnFunc(ctx, digest, data, size)
565 } else {
566 r0 = ret.Error(0)
567 }
568 return r0
569}
570
571// MockRegistryService_PutBlob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBlob'
572type MockRegistryService_PutBlob_Call struct {
573 *mock.Call
574}
575
576// PutBlob is a helper method to define mock.On call
577// - ctx context.Context
578// - digest string
579// - data io.Reader
580// - size int64
581func (_e *MockRegistryService_Expecter) PutBlob(ctx interface{}, digest interface{}, data interface{}, size interface{}) *MockRegistryService_PutBlob_Call {
582 return &MockRegistryService_PutBlob_Call{Call: _e.mock.On("PutBlob", ctx, digest, data, size)}
583}
584
585func (_c *MockRegistryService_PutBlob_Call) Run(run func(ctx context.Context, digest string, data io.Reader, size int64)) *MockRegistryService_PutBlob_Call {
586 _c.Call.Run(func(args mock.Arguments) {
587 var arg0 context.Context
588 if args[0] != nil {
589 arg0 = args[0].(context.Context)
590 }
591 var arg1 string
592 if args[1] != nil {
593 arg1 = args[1].(string)
594 }
595 var arg2 io.Reader
596 if args[2] != nil {
597 arg2 = args[2].(io.Reader)
598 }
599 var arg3 int64
600 if args[3] != nil {
601 arg3 = args[3].(int64)
602 }
603 run(
604 arg0,
605 arg1,
606 arg2,
607 arg3,
608 )
609 })
610 return _c
611}
612
613func (_c *MockRegistryService_PutBlob_Call) Return(err error) *MockRegistryService_PutBlob_Call {
614 _c.Call.Return(err)
615 return _c
616}
617
618func (_c *MockRegistryService_PutBlob_Call) RunAndReturn(run func(ctx context.Context, digest string, data io.Reader, size int64) error) *MockRegistryService_PutBlob_Call {
619 _c.Call.Return(run)
620 return _c
621}
622
623// PutManifest provides a mock function for the type MockRegistryService
624func (_mock *MockRegistryService) PutManifest(ctx context.Context, manifest *domain.Manifest) error {
625 ret := _mock.Called(ctx, manifest)
626
627 if len(ret) == 0 {
628 panic("no return value specified for PutManifest")
629 }
630
631 var r0 error
632 if returnFunc, ok := ret.Get(0).(func(context.Context, *domain.Manifest) error); ok {
633 r0 = returnFunc(ctx, manifest)
634 } else {
635 r0 = ret.Error(0)
636 }
637 return r0
638}
639
640// MockRegistryService_PutManifest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutManifest'
641type MockRegistryService_PutManifest_Call struct {
642 *mock.Call
643}
644
645// PutManifest is a helper method to define mock.On call
646// - ctx context.Context
647// - manifest *domain.Manifest
648func (_e *MockRegistryService_Expecter) PutManifest(ctx interface{}, manifest interface{}) *MockRegistryService_PutManifest_Call {
649 return &MockRegistryService_PutManifest_Call{Call: _e.mock.On("PutManifest", ctx, manifest)}
650}
651
652func (_c *MockRegistryService_PutManifest_Call) Run(run func(ctx context.Context, manifest *domain.Manifest)) *MockRegistryService_PutManifest_Call {
653 _c.Call.Run(func(args mock.Arguments) {
654 var arg0 context.Context
655 if args[0] != nil {
656 arg0 = args[0].(context.Context)
657 }
658 var arg1 *domain.Manifest
659 if args[1] != nil {
660 arg1 = args[1].(*domain.Manifest)
661 }
662 run(
663 arg0,
664 arg1,
665 )
666 })
667 return _c
668}
669
670func (_c *MockRegistryService_PutManifest_Call) Return(err error) *MockRegistryService_PutManifest_Call {
671 _c.Call.Return(err)
672 return _c
673}
674
675func (_c *MockRegistryService_PutManifest_Call) RunAndReturn(run func(ctx context.Context, manifest *domain.Manifest) error) *MockRegistryService_PutManifest_Call {
676 _c.Call.Return(run)
677 return _c
678}
679
680// StartUpload provides a mock function for the type MockRegistryService
681func (_mock *MockRegistryService) StartUpload(ctx context.Context, name string) (string, error) {
682 ret := _mock.Called(ctx, name)
683
684 if len(ret) == 0 {
685 panic("no return value specified for StartUpload")
686 }
687
688 var r0 string
689 var r1 error
690 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (string, error)); ok {
691 return returnFunc(ctx, name)
692 }
693 if returnFunc, ok := ret.Get(0).(func(context.Context, string) string); ok {
694 r0 = returnFunc(ctx, name)
695 } else {
696 r0 = ret.Get(0).(string)
697 }
698 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
699 r1 = returnFunc(ctx, name)
700 } else {
701 r1 = ret.Error(1)
702 }
703 return r0, r1
704}
705
706// MockRegistryService_StartUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartUpload'
707type MockRegistryService_StartUpload_Call struct {
708 *mock.Call
709}
710
711// StartUpload is a helper method to define mock.On call
712// - ctx context.Context
713// - name string
714func (_e *MockRegistryService_Expecter) StartUpload(ctx interface{}, name interface{}) *MockRegistryService_StartUpload_Call {
715 return &MockRegistryService_StartUpload_Call{Call: _e.mock.On("StartUpload", ctx, name)}
716}
717
718func (_c *MockRegistryService_StartUpload_Call) Run(run func(ctx context.Context, name string)) *MockRegistryService_StartUpload_Call {
719 _c.Call.Run(func(args mock.Arguments) {
720 var arg0 context.Context
721 if args[0] != nil {
722 arg0 = args[0].(context.Context)
723 }
724 var arg1 string
725 if args[1] != nil {
726 arg1 = args[1].(string)
727 }
728 run(
729 arg0,
730 arg1,
731 )
732 })
733 return _c
734}
735
736func (_c *MockRegistryService_StartUpload_Call) Return(s string, err error) *MockRegistryService_StartUpload_Call {
737 _c.Call.Return(s, err)
738 return _c
739}
740
741func (_c *MockRegistryService_StartUpload_Call) RunAndReturn(run func(ctx context.Context, name string) (string, error)) *MockRegistryService_StartUpload_Call {
742 _c.Call.Return(run)
743 return _c
744}