github.com/pf-qiu/concourse/v6@v6.7.3-0.20201207032516-1f455d73275f/atc/exec/execfakes/fake_put_delegate.go (about) 1 // Code generated by counterfeiter. DO NOT EDIT. 2 package execfakes 3 4 import ( 5 "context" 6 "io" 7 "sync" 8 9 "code.cloudfoundry.org/lager" 10 "github.com/pf-qiu/concourse/v6/atc" 11 "github.com/pf-qiu/concourse/v6/atc/exec" 12 "github.com/pf-qiu/concourse/v6/atc/runtime" 13 "github.com/pf-qiu/concourse/v6/atc/worker" 14 "github.com/pf-qiu/concourse/v6/tracing" 15 "go.opentelemetry.io/otel/api/trace" 16 ) 17 18 type FakePutDelegate struct { 19 ErroredStub func(lager.Logger, string) 20 erroredMutex sync.RWMutex 21 erroredArgsForCall []struct { 22 arg1 lager.Logger 23 arg2 string 24 } 25 FetchImageStub func(context.Context, atc.ImageResource, atc.VersionedResourceTypes, bool) (worker.ImageSpec, error) 26 fetchImageMutex sync.RWMutex 27 fetchImageArgsForCall []struct { 28 arg1 context.Context 29 arg2 atc.ImageResource 30 arg3 atc.VersionedResourceTypes 31 arg4 bool 32 } 33 fetchImageReturns struct { 34 result1 worker.ImageSpec 35 result2 error 36 } 37 fetchImageReturnsOnCall map[int]struct { 38 result1 worker.ImageSpec 39 result2 error 40 } 41 FinishedStub func(lager.Logger, exec.ExitStatus, runtime.VersionResult) 42 finishedMutex sync.RWMutex 43 finishedArgsForCall []struct { 44 arg1 lager.Logger 45 arg2 exec.ExitStatus 46 arg3 runtime.VersionResult 47 } 48 InitializingStub func(lager.Logger) 49 initializingMutex sync.RWMutex 50 initializingArgsForCall []struct { 51 arg1 lager.Logger 52 } 53 SaveOutputStub func(lager.Logger, atc.PutPlan, atc.Source, atc.VersionedResourceTypes, runtime.VersionResult) 54 saveOutputMutex sync.RWMutex 55 saveOutputArgsForCall []struct { 56 arg1 lager.Logger 57 arg2 atc.PutPlan 58 arg3 atc.Source 59 arg4 atc.VersionedResourceTypes 60 arg5 runtime.VersionResult 61 } 62 SelectedWorkerStub func(lager.Logger, string) 63 selectedWorkerMutex sync.RWMutex 64 selectedWorkerArgsForCall []struct { 65 arg1 lager.Logger 66 arg2 string 67 } 68 StartSpanStub func(context.Context, string, tracing.Attrs) (context.Context, trace.Span) 69 startSpanMutex sync.RWMutex 70 startSpanArgsForCall []struct { 71 arg1 context.Context 72 arg2 string 73 arg3 tracing.Attrs 74 } 75 startSpanReturns struct { 76 result1 context.Context 77 result2 trace.Span 78 } 79 startSpanReturnsOnCall map[int]struct { 80 result1 context.Context 81 result2 trace.Span 82 } 83 StartingStub func(lager.Logger) 84 startingMutex sync.RWMutex 85 startingArgsForCall []struct { 86 arg1 lager.Logger 87 } 88 StderrStub func() io.Writer 89 stderrMutex sync.RWMutex 90 stderrArgsForCall []struct { 91 } 92 stderrReturns struct { 93 result1 io.Writer 94 } 95 stderrReturnsOnCall map[int]struct { 96 result1 io.Writer 97 } 98 StdoutStub func() io.Writer 99 stdoutMutex sync.RWMutex 100 stdoutArgsForCall []struct { 101 } 102 stdoutReturns struct { 103 result1 io.Writer 104 } 105 stdoutReturnsOnCall map[int]struct { 106 result1 io.Writer 107 } 108 invocations map[string][][]interface{} 109 invocationsMutex sync.RWMutex 110 } 111 112 func (fake *FakePutDelegate) Errored(arg1 lager.Logger, arg2 string) { 113 fake.erroredMutex.Lock() 114 fake.erroredArgsForCall = append(fake.erroredArgsForCall, struct { 115 arg1 lager.Logger 116 arg2 string 117 }{arg1, arg2}) 118 fake.recordInvocation("Errored", []interface{}{arg1, arg2}) 119 fake.erroredMutex.Unlock() 120 if fake.ErroredStub != nil { 121 fake.ErroredStub(arg1, arg2) 122 } 123 } 124 125 func (fake *FakePutDelegate) ErroredCallCount() int { 126 fake.erroredMutex.RLock() 127 defer fake.erroredMutex.RUnlock() 128 return len(fake.erroredArgsForCall) 129 } 130 131 func (fake *FakePutDelegate) ErroredCalls(stub func(lager.Logger, string)) { 132 fake.erroredMutex.Lock() 133 defer fake.erroredMutex.Unlock() 134 fake.ErroredStub = stub 135 } 136 137 func (fake *FakePutDelegate) ErroredArgsForCall(i int) (lager.Logger, string) { 138 fake.erroredMutex.RLock() 139 defer fake.erroredMutex.RUnlock() 140 argsForCall := fake.erroredArgsForCall[i] 141 return argsForCall.arg1, argsForCall.arg2 142 } 143 144 func (fake *FakePutDelegate) FetchImage(arg1 context.Context, arg2 atc.ImageResource, arg3 atc.VersionedResourceTypes, arg4 bool) (worker.ImageSpec, error) { 145 fake.fetchImageMutex.Lock() 146 ret, specificReturn := fake.fetchImageReturnsOnCall[len(fake.fetchImageArgsForCall)] 147 fake.fetchImageArgsForCall = append(fake.fetchImageArgsForCall, struct { 148 arg1 context.Context 149 arg2 atc.ImageResource 150 arg3 atc.VersionedResourceTypes 151 arg4 bool 152 }{arg1, arg2, arg3, arg4}) 153 fake.recordInvocation("FetchImage", []interface{}{arg1, arg2, arg3, arg4}) 154 fake.fetchImageMutex.Unlock() 155 if fake.FetchImageStub != nil { 156 return fake.FetchImageStub(arg1, arg2, arg3, arg4) 157 } 158 if specificReturn { 159 return ret.result1, ret.result2 160 } 161 fakeReturns := fake.fetchImageReturns 162 return fakeReturns.result1, fakeReturns.result2 163 } 164 165 func (fake *FakePutDelegate) FetchImageCallCount() int { 166 fake.fetchImageMutex.RLock() 167 defer fake.fetchImageMutex.RUnlock() 168 return len(fake.fetchImageArgsForCall) 169 } 170 171 func (fake *FakePutDelegate) FetchImageCalls(stub func(context.Context, atc.ImageResource, atc.VersionedResourceTypes, bool) (worker.ImageSpec, error)) { 172 fake.fetchImageMutex.Lock() 173 defer fake.fetchImageMutex.Unlock() 174 fake.FetchImageStub = stub 175 } 176 177 func (fake *FakePutDelegate) FetchImageArgsForCall(i int) (context.Context, atc.ImageResource, atc.VersionedResourceTypes, bool) { 178 fake.fetchImageMutex.RLock() 179 defer fake.fetchImageMutex.RUnlock() 180 argsForCall := fake.fetchImageArgsForCall[i] 181 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 182 } 183 184 func (fake *FakePutDelegate) FetchImageReturns(result1 worker.ImageSpec, result2 error) { 185 fake.fetchImageMutex.Lock() 186 defer fake.fetchImageMutex.Unlock() 187 fake.FetchImageStub = nil 188 fake.fetchImageReturns = struct { 189 result1 worker.ImageSpec 190 result2 error 191 }{result1, result2} 192 } 193 194 func (fake *FakePutDelegate) FetchImageReturnsOnCall(i int, result1 worker.ImageSpec, result2 error) { 195 fake.fetchImageMutex.Lock() 196 defer fake.fetchImageMutex.Unlock() 197 fake.FetchImageStub = nil 198 if fake.fetchImageReturnsOnCall == nil { 199 fake.fetchImageReturnsOnCall = make(map[int]struct { 200 result1 worker.ImageSpec 201 result2 error 202 }) 203 } 204 fake.fetchImageReturnsOnCall[i] = struct { 205 result1 worker.ImageSpec 206 result2 error 207 }{result1, result2} 208 } 209 210 func (fake *FakePutDelegate) Finished(arg1 lager.Logger, arg2 exec.ExitStatus, arg3 runtime.VersionResult) { 211 fake.finishedMutex.Lock() 212 fake.finishedArgsForCall = append(fake.finishedArgsForCall, struct { 213 arg1 lager.Logger 214 arg2 exec.ExitStatus 215 arg3 runtime.VersionResult 216 }{arg1, arg2, arg3}) 217 fake.recordInvocation("Finished", []interface{}{arg1, arg2, arg3}) 218 fake.finishedMutex.Unlock() 219 if fake.FinishedStub != nil { 220 fake.FinishedStub(arg1, arg2, arg3) 221 } 222 } 223 224 func (fake *FakePutDelegate) FinishedCallCount() int { 225 fake.finishedMutex.RLock() 226 defer fake.finishedMutex.RUnlock() 227 return len(fake.finishedArgsForCall) 228 } 229 230 func (fake *FakePutDelegate) FinishedCalls(stub func(lager.Logger, exec.ExitStatus, runtime.VersionResult)) { 231 fake.finishedMutex.Lock() 232 defer fake.finishedMutex.Unlock() 233 fake.FinishedStub = stub 234 } 235 236 func (fake *FakePutDelegate) FinishedArgsForCall(i int) (lager.Logger, exec.ExitStatus, runtime.VersionResult) { 237 fake.finishedMutex.RLock() 238 defer fake.finishedMutex.RUnlock() 239 argsForCall := fake.finishedArgsForCall[i] 240 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 241 } 242 243 func (fake *FakePutDelegate) Initializing(arg1 lager.Logger) { 244 fake.initializingMutex.Lock() 245 fake.initializingArgsForCall = append(fake.initializingArgsForCall, struct { 246 arg1 lager.Logger 247 }{arg1}) 248 fake.recordInvocation("Initializing", []interface{}{arg1}) 249 fake.initializingMutex.Unlock() 250 if fake.InitializingStub != nil { 251 fake.InitializingStub(arg1) 252 } 253 } 254 255 func (fake *FakePutDelegate) InitializingCallCount() int { 256 fake.initializingMutex.RLock() 257 defer fake.initializingMutex.RUnlock() 258 return len(fake.initializingArgsForCall) 259 } 260 261 func (fake *FakePutDelegate) InitializingCalls(stub func(lager.Logger)) { 262 fake.initializingMutex.Lock() 263 defer fake.initializingMutex.Unlock() 264 fake.InitializingStub = stub 265 } 266 267 func (fake *FakePutDelegate) InitializingArgsForCall(i int) lager.Logger { 268 fake.initializingMutex.RLock() 269 defer fake.initializingMutex.RUnlock() 270 argsForCall := fake.initializingArgsForCall[i] 271 return argsForCall.arg1 272 } 273 274 func (fake *FakePutDelegate) SaveOutput(arg1 lager.Logger, arg2 atc.PutPlan, arg3 atc.Source, arg4 atc.VersionedResourceTypes, arg5 runtime.VersionResult) { 275 fake.saveOutputMutex.Lock() 276 fake.saveOutputArgsForCall = append(fake.saveOutputArgsForCall, struct { 277 arg1 lager.Logger 278 arg2 atc.PutPlan 279 arg3 atc.Source 280 arg4 atc.VersionedResourceTypes 281 arg5 runtime.VersionResult 282 }{arg1, arg2, arg3, arg4, arg5}) 283 fake.recordInvocation("SaveOutput", []interface{}{arg1, arg2, arg3, arg4, arg5}) 284 fake.saveOutputMutex.Unlock() 285 if fake.SaveOutputStub != nil { 286 fake.SaveOutputStub(arg1, arg2, arg3, arg4, arg5) 287 } 288 } 289 290 func (fake *FakePutDelegate) SaveOutputCallCount() int { 291 fake.saveOutputMutex.RLock() 292 defer fake.saveOutputMutex.RUnlock() 293 return len(fake.saveOutputArgsForCall) 294 } 295 296 func (fake *FakePutDelegate) SaveOutputCalls(stub func(lager.Logger, atc.PutPlan, atc.Source, atc.VersionedResourceTypes, runtime.VersionResult)) { 297 fake.saveOutputMutex.Lock() 298 defer fake.saveOutputMutex.Unlock() 299 fake.SaveOutputStub = stub 300 } 301 302 func (fake *FakePutDelegate) SaveOutputArgsForCall(i int) (lager.Logger, atc.PutPlan, atc.Source, atc.VersionedResourceTypes, runtime.VersionResult) { 303 fake.saveOutputMutex.RLock() 304 defer fake.saveOutputMutex.RUnlock() 305 argsForCall := fake.saveOutputArgsForCall[i] 306 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 307 } 308 309 func (fake *FakePutDelegate) SelectedWorker(arg1 lager.Logger, arg2 string) { 310 fake.selectedWorkerMutex.Lock() 311 fake.selectedWorkerArgsForCall = append(fake.selectedWorkerArgsForCall, struct { 312 arg1 lager.Logger 313 arg2 string 314 }{arg1, arg2}) 315 fake.recordInvocation("SelectedWorker", []interface{}{arg1, arg2}) 316 fake.selectedWorkerMutex.Unlock() 317 if fake.SelectedWorkerStub != nil { 318 fake.SelectedWorkerStub(arg1, arg2) 319 } 320 } 321 322 func (fake *FakePutDelegate) SelectedWorkerCallCount() int { 323 fake.selectedWorkerMutex.RLock() 324 defer fake.selectedWorkerMutex.RUnlock() 325 return len(fake.selectedWorkerArgsForCall) 326 } 327 328 func (fake *FakePutDelegate) SelectedWorkerCalls(stub func(lager.Logger, string)) { 329 fake.selectedWorkerMutex.Lock() 330 defer fake.selectedWorkerMutex.Unlock() 331 fake.SelectedWorkerStub = stub 332 } 333 334 func (fake *FakePutDelegate) SelectedWorkerArgsForCall(i int) (lager.Logger, string) { 335 fake.selectedWorkerMutex.RLock() 336 defer fake.selectedWorkerMutex.RUnlock() 337 argsForCall := fake.selectedWorkerArgsForCall[i] 338 return argsForCall.arg1, argsForCall.arg2 339 } 340 341 func (fake *FakePutDelegate) StartSpan(arg1 context.Context, arg2 string, arg3 tracing.Attrs) (context.Context, trace.Span) { 342 fake.startSpanMutex.Lock() 343 ret, specificReturn := fake.startSpanReturnsOnCall[len(fake.startSpanArgsForCall)] 344 fake.startSpanArgsForCall = append(fake.startSpanArgsForCall, struct { 345 arg1 context.Context 346 arg2 string 347 arg3 tracing.Attrs 348 }{arg1, arg2, arg3}) 349 fake.recordInvocation("StartSpan", []interface{}{arg1, arg2, arg3}) 350 fake.startSpanMutex.Unlock() 351 if fake.StartSpanStub != nil { 352 return fake.StartSpanStub(arg1, arg2, arg3) 353 } 354 if specificReturn { 355 return ret.result1, ret.result2 356 } 357 fakeReturns := fake.startSpanReturns 358 return fakeReturns.result1, fakeReturns.result2 359 } 360 361 func (fake *FakePutDelegate) StartSpanCallCount() int { 362 fake.startSpanMutex.RLock() 363 defer fake.startSpanMutex.RUnlock() 364 return len(fake.startSpanArgsForCall) 365 } 366 367 func (fake *FakePutDelegate) StartSpanCalls(stub func(context.Context, string, tracing.Attrs) (context.Context, trace.Span)) { 368 fake.startSpanMutex.Lock() 369 defer fake.startSpanMutex.Unlock() 370 fake.StartSpanStub = stub 371 } 372 373 func (fake *FakePutDelegate) StartSpanArgsForCall(i int) (context.Context, string, tracing.Attrs) { 374 fake.startSpanMutex.RLock() 375 defer fake.startSpanMutex.RUnlock() 376 argsForCall := fake.startSpanArgsForCall[i] 377 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 378 } 379 380 func (fake *FakePutDelegate) StartSpanReturns(result1 context.Context, result2 trace.Span) { 381 fake.startSpanMutex.Lock() 382 defer fake.startSpanMutex.Unlock() 383 fake.StartSpanStub = nil 384 fake.startSpanReturns = struct { 385 result1 context.Context 386 result2 trace.Span 387 }{result1, result2} 388 } 389 390 func (fake *FakePutDelegate) StartSpanReturnsOnCall(i int, result1 context.Context, result2 trace.Span) { 391 fake.startSpanMutex.Lock() 392 defer fake.startSpanMutex.Unlock() 393 fake.StartSpanStub = nil 394 if fake.startSpanReturnsOnCall == nil { 395 fake.startSpanReturnsOnCall = make(map[int]struct { 396 result1 context.Context 397 result2 trace.Span 398 }) 399 } 400 fake.startSpanReturnsOnCall[i] = struct { 401 result1 context.Context 402 result2 trace.Span 403 }{result1, result2} 404 } 405 406 func (fake *FakePutDelegate) Starting(arg1 lager.Logger) { 407 fake.startingMutex.Lock() 408 fake.startingArgsForCall = append(fake.startingArgsForCall, struct { 409 arg1 lager.Logger 410 }{arg1}) 411 fake.recordInvocation("Starting", []interface{}{arg1}) 412 fake.startingMutex.Unlock() 413 if fake.StartingStub != nil { 414 fake.StartingStub(arg1) 415 } 416 } 417 418 func (fake *FakePutDelegate) StartingCallCount() int { 419 fake.startingMutex.RLock() 420 defer fake.startingMutex.RUnlock() 421 return len(fake.startingArgsForCall) 422 } 423 424 func (fake *FakePutDelegate) StartingCalls(stub func(lager.Logger)) { 425 fake.startingMutex.Lock() 426 defer fake.startingMutex.Unlock() 427 fake.StartingStub = stub 428 } 429 430 func (fake *FakePutDelegate) StartingArgsForCall(i int) lager.Logger { 431 fake.startingMutex.RLock() 432 defer fake.startingMutex.RUnlock() 433 argsForCall := fake.startingArgsForCall[i] 434 return argsForCall.arg1 435 } 436 437 func (fake *FakePutDelegate) Stderr() io.Writer { 438 fake.stderrMutex.Lock() 439 ret, specificReturn := fake.stderrReturnsOnCall[len(fake.stderrArgsForCall)] 440 fake.stderrArgsForCall = append(fake.stderrArgsForCall, struct { 441 }{}) 442 fake.recordInvocation("Stderr", []interface{}{}) 443 fake.stderrMutex.Unlock() 444 if fake.StderrStub != nil { 445 return fake.StderrStub() 446 } 447 if specificReturn { 448 return ret.result1 449 } 450 fakeReturns := fake.stderrReturns 451 return fakeReturns.result1 452 } 453 454 func (fake *FakePutDelegate) StderrCallCount() int { 455 fake.stderrMutex.RLock() 456 defer fake.stderrMutex.RUnlock() 457 return len(fake.stderrArgsForCall) 458 } 459 460 func (fake *FakePutDelegate) StderrCalls(stub func() io.Writer) { 461 fake.stderrMutex.Lock() 462 defer fake.stderrMutex.Unlock() 463 fake.StderrStub = stub 464 } 465 466 func (fake *FakePutDelegate) StderrReturns(result1 io.Writer) { 467 fake.stderrMutex.Lock() 468 defer fake.stderrMutex.Unlock() 469 fake.StderrStub = nil 470 fake.stderrReturns = struct { 471 result1 io.Writer 472 }{result1} 473 } 474 475 func (fake *FakePutDelegate) StderrReturnsOnCall(i int, result1 io.Writer) { 476 fake.stderrMutex.Lock() 477 defer fake.stderrMutex.Unlock() 478 fake.StderrStub = nil 479 if fake.stderrReturnsOnCall == nil { 480 fake.stderrReturnsOnCall = make(map[int]struct { 481 result1 io.Writer 482 }) 483 } 484 fake.stderrReturnsOnCall[i] = struct { 485 result1 io.Writer 486 }{result1} 487 } 488 489 func (fake *FakePutDelegate) Stdout() io.Writer { 490 fake.stdoutMutex.Lock() 491 ret, specificReturn := fake.stdoutReturnsOnCall[len(fake.stdoutArgsForCall)] 492 fake.stdoutArgsForCall = append(fake.stdoutArgsForCall, struct { 493 }{}) 494 fake.recordInvocation("Stdout", []interface{}{}) 495 fake.stdoutMutex.Unlock() 496 if fake.StdoutStub != nil { 497 return fake.StdoutStub() 498 } 499 if specificReturn { 500 return ret.result1 501 } 502 fakeReturns := fake.stdoutReturns 503 return fakeReturns.result1 504 } 505 506 func (fake *FakePutDelegate) StdoutCallCount() int { 507 fake.stdoutMutex.RLock() 508 defer fake.stdoutMutex.RUnlock() 509 return len(fake.stdoutArgsForCall) 510 } 511 512 func (fake *FakePutDelegate) StdoutCalls(stub func() io.Writer) { 513 fake.stdoutMutex.Lock() 514 defer fake.stdoutMutex.Unlock() 515 fake.StdoutStub = stub 516 } 517 518 func (fake *FakePutDelegate) StdoutReturns(result1 io.Writer) { 519 fake.stdoutMutex.Lock() 520 defer fake.stdoutMutex.Unlock() 521 fake.StdoutStub = nil 522 fake.stdoutReturns = struct { 523 result1 io.Writer 524 }{result1} 525 } 526 527 func (fake *FakePutDelegate) StdoutReturnsOnCall(i int, result1 io.Writer) { 528 fake.stdoutMutex.Lock() 529 defer fake.stdoutMutex.Unlock() 530 fake.StdoutStub = nil 531 if fake.stdoutReturnsOnCall == nil { 532 fake.stdoutReturnsOnCall = make(map[int]struct { 533 result1 io.Writer 534 }) 535 } 536 fake.stdoutReturnsOnCall[i] = struct { 537 result1 io.Writer 538 }{result1} 539 } 540 541 func (fake *FakePutDelegate) Invocations() map[string][][]interface{} { 542 fake.invocationsMutex.RLock() 543 defer fake.invocationsMutex.RUnlock() 544 fake.erroredMutex.RLock() 545 defer fake.erroredMutex.RUnlock() 546 fake.fetchImageMutex.RLock() 547 defer fake.fetchImageMutex.RUnlock() 548 fake.finishedMutex.RLock() 549 defer fake.finishedMutex.RUnlock() 550 fake.initializingMutex.RLock() 551 defer fake.initializingMutex.RUnlock() 552 fake.saveOutputMutex.RLock() 553 defer fake.saveOutputMutex.RUnlock() 554 fake.selectedWorkerMutex.RLock() 555 defer fake.selectedWorkerMutex.RUnlock() 556 fake.startSpanMutex.RLock() 557 defer fake.startSpanMutex.RUnlock() 558 fake.startingMutex.RLock() 559 defer fake.startingMutex.RUnlock() 560 fake.stderrMutex.RLock() 561 defer fake.stderrMutex.RUnlock() 562 fake.stdoutMutex.RLock() 563 defer fake.stdoutMutex.RUnlock() 564 copiedInvocations := map[string][][]interface{}{} 565 for key, value := range fake.invocations { 566 copiedInvocations[key] = value 567 } 568 return copiedInvocations 569 } 570 571 func (fake *FakePutDelegate) recordInvocation(key string, args []interface{}) { 572 fake.invocationsMutex.Lock() 573 defer fake.invocationsMutex.Unlock() 574 if fake.invocations == nil { 575 fake.invocations = map[string][][]interface{}{} 576 } 577 if fake.invocations[key] == nil { 578 fake.invocations[key] = [][]interface{}{} 579 } 580 fake.invocations[key] = append(fake.invocations[key], args) 581 } 582 583 var _ exec.PutDelegate = new(FakePutDelegate)