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