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