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