1
2 package fake
3
4 import (
5 "sync"
6
7 v1 "github.com/google/go-containerregistry/pkg/v1"
8 "github.com/google/go-containerregistry/pkg/v1/types"
9 )
10
11 type FakeImageIndex struct {
12 DigestStub func() (v1.Hash, error)
13 digestMutex sync.RWMutex
14 digestArgsForCall []struct {
15 }
16 digestReturns struct {
17 result1 v1.Hash
18 result2 error
19 }
20 digestReturnsOnCall map[int]struct {
21 result1 v1.Hash
22 result2 error
23 }
24 ImageStub func(v1.Hash) (v1.Image, error)
25 imageMutex sync.RWMutex
26 imageArgsForCall []struct {
27 arg1 v1.Hash
28 }
29 imageReturns struct {
30 result1 v1.Image
31 result2 error
32 }
33 imageReturnsOnCall map[int]struct {
34 result1 v1.Image
35 result2 error
36 }
37 ImageIndexStub func(v1.Hash) (v1.ImageIndex, error)
38 imageIndexMutex sync.RWMutex
39 imageIndexArgsForCall []struct {
40 arg1 v1.Hash
41 }
42 imageIndexReturns struct {
43 result1 v1.ImageIndex
44 result2 error
45 }
46 imageIndexReturnsOnCall map[int]struct {
47 result1 v1.ImageIndex
48 result2 error
49 }
50 IndexManifestStub func() (*v1.IndexManifest, error)
51 indexManifestMutex sync.RWMutex
52 indexManifestArgsForCall []struct {
53 }
54 indexManifestReturns struct {
55 result1 *v1.IndexManifest
56 result2 error
57 }
58 indexManifestReturnsOnCall map[int]struct {
59 result1 *v1.IndexManifest
60 result2 error
61 }
62 MediaTypeStub func() (types.MediaType, error)
63 mediaTypeMutex sync.RWMutex
64 mediaTypeArgsForCall []struct {
65 }
66 mediaTypeReturns struct {
67 result1 types.MediaType
68 result2 error
69 }
70 mediaTypeReturnsOnCall map[int]struct {
71 result1 types.MediaType
72 result2 error
73 }
74 RawManifestStub func() ([]byte, error)
75 rawManifestMutex sync.RWMutex
76 rawManifestArgsForCall []struct {
77 }
78 rawManifestReturns struct {
79 result1 []byte
80 result2 error
81 }
82 rawManifestReturnsOnCall map[int]struct {
83 result1 []byte
84 result2 error
85 }
86 SizeStub func() (int64, error)
87 sizeMutex sync.RWMutex
88 sizeArgsForCall []struct {
89 }
90 sizeReturns struct {
91 result1 int64
92 result2 error
93 }
94 sizeReturnsOnCall map[int]struct {
95 result1 int64
96 result2 error
97 }
98 invocations map[string][][]interface{}
99 invocationsMutex sync.RWMutex
100 }
101
102 func (fake *FakeImageIndex) Digest() (v1.Hash, error) {
103 fake.digestMutex.Lock()
104 ret, specificReturn := fake.digestReturnsOnCall[len(fake.digestArgsForCall)]
105 fake.digestArgsForCall = append(fake.digestArgsForCall, struct {
106 }{})
107 stub := fake.DigestStub
108 fakeReturns := fake.digestReturns
109 fake.recordInvocation("Digest", []interface{}{})
110 fake.digestMutex.Unlock()
111 if stub != nil {
112 return stub()
113 }
114 if specificReturn {
115 return ret.result1, ret.result2
116 }
117 return fakeReturns.result1, fakeReturns.result2
118 }
119
120 func (fake *FakeImageIndex) DigestCallCount() int {
121 fake.digestMutex.RLock()
122 defer fake.digestMutex.RUnlock()
123 return len(fake.digestArgsForCall)
124 }
125
126 func (fake *FakeImageIndex) DigestCalls(stub func() (v1.Hash, error)) {
127 fake.digestMutex.Lock()
128 defer fake.digestMutex.Unlock()
129 fake.DigestStub = stub
130 }
131
132 func (fake *FakeImageIndex) DigestReturns(result1 v1.Hash, result2 error) {
133 fake.digestMutex.Lock()
134 defer fake.digestMutex.Unlock()
135 fake.DigestStub = nil
136 fake.digestReturns = struct {
137 result1 v1.Hash
138 result2 error
139 }{result1, result2}
140 }
141
142 func (fake *FakeImageIndex) DigestReturnsOnCall(i int, result1 v1.Hash, result2 error) {
143 fake.digestMutex.Lock()
144 defer fake.digestMutex.Unlock()
145 fake.DigestStub = nil
146 if fake.digestReturnsOnCall == nil {
147 fake.digestReturnsOnCall = make(map[int]struct {
148 result1 v1.Hash
149 result2 error
150 })
151 }
152 fake.digestReturnsOnCall[i] = struct {
153 result1 v1.Hash
154 result2 error
155 }{result1, result2}
156 }
157
158 func (fake *FakeImageIndex) Image(arg1 v1.Hash) (v1.Image, error) {
159 fake.imageMutex.Lock()
160 ret, specificReturn := fake.imageReturnsOnCall[len(fake.imageArgsForCall)]
161 fake.imageArgsForCall = append(fake.imageArgsForCall, struct {
162 arg1 v1.Hash
163 }{arg1})
164 stub := fake.ImageStub
165 fakeReturns := fake.imageReturns
166 fake.recordInvocation("Image", []interface{}{arg1})
167 fake.imageMutex.Unlock()
168 if stub != nil {
169 return stub(arg1)
170 }
171 if specificReturn {
172 return ret.result1, ret.result2
173 }
174 return fakeReturns.result1, fakeReturns.result2
175 }
176
177 func (fake *FakeImageIndex) ImageCallCount() int {
178 fake.imageMutex.RLock()
179 defer fake.imageMutex.RUnlock()
180 return len(fake.imageArgsForCall)
181 }
182
183 func (fake *FakeImageIndex) ImageCalls(stub func(v1.Hash) (v1.Image, error)) {
184 fake.imageMutex.Lock()
185 defer fake.imageMutex.Unlock()
186 fake.ImageStub = stub
187 }
188
189 func (fake *FakeImageIndex) ImageArgsForCall(i int) v1.Hash {
190 fake.imageMutex.RLock()
191 defer fake.imageMutex.RUnlock()
192 argsForCall := fake.imageArgsForCall[i]
193 return argsForCall.arg1
194 }
195
196 func (fake *FakeImageIndex) ImageReturns(result1 v1.Image, result2 error) {
197 fake.imageMutex.Lock()
198 defer fake.imageMutex.Unlock()
199 fake.ImageStub = nil
200 fake.imageReturns = struct {
201 result1 v1.Image
202 result2 error
203 }{result1, result2}
204 }
205
206 func (fake *FakeImageIndex) ImageReturnsOnCall(i int, result1 v1.Image, result2 error) {
207 fake.imageMutex.Lock()
208 defer fake.imageMutex.Unlock()
209 fake.ImageStub = nil
210 if fake.imageReturnsOnCall == nil {
211 fake.imageReturnsOnCall = make(map[int]struct {
212 result1 v1.Image
213 result2 error
214 })
215 }
216 fake.imageReturnsOnCall[i] = struct {
217 result1 v1.Image
218 result2 error
219 }{result1, result2}
220 }
221
222 func (fake *FakeImageIndex) ImageIndex(arg1 v1.Hash) (v1.ImageIndex, error) {
223 fake.imageIndexMutex.Lock()
224 ret, specificReturn := fake.imageIndexReturnsOnCall[len(fake.imageIndexArgsForCall)]
225 fake.imageIndexArgsForCall = append(fake.imageIndexArgsForCall, struct {
226 arg1 v1.Hash
227 }{arg1})
228 stub := fake.ImageIndexStub
229 fakeReturns := fake.imageIndexReturns
230 fake.recordInvocation("ImageIndex", []interface{}{arg1})
231 fake.imageIndexMutex.Unlock()
232 if stub != nil {
233 return stub(arg1)
234 }
235 if specificReturn {
236 return ret.result1, ret.result2
237 }
238 return fakeReturns.result1, fakeReturns.result2
239 }
240
241 func (fake *FakeImageIndex) ImageIndexCallCount() int {
242 fake.imageIndexMutex.RLock()
243 defer fake.imageIndexMutex.RUnlock()
244 return len(fake.imageIndexArgsForCall)
245 }
246
247 func (fake *FakeImageIndex) ImageIndexCalls(stub func(v1.Hash) (v1.ImageIndex, error)) {
248 fake.imageIndexMutex.Lock()
249 defer fake.imageIndexMutex.Unlock()
250 fake.ImageIndexStub = stub
251 }
252
253 func (fake *FakeImageIndex) ImageIndexArgsForCall(i int) v1.Hash {
254 fake.imageIndexMutex.RLock()
255 defer fake.imageIndexMutex.RUnlock()
256 argsForCall := fake.imageIndexArgsForCall[i]
257 return argsForCall.arg1
258 }
259
260 func (fake *FakeImageIndex) ImageIndexReturns(result1 v1.ImageIndex, result2 error) {
261 fake.imageIndexMutex.Lock()
262 defer fake.imageIndexMutex.Unlock()
263 fake.ImageIndexStub = nil
264 fake.imageIndexReturns = struct {
265 result1 v1.ImageIndex
266 result2 error
267 }{result1, result2}
268 }
269
270 func (fake *FakeImageIndex) ImageIndexReturnsOnCall(i int, result1 v1.ImageIndex, result2 error) {
271 fake.imageIndexMutex.Lock()
272 defer fake.imageIndexMutex.Unlock()
273 fake.ImageIndexStub = nil
274 if fake.imageIndexReturnsOnCall == nil {
275 fake.imageIndexReturnsOnCall = make(map[int]struct {
276 result1 v1.ImageIndex
277 result2 error
278 })
279 }
280 fake.imageIndexReturnsOnCall[i] = struct {
281 result1 v1.ImageIndex
282 result2 error
283 }{result1, result2}
284 }
285
286 func (fake *FakeImageIndex) IndexManifest() (*v1.IndexManifest, error) {
287 fake.indexManifestMutex.Lock()
288 ret, specificReturn := fake.indexManifestReturnsOnCall[len(fake.indexManifestArgsForCall)]
289 fake.indexManifestArgsForCall = append(fake.indexManifestArgsForCall, struct {
290 }{})
291 stub := fake.IndexManifestStub
292 fakeReturns := fake.indexManifestReturns
293 fake.recordInvocation("IndexManifest", []interface{}{})
294 fake.indexManifestMutex.Unlock()
295 if stub != nil {
296 return stub()
297 }
298 if specificReturn {
299 return ret.result1, ret.result2
300 }
301 return fakeReturns.result1, fakeReturns.result2
302 }
303
304 func (fake *FakeImageIndex) IndexManifestCallCount() int {
305 fake.indexManifestMutex.RLock()
306 defer fake.indexManifestMutex.RUnlock()
307 return len(fake.indexManifestArgsForCall)
308 }
309
310 func (fake *FakeImageIndex) IndexManifestCalls(stub func() (*v1.IndexManifest, error)) {
311 fake.indexManifestMutex.Lock()
312 defer fake.indexManifestMutex.Unlock()
313 fake.IndexManifestStub = stub
314 }
315
316 func (fake *FakeImageIndex) IndexManifestReturns(result1 *v1.IndexManifest, result2 error) {
317 fake.indexManifestMutex.Lock()
318 defer fake.indexManifestMutex.Unlock()
319 fake.IndexManifestStub = nil
320 fake.indexManifestReturns = struct {
321 result1 *v1.IndexManifest
322 result2 error
323 }{result1, result2}
324 }
325
326 func (fake *FakeImageIndex) IndexManifestReturnsOnCall(i int, result1 *v1.IndexManifest, result2 error) {
327 fake.indexManifestMutex.Lock()
328 defer fake.indexManifestMutex.Unlock()
329 fake.IndexManifestStub = nil
330 if fake.indexManifestReturnsOnCall == nil {
331 fake.indexManifestReturnsOnCall = make(map[int]struct {
332 result1 *v1.IndexManifest
333 result2 error
334 })
335 }
336 fake.indexManifestReturnsOnCall[i] = struct {
337 result1 *v1.IndexManifest
338 result2 error
339 }{result1, result2}
340 }
341
342 func (fake *FakeImageIndex) MediaType() (types.MediaType, error) {
343 fake.mediaTypeMutex.Lock()
344 ret, specificReturn := fake.mediaTypeReturnsOnCall[len(fake.mediaTypeArgsForCall)]
345 fake.mediaTypeArgsForCall = append(fake.mediaTypeArgsForCall, struct {
346 }{})
347 stub := fake.MediaTypeStub
348 fakeReturns := fake.mediaTypeReturns
349 fake.recordInvocation("MediaType", []interface{}{})
350 fake.mediaTypeMutex.Unlock()
351 if stub != nil {
352 return stub()
353 }
354 if specificReturn {
355 return ret.result1, ret.result2
356 }
357 return fakeReturns.result1, fakeReturns.result2
358 }
359
360 func (fake *FakeImageIndex) MediaTypeCallCount() int {
361 fake.mediaTypeMutex.RLock()
362 defer fake.mediaTypeMutex.RUnlock()
363 return len(fake.mediaTypeArgsForCall)
364 }
365
366 func (fake *FakeImageIndex) MediaTypeCalls(stub func() (types.MediaType, error)) {
367 fake.mediaTypeMutex.Lock()
368 defer fake.mediaTypeMutex.Unlock()
369 fake.MediaTypeStub = stub
370 }
371
372 func (fake *FakeImageIndex) MediaTypeReturns(result1 types.MediaType, result2 error) {
373 fake.mediaTypeMutex.Lock()
374 defer fake.mediaTypeMutex.Unlock()
375 fake.MediaTypeStub = nil
376 fake.mediaTypeReturns = struct {
377 result1 types.MediaType
378 result2 error
379 }{result1, result2}
380 }
381
382 func (fake *FakeImageIndex) MediaTypeReturnsOnCall(i int, result1 types.MediaType, result2 error) {
383 fake.mediaTypeMutex.Lock()
384 defer fake.mediaTypeMutex.Unlock()
385 fake.MediaTypeStub = nil
386 if fake.mediaTypeReturnsOnCall == nil {
387 fake.mediaTypeReturnsOnCall = make(map[int]struct {
388 result1 types.MediaType
389 result2 error
390 })
391 }
392 fake.mediaTypeReturnsOnCall[i] = struct {
393 result1 types.MediaType
394 result2 error
395 }{result1, result2}
396 }
397
398 func (fake *FakeImageIndex) RawManifest() ([]byte, error) {
399 fake.rawManifestMutex.Lock()
400 ret, specificReturn := fake.rawManifestReturnsOnCall[len(fake.rawManifestArgsForCall)]
401 fake.rawManifestArgsForCall = append(fake.rawManifestArgsForCall, struct {
402 }{})
403 stub := fake.RawManifestStub
404 fakeReturns := fake.rawManifestReturns
405 fake.recordInvocation("RawManifest", []interface{}{})
406 fake.rawManifestMutex.Unlock()
407 if stub != nil {
408 return stub()
409 }
410 if specificReturn {
411 return ret.result1, ret.result2
412 }
413 return fakeReturns.result1, fakeReturns.result2
414 }
415
416 func (fake *FakeImageIndex) RawManifestCallCount() int {
417 fake.rawManifestMutex.RLock()
418 defer fake.rawManifestMutex.RUnlock()
419 return len(fake.rawManifestArgsForCall)
420 }
421
422 func (fake *FakeImageIndex) RawManifestCalls(stub func() ([]byte, error)) {
423 fake.rawManifestMutex.Lock()
424 defer fake.rawManifestMutex.Unlock()
425 fake.RawManifestStub = stub
426 }
427
428 func (fake *FakeImageIndex) RawManifestReturns(result1 []byte, result2 error) {
429 fake.rawManifestMutex.Lock()
430 defer fake.rawManifestMutex.Unlock()
431 fake.RawManifestStub = nil
432 fake.rawManifestReturns = struct {
433 result1 []byte
434 result2 error
435 }{result1, result2}
436 }
437
438 func (fake *FakeImageIndex) RawManifestReturnsOnCall(i int, result1 []byte, result2 error) {
439 fake.rawManifestMutex.Lock()
440 defer fake.rawManifestMutex.Unlock()
441 fake.RawManifestStub = nil
442 if fake.rawManifestReturnsOnCall == nil {
443 fake.rawManifestReturnsOnCall = make(map[int]struct {
444 result1 []byte
445 result2 error
446 })
447 }
448 fake.rawManifestReturnsOnCall[i] = struct {
449 result1 []byte
450 result2 error
451 }{result1, result2}
452 }
453
454 func (fake *FakeImageIndex) Size() (int64, error) {
455 fake.sizeMutex.Lock()
456 ret, specificReturn := fake.sizeReturnsOnCall[len(fake.sizeArgsForCall)]
457 fake.sizeArgsForCall = append(fake.sizeArgsForCall, struct {
458 }{})
459 stub := fake.SizeStub
460 fakeReturns := fake.sizeReturns
461 fake.recordInvocation("Size", []interface{}{})
462 fake.sizeMutex.Unlock()
463 if stub != nil {
464 return stub()
465 }
466 if specificReturn {
467 return ret.result1, ret.result2
468 }
469 return fakeReturns.result1, fakeReturns.result2
470 }
471
472 func (fake *FakeImageIndex) SizeCallCount() int {
473 fake.sizeMutex.RLock()
474 defer fake.sizeMutex.RUnlock()
475 return len(fake.sizeArgsForCall)
476 }
477
478 func (fake *FakeImageIndex) SizeCalls(stub func() (int64, error)) {
479 fake.sizeMutex.Lock()
480 defer fake.sizeMutex.Unlock()
481 fake.SizeStub = stub
482 }
483
484 func (fake *FakeImageIndex) SizeReturns(result1 int64, result2 error) {
485 fake.sizeMutex.Lock()
486 defer fake.sizeMutex.Unlock()
487 fake.SizeStub = nil
488 fake.sizeReturns = struct {
489 result1 int64
490 result2 error
491 }{result1, result2}
492 }
493
494 func (fake *FakeImageIndex) SizeReturnsOnCall(i int, result1 int64, result2 error) {
495 fake.sizeMutex.Lock()
496 defer fake.sizeMutex.Unlock()
497 fake.SizeStub = nil
498 if fake.sizeReturnsOnCall == nil {
499 fake.sizeReturnsOnCall = make(map[int]struct {
500 result1 int64
501 result2 error
502 })
503 }
504 fake.sizeReturnsOnCall[i] = struct {
505 result1 int64
506 result2 error
507 }{result1, result2}
508 }
509
510 func (fake *FakeImageIndex) Invocations() map[string][][]interface{} {
511 fake.invocationsMutex.RLock()
512 defer fake.invocationsMutex.RUnlock()
513 fake.digestMutex.RLock()
514 defer fake.digestMutex.RUnlock()
515 fake.imageMutex.RLock()
516 defer fake.imageMutex.RUnlock()
517 fake.imageIndexMutex.RLock()
518 defer fake.imageIndexMutex.RUnlock()
519 fake.indexManifestMutex.RLock()
520 defer fake.indexManifestMutex.RUnlock()
521 fake.mediaTypeMutex.RLock()
522 defer fake.mediaTypeMutex.RUnlock()
523 fake.rawManifestMutex.RLock()
524 defer fake.rawManifestMutex.RUnlock()
525 fake.sizeMutex.RLock()
526 defer fake.sizeMutex.RUnlock()
527 copiedInvocations := map[string][][]interface{}{}
528 for key, value := range fake.invocations {
529 copiedInvocations[key] = value
530 }
531 return copiedInvocations
532 }
533
534 func (fake *FakeImageIndex) recordInvocation(key string, args []interface{}) {
535 fake.invocationsMutex.Lock()
536 defer fake.invocationsMutex.Unlock()
537 if fake.invocations == nil {
538 fake.invocations = map[string][][]interface{}{}
539 }
540 if fake.invocations[key] == nil {
541 fake.invocations[key] = [][]interface{}{}
542 }
543 fake.invocations[key] = append(fake.invocations[key], args)
544 }
545
546 var _ v1.ImageIndex = new(FakeImageIndex)
547
View as plain text