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