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