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) (int64, 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 int64
290 var r1 error
291 if returnFunc, ok := ret.Get(0).(func(string) (int64, error)); ok {
292 return returnFunc(digest)
293 }
294 if returnFunc, ok := ret.Get(0).(func(string) int64); ok {
295 r0 = returnFunc(digest)
296 } else {
297 r0 = ret.Get(0).(int64)
298 }
299 if returnFunc, ok := ret.Get(1).(func(string) error); ok {
300 r1 = returnFunc(digest)
301 } else {
302 r1 = ret.Error(1)
303 }
304 return r0, r1
305}
306
307// MockBlobStorage_DeleteBlob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBlob'
308type MockBlobStorage_DeleteBlob_Call struct {
309 *mock.Call
310}
311
312// DeleteBlob is a helper method to define mock.On call
313// - digest string
314func (_e *MockBlobStorage_Expecter) DeleteBlob(digest interface{}) *MockBlobStorage_DeleteBlob_Call {
315 return &MockBlobStorage_DeleteBlob_Call{Call: _e.mock.On("DeleteBlob", digest)}
316}
317
318func (_c *MockBlobStorage_DeleteBlob_Call) Run(run func(digest string)) *MockBlobStorage_DeleteBlob_Call {
319 _c.Call.Run(func(args mock.Arguments) {
320 var arg0 string
321 if args[0] != nil {
322 arg0 = args[0].(string)
323 }
324 run(
325 arg0,
326 )
327 })
328 return _c
329}
330
331func (_c *MockBlobStorage_DeleteBlob_Call) Return(n int64, err error) *MockBlobStorage_DeleteBlob_Call {
332 _c.Call.Return(n, err)
333 return _c
334}
335
336func (_c *MockBlobStorage_DeleteBlob_Call) RunAndReturn(run func(digest string) (int64, error)) *MockBlobStorage_DeleteBlob_Call {
337 _c.Call.Return(run)
338 return _c
339}
340
341// FinishBlobUpload provides a mock function for the type MockBlobStorage
342func (_mock *MockBlobStorage) FinishBlobUpload(uuid string, digest string) error {
343 ret := _mock.Called(uuid, digest)
344
345 if len(ret) == 0 {
346 panic("no return value specified for FinishBlobUpload")
347 }
348
349 var r0 error
350 if returnFunc, ok := ret.Get(0).(func(string, string) error); ok {
351 r0 = returnFunc(uuid, digest)
352 } else {
353 r0 = ret.Error(0)
354 }
355 return r0
356}
357
358// MockBlobStorage_FinishBlobUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FinishBlobUpload'
359type MockBlobStorage_FinishBlobUpload_Call struct {
360 *mock.Call
361}
362
363// FinishBlobUpload is a helper method to define mock.On call
364// - uuid string
365// - digest string
366func (_e *MockBlobStorage_Expecter) FinishBlobUpload(uuid interface{}, digest interface{}) *MockBlobStorage_FinishBlobUpload_Call {
367 return &MockBlobStorage_FinishBlobUpload_Call{Call: _e.mock.On("FinishBlobUpload", uuid, digest)}
368}
369
370func (_c *MockBlobStorage_FinishBlobUpload_Call) Run(run func(uuid string, digest string)) *MockBlobStorage_FinishBlobUpload_Call {
371 _c.Call.Run(func(args mock.Arguments) {
372 var arg0 string
373 if args[0] != nil {
374 arg0 = args[0].(string)
375 }
376 var arg1 string
377 if args[1] != nil {
378 arg1 = args[1].(string)
379 }
380 run(
381 arg0,
382 arg1,
383 )
384 })
385 return _c
386}
387
388func (_c *MockBlobStorage_FinishBlobUpload_Call) Return(err error) *MockBlobStorage_FinishBlobUpload_Call {
389 _c.Call.Return(err)
390 return _c
391}
392
393func (_c *MockBlobStorage_FinishBlobUpload_Call) RunAndReturn(run func(uuid string, digest string) error) *MockBlobStorage_FinishBlobUpload_Call {
394 _c.Call.Return(run)
395 return _c
396}
397
398// GetBlob provides a mock function for the type MockBlobStorage
399func (_mock *MockBlobStorage) GetBlob(digest string) (io.ReadCloser, error) {
400 ret := _mock.Called(digest)
401
402 if len(ret) == 0 {
403 panic("no return value specified for GetBlob")
404 }
405
406 var r0 io.ReadCloser
407 var r1 error
408 if returnFunc, ok := ret.Get(0).(func(string) (io.ReadCloser, error)); ok {
409 return returnFunc(digest)
410 }
411 if returnFunc, ok := ret.Get(0).(func(string) io.ReadCloser); ok {
412 r0 = returnFunc(digest)
413 } else {
414 if ret.Get(0) != nil {
415 r0 = ret.Get(0).(io.ReadCloser)
416 }
417 }
418 if returnFunc, ok := ret.Get(1).(func(string) error); ok {
419 r1 = returnFunc(digest)
420 } else {
421 r1 = ret.Error(1)
422 }
423 return r0, r1
424}
425
426// MockBlobStorage_GetBlob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlob'
427type MockBlobStorage_GetBlob_Call struct {
428 *mock.Call
429}
430
431// GetBlob is a helper method to define mock.On call
432// - digest string
433func (_e *MockBlobStorage_Expecter) GetBlob(digest interface{}) *MockBlobStorage_GetBlob_Call {
434 return &MockBlobStorage_GetBlob_Call{Call: _e.mock.On("GetBlob", digest)}
435}
436
437func (_c *MockBlobStorage_GetBlob_Call) Run(run func(digest string)) *MockBlobStorage_GetBlob_Call {
438 _c.Call.Run(func(args mock.Arguments) {
439 var arg0 string
440 if args[0] != nil {
441 arg0 = args[0].(string)
442 }
443 run(
444 arg0,
445 )
446 })
447 return _c
448}
449
450func (_c *MockBlobStorage_GetBlob_Call) Return(readCloser io.ReadCloser, err error) *MockBlobStorage_GetBlob_Call {
451 _c.Call.Return(readCloser, err)
452 return _c
453}
454
455func (_c *MockBlobStorage_GetBlob_Call) RunAndReturn(run func(digest string) (io.ReadCloser, error)) *MockBlobStorage_GetBlob_Call {
456 _c.Call.Return(run)
457 return _c
458}
459
460// GetBlobPath provides a mock function for the type MockBlobStorage
461func (_mock *MockBlobStorage) GetBlobPath(digest string) (string, error) {
462 ret := _mock.Called(digest)
463
464 if len(ret) == 0 {
465 panic("no return value specified for GetBlobPath")
466 }
467
468 var r0 string
469 var r1 error
470 if returnFunc, ok := ret.Get(0).(func(string) (string, error)); ok {
471 return returnFunc(digest)
472 }
473 if returnFunc, ok := ret.Get(0).(func(string) string); ok {
474 r0 = returnFunc(digest)
475 } else {
476 r0 = ret.Get(0).(string)
477 }
478 if returnFunc, ok := ret.Get(1).(func(string) error); ok {
479 r1 = returnFunc(digest)
480 } else {
481 r1 = ret.Error(1)
482 }
483 return r0, r1
484}
485
486// MockBlobStorage_GetBlobPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlobPath'
487type MockBlobStorage_GetBlobPath_Call struct {
488 *mock.Call
489}
490
491// GetBlobPath is a helper method to define mock.On call
492// - digest string
493func (_e *MockBlobStorage_Expecter) GetBlobPath(digest interface{}) *MockBlobStorage_GetBlobPath_Call {
494 return &MockBlobStorage_GetBlobPath_Call{Call: _e.mock.On("GetBlobPath", digest)}
495}
496
497func (_c *MockBlobStorage_GetBlobPath_Call) Run(run func(digest string)) *MockBlobStorage_GetBlobPath_Call {
498 _c.Call.Run(func(args mock.Arguments) {
499 var arg0 string
500 if args[0] != nil {
501 arg0 = args[0].(string)
502 }
503 run(
504 arg0,
505 )
506 })
507 return _c
508}
509
510func (_c *MockBlobStorage_GetBlobPath_Call) Return(s string, err error) *MockBlobStorage_GetBlobPath_Call {
511 _c.Call.Return(s, err)
512 return _c
513}
514
515func (_c *MockBlobStorage_GetBlobPath_Call) RunAndReturn(run func(digest string) (string, error)) *MockBlobStorage_GetBlobPath_Call {
516 _c.Call.Return(run)
517 return _c
518}
519
520// GetBlobUpload provides a mock function for the type MockBlobStorage
521func (_mock *MockBlobStorage) GetBlobUpload(uuid string) (io.WriteCloser, error) {
522 ret := _mock.Called(uuid)
523
524 if len(ret) == 0 {
525 panic("no return value specified for GetBlobUpload")
526 }
527
528 var r0 io.WriteCloser
529 var r1 error
530 if returnFunc, ok := ret.Get(0).(func(string) (io.WriteCloser, error)); ok {
531 return returnFunc(uuid)
532 }
533 if returnFunc, ok := ret.Get(0).(func(string) io.WriteCloser); ok {
534 r0 = returnFunc(uuid)
535 } else {
536 if ret.Get(0) != nil {
537 r0 = ret.Get(0).(io.WriteCloser)
538 }
539 }
540 if returnFunc, ok := ret.Get(1).(func(string) error); ok {
541 r1 = returnFunc(uuid)
542 } else {
543 r1 = ret.Error(1)
544 }
545 return r0, r1
546}
547
548// MockBlobStorage_GetBlobUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlobUpload'
549type MockBlobStorage_GetBlobUpload_Call struct {
550 *mock.Call
551}
552
553// GetBlobUpload is a helper method to define mock.On call
554// - uuid string
555func (_e *MockBlobStorage_Expecter) GetBlobUpload(uuid interface{}) *MockBlobStorage_GetBlobUpload_Call {
556 return &MockBlobStorage_GetBlobUpload_Call{Call: _e.mock.On("GetBlobUpload", uuid)}
557}
558
559func (_c *MockBlobStorage_GetBlobUpload_Call) Run(run func(uuid string)) *MockBlobStorage_GetBlobUpload_Call {
560 _c.Call.Run(func(args mock.Arguments) {
561 var arg0 string
562 if args[0] != nil {
563 arg0 = args[0].(string)
564 }
565 run(
566 arg0,
567 )
568 })
569 return _c
570}
571
572func (_c *MockBlobStorage_GetBlobUpload_Call) Return(writeCloser io.WriteCloser, err error) *MockBlobStorage_GetBlobUpload_Call {
573 _c.Call.Return(writeCloser, err)
574 return _c
575}
576
577func (_c *MockBlobStorage_GetBlobUpload_Call) RunAndReturn(run func(uuid string) (io.WriteCloser, error)) *MockBlobStorage_GetBlobUpload_Call {
578 _c.Call.Return(run)
579 return _c
580}
581
582// ListBlobs provides a mock function for the type MockBlobStorage
583func (_mock *MockBlobStorage) ListBlobs() ([]string, error) {
584 ret := _mock.Called()
585
586 if len(ret) == 0 {
587 panic("no return value specified for ListBlobs")
588 }
589
590 var r0 []string
591 var r1 error
592 if returnFunc, ok := ret.Get(0).(func() ([]string, error)); ok {
593 return returnFunc()
594 }
595 if returnFunc, ok := ret.Get(0).(func() []string); ok {
596 r0 = returnFunc()
597 } else {
598 if ret.Get(0) != nil {
599 r0 = ret.Get(0).([]string)
600 }
601 }
602 if returnFunc, ok := ret.Get(1).(func() error); ok {
603 r1 = returnFunc()
604 } else {
605 r1 = ret.Error(1)
606 }
607 return r0, r1
608}
609
610// MockBlobStorage_ListBlobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBlobs'
611type MockBlobStorage_ListBlobs_Call struct {
612 *mock.Call
613}
614
615// ListBlobs is a helper method to define mock.On call
616func (_e *MockBlobStorage_Expecter) ListBlobs() *MockBlobStorage_ListBlobs_Call {
617 return &MockBlobStorage_ListBlobs_Call{Call: _e.mock.On("ListBlobs")}
618}
619
620func (_c *MockBlobStorage_ListBlobs_Call) Run(run func()) *MockBlobStorage_ListBlobs_Call {
621 _c.Call.Run(func(args mock.Arguments) {
622 run()
623 })
624 return _c
625}
626
627func (_c *MockBlobStorage_ListBlobs_Call) Return(strings []string, err error) *MockBlobStorage_ListBlobs_Call {
628 _c.Call.Return(strings, err)
629 return _c
630}
631
632func (_c *MockBlobStorage_ListBlobs_Call) RunAndReturn(run func() ([]string, error)) *MockBlobStorage_ListBlobs_Call {
633 _c.Call.Return(run)
634 return _c
635}
636
637// PutBlob provides a mock function for the type MockBlobStorage
638func (_mock *MockBlobStorage) PutBlob(digest string, data io.Reader, size int64) error {
639 ret := _mock.Called(digest, data, size)
640
641 if len(ret) == 0 {
642 panic("no return value specified for PutBlob")
643 }
644
645 var r0 error
646 if returnFunc, ok := ret.Get(0).(func(string, io.Reader, int64) error); ok {
647 r0 = returnFunc(digest, data, size)
648 } else {
649 r0 = ret.Error(0)
650 }
651 return r0
652}
653
654// MockBlobStorage_PutBlob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBlob'
655type MockBlobStorage_PutBlob_Call struct {
656 *mock.Call
657}
658
659// PutBlob is a helper method to define mock.On call
660// - digest string
661// - data io.Reader
662// - size int64
663func (_e *MockBlobStorage_Expecter) PutBlob(digest interface{}, data interface{}, size interface{}) *MockBlobStorage_PutBlob_Call {
664 return &MockBlobStorage_PutBlob_Call{Call: _e.mock.On("PutBlob", digest, data, size)}
665}
666
667func (_c *MockBlobStorage_PutBlob_Call) Run(run func(digest string, data io.Reader, size int64)) *MockBlobStorage_PutBlob_Call {
668 _c.Call.Run(func(args mock.Arguments) {
669 var arg0 string
670 if args[0] != nil {
671 arg0 = args[0].(string)
672 }
673 var arg1 io.Reader
674 if args[1] != nil {
675 arg1 = args[1].(io.Reader)
676 }
677 var arg2 int64
678 if args[2] != nil {
679 arg2 = args[2].(int64)
680 }
681 run(
682 arg0,
683 arg1,
684 arg2,
685 )
686 })
687 return _c
688}
689
690func (_c *MockBlobStorage_PutBlob_Call) Return(err error) *MockBlobStorage_PutBlob_Call {
691 _c.Call.Return(err)
692 return _c
693}
694
695func (_c *MockBlobStorage_PutBlob_Call) RunAndReturn(run func(digest string, data io.Reader, size int64) error) *MockBlobStorage_PutBlob_Call {
696 _c.Call.Return(run)
697 return _c
698}
699
700// StartBlobUpload provides a mock function for the type MockBlobStorage
701func (_mock *MockBlobStorage) StartBlobUpload(name string) (string, error) {
702 ret := _mock.Called(name)
703
704 if len(ret) == 0 {
705 panic("no return value specified for StartBlobUpload")
706 }
707
708 var r0 string
709 var r1 error
710 if returnFunc, ok := ret.Get(0).(func(string) (string, error)); ok {
711 return returnFunc(name)
712 }
713 if returnFunc, ok := ret.Get(0).(func(string) string); ok {
714 r0 = returnFunc(name)
715 } else {
716 r0 = ret.Get(0).(string)
717 }
718 if returnFunc, ok := ret.Get(1).(func(string) error); ok {
719 r1 = returnFunc(name)
720 } else {
721 r1 = ret.Error(1)
722 }
723 return r0, r1
724}
725
726// MockBlobStorage_StartBlobUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartBlobUpload'
727type MockBlobStorage_StartBlobUpload_Call struct {
728 *mock.Call
729}
730
731// StartBlobUpload is a helper method to define mock.On call
732// - name string
733func (_e *MockBlobStorage_Expecter) StartBlobUpload(name interface{}) *MockBlobStorage_StartBlobUpload_Call {
734 return &MockBlobStorage_StartBlobUpload_Call{Call: _e.mock.On("StartBlobUpload", name)}
735}
736
737func (_c *MockBlobStorage_StartBlobUpload_Call) Run(run func(name string)) *MockBlobStorage_StartBlobUpload_Call {
738 _c.Call.Run(func(args mock.Arguments) {
739 var arg0 string
740 if args[0] != nil {
741 arg0 = args[0].(string)
742 }
743 run(
744 arg0,
745 )
746 })
747 return _c
748}
749
750func (_c *MockBlobStorage_StartBlobUpload_Call) Return(s string, err error) *MockBlobStorage_StartBlobUpload_Call {
751 _c.Call.Return(s, err)
752 return _c
753}
754
755func (_c *MockBlobStorage_StartBlobUpload_Call) RunAndReturn(run func(name string) (string, error)) *MockBlobStorage_StartBlobUpload_Call {
756 _c.Call.Return(run)
757 return _c
758}