1// Code generated by counterfeiter. DO NOT EDIT. 2package dbfakes 3 4import ( 5 "sync" 6 "time" 7 8 "code.cloudfoundry.org/lager" 9 "github.com/concourse/concourse/atc" 10 "github.com/concourse/concourse/atc/creds" 11 "github.com/concourse/concourse/atc/db" 12) 13 14type FakeTeam struct { 15 AdminStub func() bool 16 adminMutex sync.RWMutex 17 adminArgsForCall []struct { 18 } 19 adminReturns struct { 20 result1 bool 21 } 22 adminReturnsOnCall map[int]struct { 23 result1 bool 24 } 25 AuthStub func() atc.TeamAuth 26 authMutex sync.RWMutex 27 authArgsForCall []struct { 28 } 29 authReturns struct { 30 result1 atc.TeamAuth 31 } 32 authReturnsOnCall map[int]struct { 33 result1 atc.TeamAuth 34 } 35 BuildsStub func(db.Page) ([]db.Build, db.Pagination, error) 36 buildsMutex sync.RWMutex 37 buildsArgsForCall []struct { 38 arg1 db.Page 39 } 40 buildsReturns struct { 41 result1 []db.Build 42 result2 db.Pagination 43 result3 error 44 } 45 buildsReturnsOnCall map[int]struct { 46 result1 []db.Build 47 result2 db.Pagination 48 result3 error 49 } 50 BuildsWithTimeStub func(db.Page) ([]db.Build, db.Pagination, error) 51 buildsWithTimeMutex sync.RWMutex 52 buildsWithTimeArgsForCall []struct { 53 arg1 db.Page 54 } 55 buildsWithTimeReturns struct { 56 result1 []db.Build 57 result2 db.Pagination 58 result3 error 59 } 60 buildsWithTimeReturnsOnCall map[int]struct { 61 result1 []db.Build 62 result2 db.Pagination 63 result3 error 64 } 65 ContainersStub func() ([]db.Container, error) 66 containersMutex sync.RWMutex 67 containersArgsForCall []struct { 68 } 69 containersReturns struct { 70 result1 []db.Container 71 result2 error 72 } 73 containersReturnsOnCall map[int]struct { 74 result1 []db.Container 75 result2 error 76 } 77 CreateOneOffBuildStub func() (db.Build, error) 78 createOneOffBuildMutex sync.RWMutex 79 createOneOffBuildArgsForCall []struct { 80 } 81 createOneOffBuildReturns struct { 82 result1 db.Build 83 result2 error 84 } 85 createOneOffBuildReturnsOnCall map[int]struct { 86 result1 db.Build 87 result2 error 88 } 89 CreateStartedBuildStub func(atc.Plan) (db.Build, error) 90 createStartedBuildMutex sync.RWMutex 91 createStartedBuildArgsForCall []struct { 92 arg1 atc.Plan 93 } 94 createStartedBuildReturns struct { 95 result1 db.Build 96 result2 error 97 } 98 createStartedBuildReturnsOnCall map[int]struct { 99 result1 db.Build 100 result2 error 101 } 102 DeleteStub func() error 103 deleteMutex sync.RWMutex 104 deleteArgsForCall []struct { 105 } 106 deleteReturns struct { 107 result1 error 108 } 109 deleteReturnsOnCall map[int]struct { 110 result1 error 111 } 112 FindCheckContainersStub func(lager.Logger, string, string, creds.Secrets, creds.VarSourcePool) ([]db.Container, map[int]time.Time, error) 113 findCheckContainersMutex sync.RWMutex 114 findCheckContainersArgsForCall []struct { 115 arg1 lager.Logger 116 arg2 string 117 arg3 string 118 arg4 creds.Secrets 119 arg5 creds.VarSourcePool 120 } 121 findCheckContainersReturns struct { 122 result1 []db.Container 123 result2 map[int]time.Time 124 result3 error 125 } 126 findCheckContainersReturnsOnCall map[int]struct { 127 result1 []db.Container 128 result2 map[int]time.Time 129 result3 error 130 } 131 FindContainerByHandleStub func(string) (db.Container, bool, error) 132 findContainerByHandleMutex sync.RWMutex 133 findContainerByHandleArgsForCall []struct { 134 arg1 string 135 } 136 findContainerByHandleReturns struct { 137 result1 db.Container 138 result2 bool 139 result3 error 140 } 141 findContainerByHandleReturnsOnCall map[int]struct { 142 result1 db.Container 143 result2 bool 144 result3 error 145 } 146 FindContainersByMetadataStub func(db.ContainerMetadata) ([]db.Container, error) 147 findContainersByMetadataMutex sync.RWMutex 148 findContainersByMetadataArgsForCall []struct { 149 arg1 db.ContainerMetadata 150 } 151 findContainersByMetadataReturns struct { 152 result1 []db.Container 153 result2 error 154 } 155 findContainersByMetadataReturnsOnCall map[int]struct { 156 result1 []db.Container 157 result2 error 158 } 159 FindCreatedContainerByHandleStub func(string) (db.CreatedContainer, bool, error) 160 findCreatedContainerByHandleMutex sync.RWMutex 161 findCreatedContainerByHandleArgsForCall []struct { 162 arg1 string 163 } 164 findCreatedContainerByHandleReturns struct { 165 result1 db.CreatedContainer 166 result2 bool 167 result3 error 168 } 169 findCreatedContainerByHandleReturnsOnCall map[int]struct { 170 result1 db.CreatedContainer 171 result2 bool 172 result3 error 173 } 174 FindVolumeForWorkerArtifactStub func(int) (db.CreatedVolume, bool, error) 175 findVolumeForWorkerArtifactMutex sync.RWMutex 176 findVolumeForWorkerArtifactArgsForCall []struct { 177 arg1 int 178 } 179 findVolumeForWorkerArtifactReturns struct { 180 result1 db.CreatedVolume 181 result2 bool 182 result3 error 183 } 184 findVolumeForWorkerArtifactReturnsOnCall map[int]struct { 185 result1 db.CreatedVolume 186 result2 bool 187 result3 error 188 } 189 FindWorkerForContainerStub func(string) (db.Worker, bool, error) 190 findWorkerForContainerMutex sync.RWMutex 191 findWorkerForContainerArgsForCall []struct { 192 arg1 string 193 } 194 findWorkerForContainerReturns struct { 195 result1 db.Worker 196 result2 bool 197 result3 error 198 } 199 findWorkerForContainerReturnsOnCall map[int]struct { 200 result1 db.Worker 201 result2 bool 202 result3 error 203 } 204 FindWorkerForVolumeStub func(string) (db.Worker, bool, error) 205 findWorkerForVolumeMutex sync.RWMutex 206 findWorkerForVolumeArgsForCall []struct { 207 arg1 string 208 } 209 findWorkerForVolumeReturns struct { 210 result1 db.Worker 211 result2 bool 212 result3 error 213 } 214 findWorkerForVolumeReturnsOnCall map[int]struct { 215 result1 db.Worker 216 result2 bool 217 result3 error 218 } 219 IDStub func() int 220 iDMutex sync.RWMutex 221 iDArgsForCall []struct { 222 } 223 iDReturns struct { 224 result1 int 225 } 226 iDReturnsOnCall map[int]struct { 227 result1 int 228 } 229 IsCheckContainerStub func(string) (bool, error) 230 isCheckContainerMutex sync.RWMutex 231 isCheckContainerArgsForCall []struct { 232 arg1 string 233 } 234 isCheckContainerReturns struct { 235 result1 bool 236 result2 error 237 } 238 isCheckContainerReturnsOnCall map[int]struct { 239 result1 bool 240 result2 error 241 } 242 IsContainerWithinTeamStub func(string, bool) (bool, error) 243 isContainerWithinTeamMutex sync.RWMutex 244 isContainerWithinTeamArgsForCall []struct { 245 arg1 string 246 arg2 bool 247 } 248 isContainerWithinTeamReturns struct { 249 result1 bool 250 result2 error 251 } 252 isContainerWithinTeamReturnsOnCall map[int]struct { 253 result1 bool 254 result2 error 255 } 256 NameStub func() string 257 nameMutex sync.RWMutex 258 nameArgsForCall []struct { 259 } 260 nameReturns struct { 261 result1 string 262 } 263 nameReturnsOnCall map[int]struct { 264 result1 string 265 } 266 OrderPipelinesStub func([]string) error 267 orderPipelinesMutex sync.RWMutex 268 orderPipelinesArgsForCall []struct { 269 arg1 []string 270 } 271 orderPipelinesReturns struct { 272 result1 error 273 } 274 orderPipelinesReturnsOnCall map[int]struct { 275 result1 error 276 } 277 PipelineStub func(string) (db.Pipeline, bool, error) 278 pipelineMutex sync.RWMutex 279 pipelineArgsForCall []struct { 280 arg1 string 281 } 282 pipelineReturns struct { 283 result1 db.Pipeline 284 result2 bool 285 result3 error 286 } 287 pipelineReturnsOnCall map[int]struct { 288 result1 db.Pipeline 289 result2 bool 290 result3 error 291 } 292 PipelinesStub func() ([]db.Pipeline, error) 293 pipelinesMutex sync.RWMutex 294 pipelinesArgsForCall []struct { 295 } 296 pipelinesReturns struct { 297 result1 []db.Pipeline 298 result2 error 299 } 300 pipelinesReturnsOnCall map[int]struct { 301 result1 []db.Pipeline 302 result2 error 303 } 304 PrivateAndPublicBuildsStub func(db.Page) ([]db.Build, db.Pagination, error) 305 privateAndPublicBuildsMutex sync.RWMutex 306 privateAndPublicBuildsArgsForCall []struct { 307 arg1 db.Page 308 } 309 privateAndPublicBuildsReturns struct { 310 result1 []db.Build 311 result2 db.Pagination 312 result3 error 313 } 314 privateAndPublicBuildsReturnsOnCall map[int]struct { 315 result1 []db.Build 316 result2 db.Pagination 317 result3 error 318 } 319 PublicPipelinesStub func() ([]db.Pipeline, error) 320 publicPipelinesMutex sync.RWMutex 321 publicPipelinesArgsForCall []struct { 322 } 323 publicPipelinesReturns struct { 324 result1 []db.Pipeline 325 result2 error 326 } 327 publicPipelinesReturnsOnCall map[int]struct { 328 result1 []db.Pipeline 329 result2 error 330 } 331 RenameStub func(string) error 332 renameMutex sync.RWMutex 333 renameArgsForCall []struct { 334 arg1 string 335 } 336 renameReturns struct { 337 result1 error 338 } 339 renameReturnsOnCall map[int]struct { 340 result1 error 341 } 342 SavePipelineStub func(string, atc.Config, db.ConfigVersion, bool) (db.Pipeline, bool, error) 343 savePipelineMutex sync.RWMutex 344 savePipelineArgsForCall []struct { 345 arg1 string 346 arg2 atc.Config 347 arg3 db.ConfigVersion 348 arg4 bool 349 } 350 savePipelineReturns struct { 351 result1 db.Pipeline 352 result2 bool 353 result3 error 354 } 355 savePipelineReturnsOnCall map[int]struct { 356 result1 db.Pipeline 357 result2 bool 358 result3 error 359 } 360 SaveWorkerStub func(atc.Worker, time.Duration) (db.Worker, error) 361 saveWorkerMutex sync.RWMutex 362 saveWorkerArgsForCall []struct { 363 arg1 atc.Worker 364 arg2 time.Duration 365 } 366 saveWorkerReturns struct { 367 result1 db.Worker 368 result2 error 369 } 370 saveWorkerReturnsOnCall map[int]struct { 371 result1 db.Worker 372 result2 error 373 } 374 UpdateProviderAuthStub func(atc.TeamAuth) error 375 updateProviderAuthMutex sync.RWMutex 376 updateProviderAuthArgsForCall []struct { 377 arg1 atc.TeamAuth 378 } 379 updateProviderAuthReturns struct { 380 result1 error 381 } 382 updateProviderAuthReturnsOnCall map[int]struct { 383 result1 error 384 } 385 WorkersStub func() ([]db.Worker, error) 386 workersMutex sync.RWMutex 387 workersArgsForCall []struct { 388 } 389 workersReturns struct { 390 result1 []db.Worker 391 result2 error 392 } 393 workersReturnsOnCall map[int]struct { 394 result1 []db.Worker 395 result2 error 396 } 397 invocations map[string][][]interface{} 398 invocationsMutex sync.RWMutex 399} 400 401func (fake *FakeTeam) Admin() bool { 402 fake.adminMutex.Lock() 403 ret, specificReturn := fake.adminReturnsOnCall[len(fake.adminArgsForCall)] 404 fake.adminArgsForCall = append(fake.adminArgsForCall, struct { 405 }{}) 406 fake.recordInvocation("Admin", []interface{}{}) 407 fake.adminMutex.Unlock() 408 if fake.AdminStub != nil { 409 return fake.AdminStub() 410 } 411 if specificReturn { 412 return ret.result1 413 } 414 fakeReturns := fake.adminReturns 415 return fakeReturns.result1 416} 417 418func (fake *FakeTeam) AdminCallCount() int { 419 fake.adminMutex.RLock() 420 defer fake.adminMutex.RUnlock() 421 return len(fake.adminArgsForCall) 422} 423 424func (fake *FakeTeam) AdminCalls(stub func() bool) { 425 fake.adminMutex.Lock() 426 defer fake.adminMutex.Unlock() 427 fake.AdminStub = stub 428} 429 430func (fake *FakeTeam) AdminReturns(result1 bool) { 431 fake.adminMutex.Lock() 432 defer fake.adminMutex.Unlock() 433 fake.AdminStub = nil 434 fake.adminReturns = struct { 435 result1 bool 436 }{result1} 437} 438 439func (fake *FakeTeam) AdminReturnsOnCall(i int, result1 bool) { 440 fake.adminMutex.Lock() 441 defer fake.adminMutex.Unlock() 442 fake.AdminStub = nil 443 if fake.adminReturnsOnCall == nil { 444 fake.adminReturnsOnCall = make(map[int]struct { 445 result1 bool 446 }) 447 } 448 fake.adminReturnsOnCall[i] = struct { 449 result1 bool 450 }{result1} 451} 452 453func (fake *FakeTeam) Auth() atc.TeamAuth { 454 fake.authMutex.Lock() 455 ret, specificReturn := fake.authReturnsOnCall[len(fake.authArgsForCall)] 456 fake.authArgsForCall = append(fake.authArgsForCall, struct { 457 }{}) 458 fake.recordInvocation("Auth", []interface{}{}) 459 fake.authMutex.Unlock() 460 if fake.AuthStub != nil { 461 return fake.AuthStub() 462 } 463 if specificReturn { 464 return ret.result1 465 } 466 fakeReturns := fake.authReturns 467 return fakeReturns.result1 468} 469 470func (fake *FakeTeam) AuthCallCount() int { 471 fake.authMutex.RLock() 472 defer fake.authMutex.RUnlock() 473 return len(fake.authArgsForCall) 474} 475 476func (fake *FakeTeam) AuthCalls(stub func() atc.TeamAuth) { 477 fake.authMutex.Lock() 478 defer fake.authMutex.Unlock() 479 fake.AuthStub = stub 480} 481 482func (fake *FakeTeam) AuthReturns(result1 atc.TeamAuth) { 483 fake.authMutex.Lock() 484 defer fake.authMutex.Unlock() 485 fake.AuthStub = nil 486 fake.authReturns = struct { 487 result1 atc.TeamAuth 488 }{result1} 489} 490 491func (fake *FakeTeam) AuthReturnsOnCall(i int, result1 atc.TeamAuth) { 492 fake.authMutex.Lock() 493 defer fake.authMutex.Unlock() 494 fake.AuthStub = nil 495 if fake.authReturnsOnCall == nil { 496 fake.authReturnsOnCall = make(map[int]struct { 497 result1 atc.TeamAuth 498 }) 499 } 500 fake.authReturnsOnCall[i] = struct { 501 result1 atc.TeamAuth 502 }{result1} 503} 504 505func (fake *FakeTeam) Builds(arg1 db.Page) ([]db.Build, db.Pagination, error) { 506 fake.buildsMutex.Lock() 507 ret, specificReturn := fake.buildsReturnsOnCall[len(fake.buildsArgsForCall)] 508 fake.buildsArgsForCall = append(fake.buildsArgsForCall, struct { 509 arg1 db.Page 510 }{arg1}) 511 fake.recordInvocation("Builds", []interface{}{arg1}) 512 fake.buildsMutex.Unlock() 513 if fake.BuildsStub != nil { 514 return fake.BuildsStub(arg1) 515 } 516 if specificReturn { 517 return ret.result1, ret.result2, ret.result3 518 } 519 fakeReturns := fake.buildsReturns 520 return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 521} 522 523func (fake *FakeTeam) BuildsCallCount() int { 524 fake.buildsMutex.RLock() 525 defer fake.buildsMutex.RUnlock() 526 return len(fake.buildsArgsForCall) 527} 528 529func (fake *FakeTeam) BuildsCalls(stub func(db.Page) ([]db.Build, db.Pagination, error)) { 530 fake.buildsMutex.Lock() 531 defer fake.buildsMutex.Unlock() 532 fake.BuildsStub = stub 533} 534 535func (fake *FakeTeam) BuildsArgsForCall(i int) db.Page { 536 fake.buildsMutex.RLock() 537 defer fake.buildsMutex.RUnlock() 538 argsForCall := fake.buildsArgsForCall[i] 539 return argsForCall.arg1 540} 541 542func (fake *FakeTeam) BuildsReturns(result1 []db.Build, result2 db.Pagination, result3 error) { 543 fake.buildsMutex.Lock() 544 defer fake.buildsMutex.Unlock() 545 fake.BuildsStub = nil 546 fake.buildsReturns = struct { 547 result1 []db.Build 548 result2 db.Pagination 549 result3 error 550 }{result1, result2, result3} 551} 552 553func (fake *FakeTeam) BuildsReturnsOnCall(i int, result1 []db.Build, result2 db.Pagination, result3 error) { 554 fake.buildsMutex.Lock() 555 defer fake.buildsMutex.Unlock() 556 fake.BuildsStub = nil 557 if fake.buildsReturnsOnCall == nil { 558 fake.buildsReturnsOnCall = make(map[int]struct { 559 result1 []db.Build 560 result2 db.Pagination 561 result3 error 562 }) 563 } 564 fake.buildsReturnsOnCall[i] = struct { 565 result1 []db.Build 566 result2 db.Pagination 567 result3 error 568 }{result1, result2, result3} 569} 570 571func (fake *FakeTeam) BuildsWithTime(arg1 db.Page) ([]db.Build, db.Pagination, error) { 572 fake.buildsWithTimeMutex.Lock() 573 ret, specificReturn := fake.buildsWithTimeReturnsOnCall[len(fake.buildsWithTimeArgsForCall)] 574 fake.buildsWithTimeArgsForCall = append(fake.buildsWithTimeArgsForCall, struct { 575 arg1 db.Page 576 }{arg1}) 577 fake.recordInvocation("BuildsWithTime", []interface{}{arg1}) 578 fake.buildsWithTimeMutex.Unlock() 579 if fake.BuildsWithTimeStub != nil { 580 return fake.BuildsWithTimeStub(arg1) 581 } 582 if specificReturn { 583 return ret.result1, ret.result2, ret.result3 584 } 585 fakeReturns := fake.buildsWithTimeReturns 586 return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 587} 588 589func (fake *FakeTeam) BuildsWithTimeCallCount() int { 590 fake.buildsWithTimeMutex.RLock() 591 defer fake.buildsWithTimeMutex.RUnlock() 592 return len(fake.buildsWithTimeArgsForCall) 593} 594 595func (fake *FakeTeam) BuildsWithTimeCalls(stub func(db.Page) ([]db.Build, db.Pagination, error)) { 596 fake.buildsWithTimeMutex.Lock() 597 defer fake.buildsWithTimeMutex.Unlock() 598 fake.BuildsWithTimeStub = stub 599} 600 601func (fake *FakeTeam) BuildsWithTimeArgsForCall(i int) db.Page { 602 fake.buildsWithTimeMutex.RLock() 603 defer fake.buildsWithTimeMutex.RUnlock() 604 argsForCall := fake.buildsWithTimeArgsForCall[i] 605 return argsForCall.arg1 606} 607 608func (fake *FakeTeam) BuildsWithTimeReturns(result1 []db.Build, result2 db.Pagination, result3 error) { 609 fake.buildsWithTimeMutex.Lock() 610 defer fake.buildsWithTimeMutex.Unlock() 611 fake.BuildsWithTimeStub = nil 612 fake.buildsWithTimeReturns = struct { 613 result1 []db.Build 614 result2 db.Pagination 615 result3 error 616 }{result1, result2, result3} 617} 618 619func (fake *FakeTeam) BuildsWithTimeReturnsOnCall(i int, result1 []db.Build, result2 db.Pagination, result3 error) { 620 fake.buildsWithTimeMutex.Lock() 621 defer fake.buildsWithTimeMutex.Unlock() 622 fake.BuildsWithTimeStub = nil 623 if fake.buildsWithTimeReturnsOnCall == nil { 624 fake.buildsWithTimeReturnsOnCall = make(map[int]struct { 625 result1 []db.Build 626 result2 db.Pagination 627 result3 error 628 }) 629 } 630 fake.buildsWithTimeReturnsOnCall[i] = struct { 631 result1 []db.Build 632 result2 db.Pagination 633 result3 error 634 }{result1, result2, result3} 635} 636 637func (fake *FakeTeam) Containers() ([]db.Container, error) { 638 fake.containersMutex.Lock() 639 ret, specificReturn := fake.containersReturnsOnCall[len(fake.containersArgsForCall)] 640 fake.containersArgsForCall = append(fake.containersArgsForCall, struct { 641 }{}) 642 fake.recordInvocation("Containers", []interface{}{}) 643 fake.containersMutex.Unlock() 644 if fake.ContainersStub != nil { 645 return fake.ContainersStub() 646 } 647 if specificReturn { 648 return ret.result1, ret.result2 649 } 650 fakeReturns := fake.containersReturns 651 return fakeReturns.result1, fakeReturns.result2 652} 653 654func (fake *FakeTeam) ContainersCallCount() int { 655 fake.containersMutex.RLock() 656 defer fake.containersMutex.RUnlock() 657 return len(fake.containersArgsForCall) 658} 659 660func (fake *FakeTeam) ContainersCalls(stub func() ([]db.Container, error)) { 661 fake.containersMutex.Lock() 662 defer fake.containersMutex.Unlock() 663 fake.ContainersStub = stub 664} 665 666func (fake *FakeTeam) ContainersReturns(result1 []db.Container, result2 error) { 667 fake.containersMutex.Lock() 668 defer fake.containersMutex.Unlock() 669 fake.ContainersStub = nil 670 fake.containersReturns = struct { 671 result1 []db.Container 672 result2 error 673 }{result1, result2} 674} 675 676func (fake *FakeTeam) ContainersReturnsOnCall(i int, result1 []db.Container, result2 error) { 677 fake.containersMutex.Lock() 678 defer fake.containersMutex.Unlock() 679 fake.ContainersStub = nil 680 if fake.containersReturnsOnCall == nil { 681 fake.containersReturnsOnCall = make(map[int]struct { 682 result1 []db.Container 683 result2 error 684 }) 685 } 686 fake.containersReturnsOnCall[i] = struct { 687 result1 []db.Container 688 result2 error 689 }{result1, result2} 690} 691 692func (fake *FakeTeam) CreateOneOffBuild() (db.Build, error) { 693 fake.createOneOffBuildMutex.Lock() 694 ret, specificReturn := fake.createOneOffBuildReturnsOnCall[len(fake.createOneOffBuildArgsForCall)] 695 fake.createOneOffBuildArgsForCall = append(fake.createOneOffBuildArgsForCall, struct { 696 }{}) 697 fake.recordInvocation("CreateOneOffBuild", []interface{}{}) 698 fake.createOneOffBuildMutex.Unlock() 699 if fake.CreateOneOffBuildStub != nil { 700 return fake.CreateOneOffBuildStub() 701 } 702 if specificReturn { 703 return ret.result1, ret.result2 704 } 705 fakeReturns := fake.createOneOffBuildReturns 706 return fakeReturns.result1, fakeReturns.result2 707} 708 709func (fake *FakeTeam) CreateOneOffBuildCallCount() int { 710 fake.createOneOffBuildMutex.RLock() 711 defer fake.createOneOffBuildMutex.RUnlock() 712 return len(fake.createOneOffBuildArgsForCall) 713} 714 715func (fake *FakeTeam) CreateOneOffBuildCalls(stub func() (db.Build, error)) { 716 fake.createOneOffBuildMutex.Lock() 717 defer fake.createOneOffBuildMutex.Unlock() 718 fake.CreateOneOffBuildStub = stub 719} 720 721func (fake *FakeTeam) CreateOneOffBuildReturns(result1 db.Build, result2 error) { 722 fake.createOneOffBuildMutex.Lock() 723 defer fake.createOneOffBuildMutex.Unlock() 724 fake.CreateOneOffBuildStub = nil 725 fake.createOneOffBuildReturns = struct { 726 result1 db.Build 727 result2 error 728 }{result1, result2} 729} 730 731func (fake *FakeTeam) CreateOneOffBuildReturnsOnCall(i int, result1 db.Build, result2 error) { 732 fake.createOneOffBuildMutex.Lock() 733 defer fake.createOneOffBuildMutex.Unlock() 734 fake.CreateOneOffBuildStub = nil 735 if fake.createOneOffBuildReturnsOnCall == nil { 736 fake.createOneOffBuildReturnsOnCall = make(map[int]struct { 737 result1 db.Build 738 result2 error 739 }) 740 } 741 fake.createOneOffBuildReturnsOnCall[i] = struct { 742 result1 db.Build 743 result2 error 744 }{result1, result2} 745} 746 747func (fake *FakeTeam) CreateStartedBuild(arg1 atc.Plan) (db.Build, error) { 748 fake.createStartedBuildMutex.Lock() 749 ret, specificReturn := fake.createStartedBuildReturnsOnCall[len(fake.createStartedBuildArgsForCall)] 750 fake.createStartedBuildArgsForCall = append(fake.createStartedBuildArgsForCall, struct { 751 arg1 atc.Plan 752 }{arg1}) 753 fake.recordInvocation("CreateStartedBuild", []interface{}{arg1}) 754 fake.createStartedBuildMutex.Unlock() 755 if fake.CreateStartedBuildStub != nil { 756 return fake.CreateStartedBuildStub(arg1) 757 } 758 if specificReturn { 759 return ret.result1, ret.result2 760 } 761 fakeReturns := fake.createStartedBuildReturns 762 return fakeReturns.result1, fakeReturns.result2 763} 764 765func (fake *FakeTeam) CreateStartedBuildCallCount() int { 766 fake.createStartedBuildMutex.RLock() 767 defer fake.createStartedBuildMutex.RUnlock() 768 return len(fake.createStartedBuildArgsForCall) 769} 770 771func (fake *FakeTeam) CreateStartedBuildCalls(stub func(atc.Plan) (db.Build, error)) { 772 fake.createStartedBuildMutex.Lock() 773 defer fake.createStartedBuildMutex.Unlock() 774 fake.CreateStartedBuildStub = stub 775} 776 777func (fake *FakeTeam) CreateStartedBuildArgsForCall(i int) atc.Plan { 778 fake.createStartedBuildMutex.RLock() 779 defer fake.createStartedBuildMutex.RUnlock() 780 argsForCall := fake.createStartedBuildArgsForCall[i] 781 return argsForCall.arg1 782} 783 784func (fake *FakeTeam) CreateStartedBuildReturns(result1 db.Build, result2 error) { 785 fake.createStartedBuildMutex.Lock() 786 defer fake.createStartedBuildMutex.Unlock() 787 fake.CreateStartedBuildStub = nil 788 fake.createStartedBuildReturns = struct { 789 result1 db.Build 790 result2 error 791 }{result1, result2} 792} 793 794func (fake *FakeTeam) CreateStartedBuildReturnsOnCall(i int, result1 db.Build, result2 error) { 795 fake.createStartedBuildMutex.Lock() 796 defer fake.createStartedBuildMutex.Unlock() 797 fake.CreateStartedBuildStub = nil 798 if fake.createStartedBuildReturnsOnCall == nil { 799 fake.createStartedBuildReturnsOnCall = make(map[int]struct { 800 result1 db.Build 801 result2 error 802 }) 803 } 804 fake.createStartedBuildReturnsOnCall[i] = struct { 805 result1 db.Build 806 result2 error 807 }{result1, result2} 808} 809 810func (fake *FakeTeam) Delete() error { 811 fake.deleteMutex.Lock() 812 ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)] 813 fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct { 814 }{}) 815 fake.recordInvocation("Delete", []interface{}{}) 816 fake.deleteMutex.Unlock() 817 if fake.DeleteStub != nil { 818 return fake.DeleteStub() 819 } 820 if specificReturn { 821 return ret.result1 822 } 823 fakeReturns := fake.deleteReturns 824 return fakeReturns.result1 825} 826 827func (fake *FakeTeam) DeleteCallCount() int { 828 fake.deleteMutex.RLock() 829 defer fake.deleteMutex.RUnlock() 830 return len(fake.deleteArgsForCall) 831} 832 833func (fake *FakeTeam) DeleteCalls(stub func() error) { 834 fake.deleteMutex.Lock() 835 defer fake.deleteMutex.Unlock() 836 fake.DeleteStub = stub 837} 838 839func (fake *FakeTeam) DeleteReturns(result1 error) { 840 fake.deleteMutex.Lock() 841 defer fake.deleteMutex.Unlock() 842 fake.DeleteStub = nil 843 fake.deleteReturns = struct { 844 result1 error 845 }{result1} 846} 847 848func (fake *FakeTeam) DeleteReturnsOnCall(i int, result1 error) { 849 fake.deleteMutex.Lock() 850 defer fake.deleteMutex.Unlock() 851 fake.DeleteStub = nil 852 if fake.deleteReturnsOnCall == nil { 853 fake.deleteReturnsOnCall = make(map[int]struct { 854 result1 error 855 }) 856 } 857 fake.deleteReturnsOnCall[i] = struct { 858 result1 error 859 }{result1} 860} 861 862func (fake *FakeTeam) FindCheckContainers(arg1 lager.Logger, arg2 string, arg3 string, arg4 creds.Secrets, arg5 creds.VarSourcePool) ([]db.Container, map[int]time.Time, error) { 863 fake.findCheckContainersMutex.Lock() 864 ret, specificReturn := fake.findCheckContainersReturnsOnCall[len(fake.findCheckContainersArgsForCall)] 865 fake.findCheckContainersArgsForCall = append(fake.findCheckContainersArgsForCall, struct { 866 arg1 lager.Logger 867 arg2 string 868 arg3 string 869 arg4 creds.Secrets 870 arg5 creds.VarSourcePool 871 }{arg1, arg2, arg3, arg4, arg5}) 872 fake.recordInvocation("FindCheckContainers", []interface{}{arg1, arg2, arg3, arg4, arg5}) 873 fake.findCheckContainersMutex.Unlock() 874 if fake.FindCheckContainersStub != nil { 875 return fake.FindCheckContainersStub(arg1, arg2, arg3, arg4, arg5) 876 } 877 if specificReturn { 878 return ret.result1, ret.result2, ret.result3 879 } 880 fakeReturns := fake.findCheckContainersReturns 881 return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 882} 883 884func (fake *FakeTeam) FindCheckContainersCallCount() int { 885 fake.findCheckContainersMutex.RLock() 886 defer fake.findCheckContainersMutex.RUnlock() 887 return len(fake.findCheckContainersArgsForCall) 888} 889 890func (fake *FakeTeam) FindCheckContainersCalls(stub func(lager.Logger, string, string, creds.Secrets, creds.VarSourcePool) ([]db.Container, map[int]time.Time, error)) { 891 fake.findCheckContainersMutex.Lock() 892 defer fake.findCheckContainersMutex.Unlock() 893 fake.FindCheckContainersStub = stub 894} 895 896func (fake *FakeTeam) FindCheckContainersArgsForCall(i int) (lager.Logger, string, string, creds.Secrets, creds.VarSourcePool) { 897 fake.findCheckContainersMutex.RLock() 898 defer fake.findCheckContainersMutex.RUnlock() 899 argsForCall := fake.findCheckContainersArgsForCall[i] 900 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 901} 902 903func (fake *FakeTeam) FindCheckContainersReturns(result1 []db.Container, result2 map[int]time.Time, result3 error) { 904 fake.findCheckContainersMutex.Lock() 905 defer fake.findCheckContainersMutex.Unlock() 906 fake.FindCheckContainersStub = nil 907 fake.findCheckContainersReturns = struct { 908 result1 []db.Container 909 result2 map[int]time.Time 910 result3 error 911 }{result1, result2, result3} 912} 913 914func (fake *FakeTeam) FindCheckContainersReturnsOnCall(i int, result1 []db.Container, result2 map[int]time.Time, result3 error) { 915 fake.findCheckContainersMutex.Lock() 916 defer fake.findCheckContainersMutex.Unlock() 917 fake.FindCheckContainersStub = nil 918 if fake.findCheckContainersReturnsOnCall == nil { 919 fake.findCheckContainersReturnsOnCall = make(map[int]struct { 920 result1 []db.Container 921 result2 map[int]time.Time 922 result3 error 923 }) 924 } 925 fake.findCheckContainersReturnsOnCall[i] = struct { 926 result1 []db.Container 927 result2 map[int]time.Time 928 result3 error 929 }{result1, result2, result3} 930} 931 932func (fake *FakeTeam) FindContainerByHandle(arg1 string) (db.Container, bool, error) { 933 fake.findContainerByHandleMutex.Lock() 934 ret, specificReturn := fake.findContainerByHandleReturnsOnCall[len(fake.findContainerByHandleArgsForCall)] 935 fake.findContainerByHandleArgsForCall = append(fake.findContainerByHandleArgsForCall, struct { 936 arg1 string 937 }{arg1}) 938 fake.recordInvocation("FindContainerByHandle", []interface{}{arg1}) 939 fake.findContainerByHandleMutex.Unlock() 940 if fake.FindContainerByHandleStub != nil { 941 return fake.FindContainerByHandleStub(arg1) 942 } 943 if specificReturn { 944 return ret.result1, ret.result2, ret.result3 945 } 946 fakeReturns := fake.findContainerByHandleReturns 947 return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 948} 949 950func (fake *FakeTeam) FindContainerByHandleCallCount() int { 951 fake.findContainerByHandleMutex.RLock() 952 defer fake.findContainerByHandleMutex.RUnlock() 953 return len(fake.findContainerByHandleArgsForCall) 954} 955 956func (fake *FakeTeam) FindContainerByHandleCalls(stub func(string) (db.Container, bool, error)) { 957 fake.findContainerByHandleMutex.Lock() 958 defer fake.findContainerByHandleMutex.Unlock() 959 fake.FindContainerByHandleStub = stub 960} 961 962func (fake *FakeTeam) FindContainerByHandleArgsForCall(i int) string { 963 fake.findContainerByHandleMutex.RLock() 964 defer fake.findContainerByHandleMutex.RUnlock() 965 argsForCall := fake.findContainerByHandleArgsForCall[i] 966 return argsForCall.arg1 967} 968 969func (fake *FakeTeam) FindContainerByHandleReturns(result1 db.Container, result2 bool, result3 error) { 970 fake.findContainerByHandleMutex.Lock() 971 defer fake.findContainerByHandleMutex.Unlock() 972 fake.FindContainerByHandleStub = nil 973 fake.findContainerByHandleReturns = struct { 974 result1 db.Container 975 result2 bool 976 result3 error 977 }{result1, result2, result3} 978} 979 980func (fake *FakeTeam) FindContainerByHandleReturnsOnCall(i int, result1 db.Container, result2 bool, result3 error) { 981 fake.findContainerByHandleMutex.Lock() 982 defer fake.findContainerByHandleMutex.Unlock() 983 fake.FindContainerByHandleStub = nil 984 if fake.findContainerByHandleReturnsOnCall == nil { 985 fake.findContainerByHandleReturnsOnCall = make(map[int]struct { 986 result1 db.Container 987 result2 bool 988 result3 error 989 }) 990 } 991 fake.findContainerByHandleReturnsOnCall[i] = struct { 992 result1 db.Container 993 result2 bool 994 result3 error 995 }{result1, result2, result3} 996} 997 998func (fake *FakeTeam) FindContainersByMetadata(arg1 db.ContainerMetadata) ([]db.Container, error) { 999 fake.findContainersByMetadataMutex.Lock() 1000 ret, specificReturn := fake.findContainersByMetadataReturnsOnCall[len(fake.findContainersByMetadataArgsForCall)] 1001 fake.findContainersByMetadataArgsForCall = append(fake.findContainersByMetadataArgsForCall, struct { 1002 arg1 db.ContainerMetadata 1003 }{arg1}) 1004 fake.recordInvocation("FindContainersByMetadata", []interface{}{arg1}) 1005 fake.findContainersByMetadataMutex.Unlock() 1006 if fake.FindContainersByMetadataStub != nil { 1007 return fake.FindContainersByMetadataStub(arg1) 1008 } 1009 if specificReturn { 1010 return ret.result1, ret.result2 1011 } 1012 fakeReturns := fake.findContainersByMetadataReturns 1013 return fakeReturns.result1, fakeReturns.result2 1014} 1015 1016func (fake *FakeTeam) FindContainersByMetadataCallCount() int { 1017 fake.findContainersByMetadataMutex.RLock() 1018 defer fake.findContainersByMetadataMutex.RUnlock() 1019 return len(fake.findContainersByMetadataArgsForCall) 1020} 1021 1022func (fake *FakeTeam) FindContainersByMetadataCalls(stub func(db.ContainerMetadata) ([]db.Container, error)) { 1023 fake.findContainersByMetadataMutex.Lock() 1024 defer fake.findContainersByMetadataMutex.Unlock() 1025 fake.FindContainersByMetadataStub = stub 1026} 1027 1028func (fake *FakeTeam) FindContainersByMetadataArgsForCall(i int) db.ContainerMetadata { 1029 fake.findContainersByMetadataMutex.RLock() 1030 defer fake.findContainersByMetadataMutex.RUnlock() 1031 argsForCall := fake.findContainersByMetadataArgsForCall[i] 1032 return argsForCall.arg1 1033} 1034 1035func (fake *FakeTeam) FindContainersByMetadataReturns(result1 []db.Container, result2 error) { 1036 fake.findContainersByMetadataMutex.Lock() 1037 defer fake.findContainersByMetadataMutex.Unlock() 1038 fake.FindContainersByMetadataStub = nil 1039 fake.findContainersByMetadataReturns = struct { 1040 result1 []db.Container 1041 result2 error 1042 }{result1, result2} 1043} 1044 1045func (fake *FakeTeam) FindContainersByMetadataReturnsOnCall(i int, result1 []db.Container, result2 error) { 1046 fake.findContainersByMetadataMutex.Lock() 1047 defer fake.findContainersByMetadataMutex.Unlock() 1048 fake.FindContainersByMetadataStub = nil 1049 if fake.findContainersByMetadataReturnsOnCall == nil { 1050 fake.findContainersByMetadataReturnsOnCall = make(map[int]struct { 1051 result1 []db.Container 1052 result2 error 1053 }) 1054 } 1055 fake.findContainersByMetadataReturnsOnCall[i] = struct { 1056 result1 []db.Container 1057 result2 error 1058 }{result1, result2} 1059} 1060 1061func (fake *FakeTeam) FindCreatedContainerByHandle(arg1 string) (db.CreatedContainer, bool, error) { 1062 fake.findCreatedContainerByHandleMutex.Lock() 1063 ret, specificReturn := fake.findCreatedContainerByHandleReturnsOnCall[len(fake.findCreatedContainerByHandleArgsForCall)] 1064 fake.findCreatedContainerByHandleArgsForCall = append(fake.findCreatedContainerByHandleArgsForCall, struct { 1065 arg1 string 1066 }{arg1}) 1067 fake.recordInvocation("FindCreatedContainerByHandle", []interface{}{arg1}) 1068 fake.findCreatedContainerByHandleMutex.Unlock() 1069 if fake.FindCreatedContainerByHandleStub != nil { 1070 return fake.FindCreatedContainerByHandleStub(arg1) 1071 } 1072 if specificReturn { 1073 return ret.result1, ret.result2, ret.result3 1074 } 1075 fakeReturns := fake.findCreatedContainerByHandleReturns 1076 return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 1077} 1078 1079func (fake *FakeTeam) FindCreatedContainerByHandleCallCount() int { 1080 fake.findCreatedContainerByHandleMutex.RLock() 1081 defer fake.findCreatedContainerByHandleMutex.RUnlock() 1082 return len(fake.findCreatedContainerByHandleArgsForCall) 1083} 1084 1085func (fake *FakeTeam) FindCreatedContainerByHandleCalls(stub func(string) (db.CreatedContainer, bool, error)) { 1086 fake.findCreatedContainerByHandleMutex.Lock() 1087 defer fake.findCreatedContainerByHandleMutex.Unlock() 1088 fake.FindCreatedContainerByHandleStub = stub 1089} 1090 1091func (fake *FakeTeam) FindCreatedContainerByHandleArgsForCall(i int) string { 1092 fake.findCreatedContainerByHandleMutex.RLock() 1093 defer fake.findCreatedContainerByHandleMutex.RUnlock() 1094 argsForCall := fake.findCreatedContainerByHandleArgsForCall[i] 1095 return argsForCall.arg1 1096} 1097 1098func (fake *FakeTeam) FindCreatedContainerByHandleReturns(result1 db.CreatedContainer, result2 bool, result3 error) { 1099 fake.findCreatedContainerByHandleMutex.Lock() 1100 defer fake.findCreatedContainerByHandleMutex.Unlock() 1101 fake.FindCreatedContainerByHandleStub = nil 1102 fake.findCreatedContainerByHandleReturns = struct { 1103 result1 db.CreatedContainer 1104 result2 bool 1105 result3 error 1106 }{result1, result2, result3} 1107} 1108 1109func (fake *FakeTeam) FindCreatedContainerByHandleReturnsOnCall(i int, result1 db.CreatedContainer, result2 bool, result3 error) { 1110 fake.findCreatedContainerByHandleMutex.Lock() 1111 defer fake.findCreatedContainerByHandleMutex.Unlock() 1112 fake.FindCreatedContainerByHandleStub = nil 1113 if fake.findCreatedContainerByHandleReturnsOnCall == nil { 1114 fake.findCreatedContainerByHandleReturnsOnCall = make(map[int]struct { 1115 result1 db.CreatedContainer 1116 result2 bool 1117 result3 error 1118 }) 1119 } 1120 fake.findCreatedContainerByHandleReturnsOnCall[i] = struct { 1121 result1 db.CreatedContainer 1122 result2 bool 1123 result3 error 1124 }{result1, result2, result3} 1125} 1126 1127func (fake *FakeTeam) FindVolumeForWorkerArtifact(arg1 int) (db.CreatedVolume, bool, error) { 1128 fake.findVolumeForWorkerArtifactMutex.Lock() 1129 ret, specificReturn := fake.findVolumeForWorkerArtifactReturnsOnCall[len(fake.findVolumeForWorkerArtifactArgsForCall)] 1130 fake.findVolumeForWorkerArtifactArgsForCall = append(fake.findVolumeForWorkerArtifactArgsForCall, struct { 1131 arg1 int 1132 }{arg1}) 1133 fake.recordInvocation("FindVolumeForWorkerArtifact", []interface{}{arg1}) 1134 fake.findVolumeForWorkerArtifactMutex.Unlock() 1135 if fake.FindVolumeForWorkerArtifactStub != nil { 1136 return fake.FindVolumeForWorkerArtifactStub(arg1) 1137 } 1138 if specificReturn { 1139 return ret.result1, ret.result2, ret.result3 1140 } 1141 fakeReturns := fake.findVolumeForWorkerArtifactReturns 1142 return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 1143} 1144 1145func (fake *FakeTeam) FindVolumeForWorkerArtifactCallCount() int { 1146 fake.findVolumeForWorkerArtifactMutex.RLock() 1147 defer fake.findVolumeForWorkerArtifactMutex.RUnlock() 1148 return len(fake.findVolumeForWorkerArtifactArgsForCall) 1149} 1150 1151func (fake *FakeTeam) FindVolumeForWorkerArtifactCalls(stub func(int) (db.CreatedVolume, bool, error)) { 1152 fake.findVolumeForWorkerArtifactMutex.Lock() 1153 defer fake.findVolumeForWorkerArtifactMutex.Unlock() 1154 fake.FindVolumeForWorkerArtifactStub = stub 1155} 1156 1157func (fake *FakeTeam) FindVolumeForWorkerArtifactArgsForCall(i int) int { 1158 fake.findVolumeForWorkerArtifactMutex.RLock() 1159 defer fake.findVolumeForWorkerArtifactMutex.RUnlock() 1160 argsForCall := fake.findVolumeForWorkerArtifactArgsForCall[i] 1161 return argsForCall.arg1 1162} 1163 1164func (fake *FakeTeam) FindVolumeForWorkerArtifactReturns(result1 db.CreatedVolume, result2 bool, result3 error) { 1165 fake.findVolumeForWorkerArtifactMutex.Lock() 1166 defer fake.findVolumeForWorkerArtifactMutex.Unlock() 1167 fake.FindVolumeForWorkerArtifactStub = nil 1168 fake.findVolumeForWorkerArtifactReturns = struct { 1169 result1 db.CreatedVolume 1170 result2 bool 1171 result3 error 1172 }{result1, result2, result3} 1173} 1174 1175func (fake *FakeTeam) FindVolumeForWorkerArtifactReturnsOnCall(i int, result1 db.CreatedVolume, result2 bool, result3 error) { 1176 fake.findVolumeForWorkerArtifactMutex.Lock() 1177 defer fake.findVolumeForWorkerArtifactMutex.Unlock() 1178 fake.FindVolumeForWorkerArtifactStub = nil 1179 if fake.findVolumeForWorkerArtifactReturnsOnCall == nil { 1180 fake.findVolumeForWorkerArtifactReturnsOnCall = make(map[int]struct { 1181 result1 db.CreatedVolume 1182 result2 bool 1183 result3 error 1184 }) 1185 } 1186 fake.findVolumeForWorkerArtifactReturnsOnCall[i] = struct { 1187 result1 db.CreatedVolume 1188 result2 bool 1189 result3 error 1190 }{result1, result2, result3} 1191} 1192 1193func (fake *FakeTeam) FindWorkerForContainer(arg1 string) (db.Worker, bool, error) { 1194 fake.findWorkerForContainerMutex.Lock() 1195 ret, specificReturn := fake.findWorkerForContainerReturnsOnCall[len(fake.findWorkerForContainerArgsForCall)] 1196 fake.findWorkerForContainerArgsForCall = append(fake.findWorkerForContainerArgsForCall, struct { 1197 arg1 string 1198 }{arg1}) 1199 fake.recordInvocation("FindWorkerForContainer", []interface{}{arg1}) 1200 fake.findWorkerForContainerMutex.Unlock() 1201 if fake.FindWorkerForContainerStub != nil { 1202 return fake.FindWorkerForContainerStub(arg1) 1203 } 1204 if specificReturn { 1205 return ret.result1, ret.result2, ret.result3 1206 } 1207 fakeReturns := fake.findWorkerForContainerReturns 1208 return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 1209} 1210 1211func (fake *FakeTeam) FindWorkerForContainerCallCount() int { 1212 fake.findWorkerForContainerMutex.RLock() 1213 defer fake.findWorkerForContainerMutex.RUnlock() 1214 return len(fake.findWorkerForContainerArgsForCall) 1215} 1216 1217func (fake *FakeTeam) FindWorkerForContainerCalls(stub func(string) (db.Worker, bool, error)) { 1218 fake.findWorkerForContainerMutex.Lock() 1219 defer fake.findWorkerForContainerMutex.Unlock() 1220 fake.FindWorkerForContainerStub = stub 1221} 1222 1223func (fake *FakeTeam) FindWorkerForContainerArgsForCall(i int) string { 1224 fake.findWorkerForContainerMutex.RLock() 1225 defer fake.findWorkerForContainerMutex.RUnlock() 1226 argsForCall := fake.findWorkerForContainerArgsForCall[i] 1227 return argsForCall.arg1 1228} 1229 1230func (fake *FakeTeam) FindWorkerForContainerReturns(result1 db.Worker, result2 bool, result3 error) { 1231 fake.findWorkerForContainerMutex.Lock() 1232 defer fake.findWorkerForContainerMutex.Unlock() 1233 fake.FindWorkerForContainerStub = nil 1234 fake.findWorkerForContainerReturns = struct { 1235 result1 db.Worker 1236 result2 bool 1237 result3 error 1238 }{result1, result2, result3} 1239} 1240 1241func (fake *FakeTeam) FindWorkerForContainerReturnsOnCall(i int, result1 db.Worker, result2 bool, result3 error) { 1242 fake.findWorkerForContainerMutex.Lock() 1243 defer fake.findWorkerForContainerMutex.Unlock() 1244 fake.FindWorkerForContainerStub = nil 1245 if fake.findWorkerForContainerReturnsOnCall == nil { 1246 fake.findWorkerForContainerReturnsOnCall = make(map[int]struct { 1247 result1 db.Worker 1248 result2 bool 1249 result3 error 1250 }) 1251 } 1252 fake.findWorkerForContainerReturnsOnCall[i] = struct { 1253 result1 db.Worker 1254 result2 bool 1255 result3 error 1256 }{result1, result2, result3} 1257} 1258 1259func (fake *FakeTeam) FindWorkerForVolume(arg1 string) (db.Worker, bool, error) { 1260 fake.findWorkerForVolumeMutex.Lock() 1261 ret, specificReturn := fake.findWorkerForVolumeReturnsOnCall[len(fake.findWorkerForVolumeArgsForCall)] 1262 fake.findWorkerForVolumeArgsForCall = append(fake.findWorkerForVolumeArgsForCall, struct { 1263 arg1 string 1264 }{arg1}) 1265 fake.recordInvocation("FindWorkerForVolume", []interface{}{arg1}) 1266 fake.findWorkerForVolumeMutex.Unlock() 1267 if fake.FindWorkerForVolumeStub != nil { 1268 return fake.FindWorkerForVolumeStub(arg1) 1269 } 1270 if specificReturn { 1271 return ret.result1, ret.result2, ret.result3 1272 } 1273 fakeReturns := fake.findWorkerForVolumeReturns 1274 return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 1275} 1276 1277func (fake *FakeTeam) FindWorkerForVolumeCallCount() int { 1278 fake.findWorkerForVolumeMutex.RLock() 1279 defer fake.findWorkerForVolumeMutex.RUnlock() 1280 return len(fake.findWorkerForVolumeArgsForCall) 1281} 1282 1283func (fake *FakeTeam) FindWorkerForVolumeCalls(stub func(string) (db.Worker, bool, error)) { 1284 fake.findWorkerForVolumeMutex.Lock() 1285 defer fake.findWorkerForVolumeMutex.Unlock() 1286 fake.FindWorkerForVolumeStub = stub 1287} 1288 1289func (fake *FakeTeam) FindWorkerForVolumeArgsForCall(i int) string { 1290 fake.findWorkerForVolumeMutex.RLock() 1291 defer fake.findWorkerForVolumeMutex.RUnlock() 1292 argsForCall := fake.findWorkerForVolumeArgsForCall[i] 1293 return argsForCall.arg1 1294} 1295 1296func (fake *FakeTeam) FindWorkerForVolumeReturns(result1 db.Worker, result2 bool, result3 error) { 1297 fake.findWorkerForVolumeMutex.Lock() 1298 defer fake.findWorkerForVolumeMutex.Unlock() 1299 fake.FindWorkerForVolumeStub = nil 1300 fake.findWorkerForVolumeReturns = struct { 1301 result1 db.Worker 1302 result2 bool 1303 result3 error 1304 }{result1, result2, result3} 1305} 1306 1307func (fake *FakeTeam) FindWorkerForVolumeReturnsOnCall(i int, result1 db.Worker, result2 bool, result3 error) { 1308 fake.findWorkerForVolumeMutex.Lock() 1309 defer fake.findWorkerForVolumeMutex.Unlock() 1310 fake.FindWorkerForVolumeStub = nil 1311 if fake.findWorkerForVolumeReturnsOnCall == nil { 1312 fake.findWorkerForVolumeReturnsOnCall = make(map[int]struct { 1313 result1 db.Worker 1314 result2 bool 1315 result3 error 1316 }) 1317 } 1318 fake.findWorkerForVolumeReturnsOnCall[i] = struct { 1319 result1 db.Worker 1320 result2 bool 1321 result3 error 1322 }{result1, result2, result3} 1323} 1324 1325func (fake *FakeTeam) ID() int { 1326 fake.iDMutex.Lock() 1327 ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)] 1328 fake.iDArgsForCall = append(fake.iDArgsForCall, struct { 1329 }{}) 1330 fake.recordInvocation("ID", []interface{}{}) 1331 fake.iDMutex.Unlock() 1332 if fake.IDStub != nil { 1333 return fake.IDStub() 1334 } 1335 if specificReturn { 1336 return ret.result1 1337 } 1338 fakeReturns := fake.iDReturns 1339 return fakeReturns.result1 1340} 1341 1342func (fake *FakeTeam) IDCallCount() int { 1343 fake.iDMutex.RLock() 1344 defer fake.iDMutex.RUnlock() 1345 return len(fake.iDArgsForCall) 1346} 1347 1348func (fake *FakeTeam) IDCalls(stub func() int) { 1349 fake.iDMutex.Lock() 1350 defer fake.iDMutex.Unlock() 1351 fake.IDStub = stub 1352} 1353 1354func (fake *FakeTeam) IDReturns(result1 int) { 1355 fake.iDMutex.Lock() 1356 defer fake.iDMutex.Unlock() 1357 fake.IDStub = nil 1358 fake.iDReturns = struct { 1359 result1 int 1360 }{result1} 1361} 1362 1363func (fake *FakeTeam) IDReturnsOnCall(i int, result1 int) { 1364 fake.iDMutex.Lock() 1365 defer fake.iDMutex.Unlock() 1366 fake.IDStub = nil 1367 if fake.iDReturnsOnCall == nil { 1368 fake.iDReturnsOnCall = make(map[int]struct { 1369 result1 int 1370 }) 1371 } 1372 fake.iDReturnsOnCall[i] = struct { 1373 result1 int 1374 }{result1} 1375} 1376 1377func (fake *FakeTeam) IsCheckContainer(arg1 string) (bool, error) { 1378 fake.isCheckContainerMutex.Lock() 1379 ret, specificReturn := fake.isCheckContainerReturnsOnCall[len(fake.isCheckContainerArgsForCall)] 1380 fake.isCheckContainerArgsForCall = append(fake.isCheckContainerArgsForCall, struct { 1381 arg1 string 1382 }{arg1}) 1383 fake.recordInvocation("IsCheckContainer", []interface{}{arg1}) 1384 fake.isCheckContainerMutex.Unlock() 1385 if fake.IsCheckContainerStub != nil { 1386 return fake.IsCheckContainerStub(arg1) 1387 } 1388 if specificReturn { 1389 return ret.result1, ret.result2 1390 } 1391 fakeReturns := fake.isCheckContainerReturns 1392 return fakeReturns.result1, fakeReturns.result2 1393} 1394 1395func (fake *FakeTeam) IsCheckContainerCallCount() int { 1396 fake.isCheckContainerMutex.RLock() 1397 defer fake.isCheckContainerMutex.RUnlock() 1398 return len(fake.isCheckContainerArgsForCall) 1399} 1400 1401func (fake *FakeTeam) IsCheckContainerCalls(stub func(string) (bool, error)) { 1402 fake.isCheckContainerMutex.Lock() 1403 defer fake.isCheckContainerMutex.Unlock() 1404 fake.IsCheckContainerStub = stub 1405} 1406 1407func (fake *FakeTeam) IsCheckContainerArgsForCall(i int) string { 1408 fake.isCheckContainerMutex.RLock() 1409 defer fake.isCheckContainerMutex.RUnlock() 1410 argsForCall := fake.isCheckContainerArgsForCall[i] 1411 return argsForCall.arg1 1412} 1413 1414func (fake *FakeTeam) IsCheckContainerReturns(result1 bool, result2 error) { 1415 fake.isCheckContainerMutex.Lock() 1416 defer fake.isCheckContainerMutex.Unlock() 1417 fake.IsCheckContainerStub = nil 1418 fake.isCheckContainerReturns = struct { 1419 result1 bool 1420 result2 error 1421 }{result1, result2} 1422} 1423 1424func (fake *FakeTeam) IsCheckContainerReturnsOnCall(i int, result1 bool, result2 error) { 1425 fake.isCheckContainerMutex.Lock() 1426 defer fake.isCheckContainerMutex.Unlock() 1427 fake.IsCheckContainerStub = nil 1428 if fake.isCheckContainerReturnsOnCall == nil { 1429 fake.isCheckContainerReturnsOnCall = make(map[int]struct { 1430 result1 bool 1431 result2 error 1432 }) 1433 } 1434 fake.isCheckContainerReturnsOnCall[i] = struct { 1435 result1 bool 1436 result2 error 1437 }{result1, result2} 1438} 1439 1440func (fake *FakeTeam) IsContainerWithinTeam(arg1 string, arg2 bool) (bool, error) { 1441 fake.isContainerWithinTeamMutex.Lock() 1442 ret, specificReturn := fake.isContainerWithinTeamReturnsOnCall[len(fake.isContainerWithinTeamArgsForCall)] 1443 fake.isContainerWithinTeamArgsForCall = append(fake.isContainerWithinTeamArgsForCall, struct { 1444 arg1 string 1445 arg2 bool 1446 }{arg1, arg2}) 1447 fake.recordInvocation("IsContainerWithinTeam", []interface{}{arg1, arg2}) 1448 fake.isContainerWithinTeamMutex.Unlock() 1449 if fake.IsContainerWithinTeamStub != nil { 1450 return fake.IsContainerWithinTeamStub(arg1, arg2) 1451 } 1452 if specificReturn { 1453 return ret.result1, ret.result2 1454 } 1455 fakeReturns := fake.isContainerWithinTeamReturns 1456 return fakeReturns.result1, fakeReturns.result2 1457} 1458 1459func (fake *FakeTeam) IsContainerWithinTeamCallCount() int { 1460 fake.isContainerWithinTeamMutex.RLock() 1461 defer fake.isContainerWithinTeamMutex.RUnlock() 1462 return len(fake.isContainerWithinTeamArgsForCall) 1463} 1464 1465func (fake *FakeTeam) IsContainerWithinTeamCalls(stub func(string, bool) (bool, error)) { 1466 fake.isContainerWithinTeamMutex.Lock() 1467 defer fake.isContainerWithinTeamMutex.Unlock() 1468 fake.IsContainerWithinTeamStub = stub 1469} 1470 1471func (fake *FakeTeam) IsContainerWithinTeamArgsForCall(i int) (string, bool) { 1472 fake.isContainerWithinTeamMutex.RLock() 1473 defer fake.isContainerWithinTeamMutex.RUnlock() 1474 argsForCall := fake.isContainerWithinTeamArgsForCall[i] 1475 return argsForCall.arg1, argsForCall.arg2 1476} 1477 1478func (fake *FakeTeam) IsContainerWithinTeamReturns(result1 bool, result2 error) { 1479 fake.isContainerWithinTeamMutex.Lock() 1480 defer fake.isContainerWithinTeamMutex.Unlock() 1481 fake.IsContainerWithinTeamStub = nil 1482 fake.isContainerWithinTeamReturns = struct { 1483 result1 bool 1484 result2 error 1485 }{result1, result2} 1486} 1487 1488func (fake *FakeTeam) IsContainerWithinTeamReturnsOnCall(i int, result1 bool, result2 error) { 1489 fake.isContainerWithinTeamMutex.Lock() 1490 defer fake.isContainerWithinTeamMutex.Unlock() 1491 fake.IsContainerWithinTeamStub = nil 1492 if fake.isContainerWithinTeamReturnsOnCall == nil { 1493 fake.isContainerWithinTeamReturnsOnCall = make(map[int]struct { 1494 result1 bool 1495 result2 error 1496 }) 1497 } 1498 fake.isContainerWithinTeamReturnsOnCall[i] = struct { 1499 result1 bool 1500 result2 error 1501 }{result1, result2} 1502} 1503 1504func (fake *FakeTeam) Name() string { 1505 fake.nameMutex.Lock() 1506 ret, specificReturn := fake.nameReturnsOnCall[len(fake.nameArgsForCall)] 1507 fake.nameArgsForCall = append(fake.nameArgsForCall, struct { 1508 }{}) 1509 fake.recordInvocation("Name", []interface{}{}) 1510 fake.nameMutex.Unlock() 1511 if fake.NameStub != nil { 1512 return fake.NameStub() 1513 } 1514 if specificReturn { 1515 return ret.result1 1516 } 1517 fakeReturns := fake.nameReturns 1518 return fakeReturns.result1 1519} 1520 1521func (fake *FakeTeam) NameCallCount() int { 1522 fake.nameMutex.RLock() 1523 defer fake.nameMutex.RUnlock() 1524 return len(fake.nameArgsForCall) 1525} 1526 1527func (fake *FakeTeam) NameCalls(stub func() string) { 1528 fake.nameMutex.Lock() 1529 defer fake.nameMutex.Unlock() 1530 fake.NameStub = stub 1531} 1532 1533func (fake *FakeTeam) NameReturns(result1 string) { 1534 fake.nameMutex.Lock() 1535 defer fake.nameMutex.Unlock() 1536 fake.NameStub = nil 1537 fake.nameReturns = struct { 1538 result1 string 1539 }{result1} 1540} 1541 1542func (fake *FakeTeam) NameReturnsOnCall(i int, result1 string) { 1543 fake.nameMutex.Lock() 1544 defer fake.nameMutex.Unlock() 1545 fake.NameStub = nil 1546 if fake.nameReturnsOnCall == nil { 1547 fake.nameReturnsOnCall = make(map[int]struct { 1548 result1 string 1549 }) 1550 } 1551 fake.nameReturnsOnCall[i] = struct { 1552 result1 string 1553 }{result1} 1554} 1555 1556func (fake *FakeTeam) OrderPipelines(arg1 []string) error { 1557 var arg1Copy []string 1558 if arg1 != nil { 1559 arg1Copy = make([]string, len(arg1)) 1560 copy(arg1Copy, arg1) 1561 } 1562 fake.orderPipelinesMutex.Lock() 1563 ret, specificReturn := fake.orderPipelinesReturnsOnCall[len(fake.orderPipelinesArgsForCall)] 1564 fake.orderPipelinesArgsForCall = append(fake.orderPipelinesArgsForCall, struct { 1565 arg1 []string 1566 }{arg1Copy}) 1567 fake.recordInvocation("OrderPipelines", []interface{}{arg1Copy}) 1568 fake.orderPipelinesMutex.Unlock() 1569 if fake.OrderPipelinesStub != nil { 1570 return fake.OrderPipelinesStub(arg1) 1571 } 1572 if specificReturn { 1573 return ret.result1 1574 } 1575 fakeReturns := fake.orderPipelinesReturns 1576 return fakeReturns.result1 1577} 1578 1579func (fake *FakeTeam) OrderPipelinesCallCount() int { 1580 fake.orderPipelinesMutex.RLock() 1581 defer fake.orderPipelinesMutex.RUnlock() 1582 return len(fake.orderPipelinesArgsForCall) 1583} 1584 1585func (fake *FakeTeam) OrderPipelinesCalls(stub func([]string) error) { 1586 fake.orderPipelinesMutex.Lock() 1587 defer fake.orderPipelinesMutex.Unlock() 1588 fake.OrderPipelinesStub = stub 1589} 1590 1591func (fake *FakeTeam) OrderPipelinesArgsForCall(i int) []string { 1592 fake.orderPipelinesMutex.RLock() 1593 defer fake.orderPipelinesMutex.RUnlock() 1594 argsForCall := fake.orderPipelinesArgsForCall[i] 1595 return argsForCall.arg1 1596} 1597 1598func (fake *FakeTeam) OrderPipelinesReturns(result1 error) { 1599 fake.orderPipelinesMutex.Lock() 1600 defer fake.orderPipelinesMutex.Unlock() 1601 fake.OrderPipelinesStub = nil 1602 fake.orderPipelinesReturns = struct { 1603 result1 error 1604 }{result1} 1605} 1606 1607func (fake *FakeTeam) OrderPipelinesReturnsOnCall(i int, result1 error) { 1608 fake.orderPipelinesMutex.Lock() 1609 defer fake.orderPipelinesMutex.Unlock() 1610 fake.OrderPipelinesStub = nil 1611 if fake.orderPipelinesReturnsOnCall == nil { 1612 fake.orderPipelinesReturnsOnCall = make(map[int]struct { 1613 result1 error 1614 }) 1615 } 1616 fake.orderPipelinesReturnsOnCall[i] = struct { 1617 result1 error 1618 }{result1} 1619} 1620 1621func (fake *FakeTeam) Pipeline(arg1 string) (db.Pipeline, bool, error) { 1622 fake.pipelineMutex.Lock() 1623 ret, specificReturn := fake.pipelineReturnsOnCall[len(fake.pipelineArgsForCall)] 1624 fake.pipelineArgsForCall = append(fake.pipelineArgsForCall, struct { 1625 arg1 string 1626 }{arg1}) 1627 fake.recordInvocation("Pipeline", []interface{}{arg1}) 1628 fake.pipelineMutex.Unlock() 1629 if fake.PipelineStub != nil { 1630 return fake.PipelineStub(arg1) 1631 } 1632 if specificReturn { 1633 return ret.result1, ret.result2, ret.result3 1634 } 1635 fakeReturns := fake.pipelineReturns 1636 return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 1637} 1638 1639func (fake *FakeTeam) PipelineCallCount() int { 1640 fake.pipelineMutex.RLock() 1641 defer fake.pipelineMutex.RUnlock() 1642 return len(fake.pipelineArgsForCall) 1643} 1644 1645func (fake *FakeTeam) PipelineCalls(stub func(string) (db.Pipeline, bool, error)) { 1646 fake.pipelineMutex.Lock() 1647 defer fake.pipelineMutex.Unlock() 1648 fake.PipelineStub = stub 1649} 1650 1651func (fake *FakeTeam) PipelineArgsForCall(i int) string { 1652 fake.pipelineMutex.RLock() 1653 defer fake.pipelineMutex.RUnlock() 1654 argsForCall := fake.pipelineArgsForCall[i] 1655 return argsForCall.arg1 1656} 1657 1658func (fake *FakeTeam) PipelineReturns(result1 db.Pipeline, result2 bool, result3 error) { 1659 fake.pipelineMutex.Lock() 1660 defer fake.pipelineMutex.Unlock() 1661 fake.PipelineStub = nil 1662 fake.pipelineReturns = struct { 1663 result1 db.Pipeline 1664 result2 bool 1665 result3 error 1666 }{result1, result2, result3} 1667} 1668 1669func (fake *FakeTeam) PipelineReturnsOnCall(i int, result1 db.Pipeline, result2 bool, result3 error) { 1670 fake.pipelineMutex.Lock() 1671 defer fake.pipelineMutex.Unlock() 1672 fake.PipelineStub = nil 1673 if fake.pipelineReturnsOnCall == nil { 1674 fake.pipelineReturnsOnCall = make(map[int]struct { 1675 result1 db.Pipeline 1676 result2 bool 1677 result3 error 1678 }) 1679 } 1680 fake.pipelineReturnsOnCall[i] = struct { 1681 result1 db.Pipeline 1682 result2 bool 1683 result3 error 1684 }{result1, result2, result3} 1685} 1686 1687func (fake *FakeTeam) Pipelines() ([]db.Pipeline, error) { 1688 fake.pipelinesMutex.Lock() 1689 ret, specificReturn := fake.pipelinesReturnsOnCall[len(fake.pipelinesArgsForCall)] 1690 fake.pipelinesArgsForCall = append(fake.pipelinesArgsForCall, struct { 1691 }{}) 1692 fake.recordInvocation("Pipelines", []interface{}{}) 1693 fake.pipelinesMutex.Unlock() 1694 if fake.PipelinesStub != nil { 1695 return fake.PipelinesStub() 1696 } 1697 if specificReturn { 1698 return ret.result1, ret.result2 1699 } 1700 fakeReturns := fake.pipelinesReturns 1701 return fakeReturns.result1, fakeReturns.result2 1702} 1703 1704func (fake *FakeTeam) PipelinesCallCount() int { 1705 fake.pipelinesMutex.RLock() 1706 defer fake.pipelinesMutex.RUnlock() 1707 return len(fake.pipelinesArgsForCall) 1708} 1709 1710func (fake *FakeTeam) PipelinesCalls(stub func() ([]db.Pipeline, error)) { 1711 fake.pipelinesMutex.Lock() 1712 defer fake.pipelinesMutex.Unlock() 1713 fake.PipelinesStub = stub 1714} 1715 1716func (fake *FakeTeam) PipelinesReturns(result1 []db.Pipeline, result2 error) { 1717 fake.pipelinesMutex.Lock() 1718 defer fake.pipelinesMutex.Unlock() 1719 fake.PipelinesStub = nil 1720 fake.pipelinesReturns = struct { 1721 result1 []db.Pipeline 1722 result2 error 1723 }{result1, result2} 1724} 1725 1726func (fake *FakeTeam) PipelinesReturnsOnCall(i int, result1 []db.Pipeline, result2 error) { 1727 fake.pipelinesMutex.Lock() 1728 defer fake.pipelinesMutex.Unlock() 1729 fake.PipelinesStub = nil 1730 if fake.pipelinesReturnsOnCall == nil { 1731 fake.pipelinesReturnsOnCall = make(map[int]struct { 1732 result1 []db.Pipeline 1733 result2 error 1734 }) 1735 } 1736 fake.pipelinesReturnsOnCall[i] = struct { 1737 result1 []db.Pipeline 1738 result2 error 1739 }{result1, result2} 1740} 1741 1742func (fake *FakeTeam) PrivateAndPublicBuilds(arg1 db.Page) ([]db.Build, db.Pagination, error) { 1743 fake.privateAndPublicBuildsMutex.Lock() 1744 ret, specificReturn := fake.privateAndPublicBuildsReturnsOnCall[len(fake.privateAndPublicBuildsArgsForCall)] 1745 fake.privateAndPublicBuildsArgsForCall = append(fake.privateAndPublicBuildsArgsForCall, struct { 1746 arg1 db.Page 1747 }{arg1}) 1748 fake.recordInvocation("PrivateAndPublicBuilds", []interface{}{arg1}) 1749 fake.privateAndPublicBuildsMutex.Unlock() 1750 if fake.PrivateAndPublicBuildsStub != nil { 1751 return fake.PrivateAndPublicBuildsStub(arg1) 1752 } 1753 if specificReturn { 1754 return ret.result1, ret.result2, ret.result3 1755 } 1756 fakeReturns := fake.privateAndPublicBuildsReturns 1757 return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 1758} 1759 1760func (fake *FakeTeam) PrivateAndPublicBuildsCallCount() int { 1761 fake.privateAndPublicBuildsMutex.RLock() 1762 defer fake.privateAndPublicBuildsMutex.RUnlock() 1763 return len(fake.privateAndPublicBuildsArgsForCall) 1764} 1765 1766func (fake *FakeTeam) PrivateAndPublicBuildsCalls(stub func(db.Page) ([]db.Build, db.Pagination, error)) { 1767 fake.privateAndPublicBuildsMutex.Lock() 1768 defer fake.privateAndPublicBuildsMutex.Unlock() 1769 fake.PrivateAndPublicBuildsStub = stub 1770} 1771 1772func (fake *FakeTeam) PrivateAndPublicBuildsArgsForCall(i int) db.Page { 1773 fake.privateAndPublicBuildsMutex.RLock() 1774 defer fake.privateAndPublicBuildsMutex.RUnlock() 1775 argsForCall := fake.privateAndPublicBuildsArgsForCall[i] 1776 return argsForCall.arg1 1777} 1778 1779func (fake *FakeTeam) PrivateAndPublicBuildsReturns(result1 []db.Build, result2 db.Pagination, result3 error) { 1780 fake.privateAndPublicBuildsMutex.Lock() 1781 defer fake.privateAndPublicBuildsMutex.Unlock() 1782 fake.PrivateAndPublicBuildsStub = nil 1783 fake.privateAndPublicBuildsReturns = struct { 1784 result1 []db.Build 1785 result2 db.Pagination 1786 result3 error 1787 }{result1, result2, result3} 1788} 1789 1790func (fake *FakeTeam) PrivateAndPublicBuildsReturnsOnCall(i int, result1 []db.Build, result2 db.Pagination, result3 error) { 1791 fake.privateAndPublicBuildsMutex.Lock() 1792 defer fake.privateAndPublicBuildsMutex.Unlock() 1793 fake.PrivateAndPublicBuildsStub = nil 1794 if fake.privateAndPublicBuildsReturnsOnCall == nil { 1795 fake.privateAndPublicBuildsReturnsOnCall = make(map[int]struct { 1796 result1 []db.Build 1797 result2 db.Pagination 1798 result3 error 1799 }) 1800 } 1801 fake.privateAndPublicBuildsReturnsOnCall[i] = struct { 1802 result1 []db.Build 1803 result2 db.Pagination 1804 result3 error 1805 }{result1, result2, result3} 1806} 1807 1808func (fake *FakeTeam) PublicPipelines() ([]db.Pipeline, error) { 1809 fake.publicPipelinesMutex.Lock() 1810 ret, specificReturn := fake.publicPipelinesReturnsOnCall[len(fake.publicPipelinesArgsForCall)] 1811 fake.publicPipelinesArgsForCall = append(fake.publicPipelinesArgsForCall, struct { 1812 }{}) 1813 fake.recordInvocation("PublicPipelines", []interface{}{}) 1814 fake.publicPipelinesMutex.Unlock() 1815 if fake.PublicPipelinesStub != nil { 1816 return fake.PublicPipelinesStub() 1817 } 1818 if specificReturn { 1819 return ret.result1, ret.result2 1820 } 1821 fakeReturns := fake.publicPipelinesReturns 1822 return fakeReturns.result1, fakeReturns.result2 1823} 1824 1825func (fake *FakeTeam) PublicPipelinesCallCount() int { 1826 fake.publicPipelinesMutex.RLock() 1827 defer fake.publicPipelinesMutex.RUnlock() 1828 return len(fake.publicPipelinesArgsForCall) 1829} 1830 1831func (fake *FakeTeam) PublicPipelinesCalls(stub func() ([]db.Pipeline, error)) { 1832 fake.publicPipelinesMutex.Lock() 1833 defer fake.publicPipelinesMutex.Unlock() 1834 fake.PublicPipelinesStub = stub 1835} 1836 1837func (fake *FakeTeam) PublicPipelinesReturns(result1 []db.Pipeline, result2 error) { 1838 fake.publicPipelinesMutex.Lock() 1839 defer fake.publicPipelinesMutex.Unlock() 1840 fake.PublicPipelinesStub = nil 1841 fake.publicPipelinesReturns = struct { 1842 result1 []db.Pipeline 1843 result2 error 1844 }{result1, result2} 1845} 1846 1847func (fake *FakeTeam) PublicPipelinesReturnsOnCall(i int, result1 []db.Pipeline, result2 error) { 1848 fake.publicPipelinesMutex.Lock() 1849 defer fake.publicPipelinesMutex.Unlock() 1850 fake.PublicPipelinesStub = nil 1851 if fake.publicPipelinesReturnsOnCall == nil { 1852 fake.publicPipelinesReturnsOnCall = make(map[int]struct { 1853 result1 []db.Pipeline 1854 result2 error 1855 }) 1856 } 1857 fake.publicPipelinesReturnsOnCall[i] = struct { 1858 result1 []db.Pipeline 1859 result2 error 1860 }{result1, result2} 1861} 1862 1863func (fake *FakeTeam) Rename(arg1 string) error { 1864 fake.renameMutex.Lock() 1865 ret, specificReturn := fake.renameReturnsOnCall[len(fake.renameArgsForCall)] 1866 fake.renameArgsForCall = append(fake.renameArgsForCall, struct { 1867 arg1 string 1868 }{arg1}) 1869 fake.recordInvocation("Rename", []interface{}{arg1}) 1870 fake.renameMutex.Unlock() 1871 if fake.RenameStub != nil { 1872 return fake.RenameStub(arg1) 1873 } 1874 if specificReturn { 1875 return ret.result1 1876 } 1877 fakeReturns := fake.renameReturns 1878 return fakeReturns.result1 1879} 1880 1881func (fake *FakeTeam) RenameCallCount() int { 1882 fake.renameMutex.RLock() 1883 defer fake.renameMutex.RUnlock() 1884 return len(fake.renameArgsForCall) 1885} 1886 1887func (fake *FakeTeam) RenameCalls(stub func(string) error) { 1888 fake.renameMutex.Lock() 1889 defer fake.renameMutex.Unlock() 1890 fake.RenameStub = stub 1891} 1892 1893func (fake *FakeTeam) RenameArgsForCall(i int) string { 1894 fake.renameMutex.RLock() 1895 defer fake.renameMutex.RUnlock() 1896 argsForCall := fake.renameArgsForCall[i] 1897 return argsForCall.arg1 1898} 1899 1900func (fake *FakeTeam) RenameReturns(result1 error) { 1901 fake.renameMutex.Lock() 1902 defer fake.renameMutex.Unlock() 1903 fake.RenameStub = nil 1904 fake.renameReturns = struct { 1905 result1 error 1906 }{result1} 1907} 1908 1909func (fake *FakeTeam) RenameReturnsOnCall(i int, result1 error) { 1910 fake.renameMutex.Lock() 1911 defer fake.renameMutex.Unlock() 1912 fake.RenameStub = nil 1913 if fake.renameReturnsOnCall == nil { 1914 fake.renameReturnsOnCall = make(map[int]struct { 1915 result1 error 1916 }) 1917 } 1918 fake.renameReturnsOnCall[i] = struct { 1919 result1 error 1920 }{result1} 1921} 1922 1923func (fake *FakeTeam) SavePipeline(arg1 string, arg2 atc.Config, arg3 db.ConfigVersion, arg4 bool) (db.Pipeline, bool, error) { 1924 fake.savePipelineMutex.Lock() 1925 ret, specificReturn := fake.savePipelineReturnsOnCall[len(fake.savePipelineArgsForCall)] 1926 fake.savePipelineArgsForCall = append(fake.savePipelineArgsForCall, struct { 1927 arg1 string 1928 arg2 atc.Config 1929 arg3 db.ConfigVersion 1930 arg4 bool 1931 }{arg1, arg2, arg3, arg4}) 1932 fake.recordInvocation("SavePipeline", []interface{}{arg1, arg2, arg3, arg4}) 1933 fake.savePipelineMutex.Unlock() 1934 if fake.SavePipelineStub != nil { 1935 return fake.SavePipelineStub(arg1, arg2, arg3, arg4) 1936 } 1937 if specificReturn { 1938 return ret.result1, ret.result2, ret.result3 1939 } 1940 fakeReturns := fake.savePipelineReturns 1941 return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 1942} 1943 1944func (fake *FakeTeam) SavePipelineCallCount() int { 1945 fake.savePipelineMutex.RLock() 1946 defer fake.savePipelineMutex.RUnlock() 1947 return len(fake.savePipelineArgsForCall) 1948} 1949 1950func (fake *FakeTeam) SavePipelineCalls(stub func(string, atc.Config, db.ConfigVersion, bool) (db.Pipeline, bool, error)) { 1951 fake.savePipelineMutex.Lock() 1952 defer fake.savePipelineMutex.Unlock() 1953 fake.SavePipelineStub = stub 1954} 1955 1956func (fake *FakeTeam) SavePipelineArgsForCall(i int) (string, atc.Config, db.ConfigVersion, bool) { 1957 fake.savePipelineMutex.RLock() 1958 defer fake.savePipelineMutex.RUnlock() 1959 argsForCall := fake.savePipelineArgsForCall[i] 1960 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 1961} 1962 1963func (fake *FakeTeam) SavePipelineReturns(result1 db.Pipeline, result2 bool, result3 error) { 1964 fake.savePipelineMutex.Lock() 1965 defer fake.savePipelineMutex.Unlock() 1966 fake.SavePipelineStub = nil 1967 fake.savePipelineReturns = struct { 1968 result1 db.Pipeline 1969 result2 bool 1970 result3 error 1971 }{result1, result2, result3} 1972} 1973 1974func (fake *FakeTeam) SavePipelineReturnsOnCall(i int, result1 db.Pipeline, result2 bool, result3 error) { 1975 fake.savePipelineMutex.Lock() 1976 defer fake.savePipelineMutex.Unlock() 1977 fake.SavePipelineStub = nil 1978 if fake.savePipelineReturnsOnCall == nil { 1979 fake.savePipelineReturnsOnCall = make(map[int]struct { 1980 result1 db.Pipeline 1981 result2 bool 1982 result3 error 1983 }) 1984 } 1985 fake.savePipelineReturnsOnCall[i] = struct { 1986 result1 db.Pipeline 1987 result2 bool 1988 result3 error 1989 }{result1, result2, result3} 1990} 1991 1992func (fake *FakeTeam) SaveWorker(arg1 atc.Worker, arg2 time.Duration) (db.Worker, error) { 1993 fake.saveWorkerMutex.Lock() 1994 ret, specificReturn := fake.saveWorkerReturnsOnCall[len(fake.saveWorkerArgsForCall)] 1995 fake.saveWorkerArgsForCall = append(fake.saveWorkerArgsForCall, struct { 1996 arg1 atc.Worker 1997 arg2 time.Duration 1998 }{arg1, arg2}) 1999 fake.recordInvocation("SaveWorker", []interface{}{arg1, arg2}) 2000 fake.saveWorkerMutex.Unlock() 2001 if fake.SaveWorkerStub != nil { 2002 return fake.SaveWorkerStub(arg1, arg2) 2003 } 2004 if specificReturn { 2005 return ret.result1, ret.result2 2006 } 2007 fakeReturns := fake.saveWorkerReturns 2008 return fakeReturns.result1, fakeReturns.result2 2009} 2010 2011func (fake *FakeTeam) SaveWorkerCallCount() int { 2012 fake.saveWorkerMutex.RLock() 2013 defer fake.saveWorkerMutex.RUnlock() 2014 return len(fake.saveWorkerArgsForCall) 2015} 2016 2017func (fake *FakeTeam) SaveWorkerCalls(stub func(atc.Worker, time.Duration) (db.Worker, error)) { 2018 fake.saveWorkerMutex.Lock() 2019 defer fake.saveWorkerMutex.Unlock() 2020 fake.SaveWorkerStub = stub 2021} 2022 2023func (fake *FakeTeam) SaveWorkerArgsForCall(i int) (atc.Worker, time.Duration) { 2024 fake.saveWorkerMutex.RLock() 2025 defer fake.saveWorkerMutex.RUnlock() 2026 argsForCall := fake.saveWorkerArgsForCall[i] 2027 return argsForCall.arg1, argsForCall.arg2 2028} 2029 2030func (fake *FakeTeam) SaveWorkerReturns(result1 db.Worker, result2 error) { 2031 fake.saveWorkerMutex.Lock() 2032 defer fake.saveWorkerMutex.Unlock() 2033 fake.SaveWorkerStub = nil 2034 fake.saveWorkerReturns = struct { 2035 result1 db.Worker 2036 result2 error 2037 }{result1, result2} 2038} 2039 2040func (fake *FakeTeam) SaveWorkerReturnsOnCall(i int, result1 db.Worker, result2 error) { 2041 fake.saveWorkerMutex.Lock() 2042 defer fake.saveWorkerMutex.Unlock() 2043 fake.SaveWorkerStub = nil 2044 if fake.saveWorkerReturnsOnCall == nil { 2045 fake.saveWorkerReturnsOnCall = make(map[int]struct { 2046 result1 db.Worker 2047 result2 error 2048 }) 2049 } 2050 fake.saveWorkerReturnsOnCall[i] = struct { 2051 result1 db.Worker 2052 result2 error 2053 }{result1, result2} 2054} 2055 2056func (fake *FakeTeam) UpdateProviderAuth(arg1 atc.TeamAuth) error { 2057 fake.updateProviderAuthMutex.Lock() 2058 ret, specificReturn := fake.updateProviderAuthReturnsOnCall[len(fake.updateProviderAuthArgsForCall)] 2059 fake.updateProviderAuthArgsForCall = append(fake.updateProviderAuthArgsForCall, struct { 2060 arg1 atc.TeamAuth 2061 }{arg1}) 2062 fake.recordInvocation("UpdateProviderAuth", []interface{}{arg1}) 2063 fake.updateProviderAuthMutex.Unlock() 2064 if fake.UpdateProviderAuthStub != nil { 2065 return fake.UpdateProviderAuthStub(arg1) 2066 } 2067 if specificReturn { 2068 return ret.result1 2069 } 2070 fakeReturns := fake.updateProviderAuthReturns 2071 return fakeReturns.result1 2072} 2073 2074func (fake *FakeTeam) UpdateProviderAuthCallCount() int { 2075 fake.updateProviderAuthMutex.RLock() 2076 defer fake.updateProviderAuthMutex.RUnlock() 2077 return len(fake.updateProviderAuthArgsForCall) 2078} 2079 2080func (fake *FakeTeam) UpdateProviderAuthCalls(stub func(atc.TeamAuth) error) { 2081 fake.updateProviderAuthMutex.Lock() 2082 defer fake.updateProviderAuthMutex.Unlock() 2083 fake.UpdateProviderAuthStub = stub 2084} 2085 2086func (fake *FakeTeam) UpdateProviderAuthArgsForCall(i int) atc.TeamAuth { 2087 fake.updateProviderAuthMutex.RLock() 2088 defer fake.updateProviderAuthMutex.RUnlock() 2089 argsForCall := fake.updateProviderAuthArgsForCall[i] 2090 return argsForCall.arg1 2091} 2092 2093func (fake *FakeTeam) UpdateProviderAuthReturns(result1 error) { 2094 fake.updateProviderAuthMutex.Lock() 2095 defer fake.updateProviderAuthMutex.Unlock() 2096 fake.UpdateProviderAuthStub = nil 2097 fake.updateProviderAuthReturns = struct { 2098 result1 error 2099 }{result1} 2100} 2101 2102func (fake *FakeTeam) UpdateProviderAuthReturnsOnCall(i int, result1 error) { 2103 fake.updateProviderAuthMutex.Lock() 2104 defer fake.updateProviderAuthMutex.Unlock() 2105 fake.UpdateProviderAuthStub = nil 2106 if fake.updateProviderAuthReturnsOnCall == nil { 2107 fake.updateProviderAuthReturnsOnCall = make(map[int]struct { 2108 result1 error 2109 }) 2110 } 2111 fake.updateProviderAuthReturnsOnCall[i] = struct { 2112 result1 error 2113 }{result1} 2114} 2115 2116func (fake *FakeTeam) Workers() ([]db.Worker, error) { 2117 fake.workersMutex.Lock() 2118 ret, specificReturn := fake.workersReturnsOnCall[len(fake.workersArgsForCall)] 2119 fake.workersArgsForCall = append(fake.workersArgsForCall, struct { 2120 }{}) 2121 fake.recordInvocation("Workers", []interface{}{}) 2122 fake.workersMutex.Unlock() 2123 if fake.WorkersStub != nil { 2124 return fake.WorkersStub() 2125 } 2126 if specificReturn { 2127 return ret.result1, ret.result2 2128 } 2129 fakeReturns := fake.workersReturns 2130 return fakeReturns.result1, fakeReturns.result2 2131} 2132 2133func (fake *FakeTeam) WorkersCallCount() int { 2134 fake.workersMutex.RLock() 2135 defer fake.workersMutex.RUnlock() 2136 return len(fake.workersArgsForCall) 2137} 2138 2139func (fake *FakeTeam) WorkersCalls(stub func() ([]db.Worker, error)) { 2140 fake.workersMutex.Lock() 2141 defer fake.workersMutex.Unlock() 2142 fake.WorkersStub = stub 2143} 2144 2145func (fake *FakeTeam) WorkersReturns(result1 []db.Worker, result2 error) { 2146 fake.workersMutex.Lock() 2147 defer fake.workersMutex.Unlock() 2148 fake.WorkersStub = nil 2149 fake.workersReturns = struct { 2150 result1 []db.Worker 2151 result2 error 2152 }{result1, result2} 2153} 2154 2155func (fake *FakeTeam) WorkersReturnsOnCall(i int, result1 []db.Worker, result2 error) { 2156 fake.workersMutex.Lock() 2157 defer fake.workersMutex.Unlock() 2158 fake.WorkersStub = nil 2159 if fake.workersReturnsOnCall == nil { 2160 fake.workersReturnsOnCall = make(map[int]struct { 2161 result1 []db.Worker 2162 result2 error 2163 }) 2164 } 2165 fake.workersReturnsOnCall[i] = struct { 2166 result1 []db.Worker 2167 result2 error 2168 }{result1, result2} 2169} 2170 2171func (fake *FakeTeam) Invocations() map[string][][]interface{} { 2172 fake.invocationsMutex.RLock() 2173 defer fake.invocationsMutex.RUnlock() 2174 fake.adminMutex.RLock() 2175 defer fake.adminMutex.RUnlock() 2176 fake.authMutex.RLock() 2177 defer fake.authMutex.RUnlock() 2178 fake.buildsMutex.RLock() 2179 defer fake.buildsMutex.RUnlock() 2180 fake.buildsWithTimeMutex.RLock() 2181 defer fake.buildsWithTimeMutex.RUnlock() 2182 fake.containersMutex.RLock() 2183 defer fake.containersMutex.RUnlock() 2184 fake.createOneOffBuildMutex.RLock() 2185 defer fake.createOneOffBuildMutex.RUnlock() 2186 fake.createStartedBuildMutex.RLock() 2187 defer fake.createStartedBuildMutex.RUnlock() 2188 fake.deleteMutex.RLock() 2189 defer fake.deleteMutex.RUnlock() 2190 fake.findCheckContainersMutex.RLock() 2191 defer fake.findCheckContainersMutex.RUnlock() 2192 fake.findContainerByHandleMutex.RLock() 2193 defer fake.findContainerByHandleMutex.RUnlock() 2194 fake.findContainersByMetadataMutex.RLock() 2195 defer fake.findContainersByMetadataMutex.RUnlock() 2196 fake.findCreatedContainerByHandleMutex.RLock() 2197 defer fake.findCreatedContainerByHandleMutex.RUnlock() 2198 fake.findVolumeForWorkerArtifactMutex.RLock() 2199 defer fake.findVolumeForWorkerArtifactMutex.RUnlock() 2200 fake.findWorkerForContainerMutex.RLock() 2201 defer fake.findWorkerForContainerMutex.RUnlock() 2202 fake.findWorkerForVolumeMutex.RLock() 2203 defer fake.findWorkerForVolumeMutex.RUnlock() 2204 fake.iDMutex.RLock() 2205 defer fake.iDMutex.RUnlock() 2206 fake.isCheckContainerMutex.RLock() 2207 defer fake.isCheckContainerMutex.RUnlock() 2208 fake.isContainerWithinTeamMutex.RLock() 2209 defer fake.isContainerWithinTeamMutex.RUnlock() 2210 fake.nameMutex.RLock() 2211 defer fake.nameMutex.RUnlock() 2212 fake.orderPipelinesMutex.RLock() 2213 defer fake.orderPipelinesMutex.RUnlock() 2214 fake.pipelineMutex.RLock() 2215 defer fake.pipelineMutex.RUnlock() 2216 fake.pipelinesMutex.RLock() 2217 defer fake.pipelinesMutex.RUnlock() 2218 fake.privateAndPublicBuildsMutex.RLock() 2219 defer fake.privateAndPublicBuildsMutex.RUnlock() 2220 fake.publicPipelinesMutex.RLock() 2221 defer fake.publicPipelinesMutex.RUnlock() 2222 fake.renameMutex.RLock() 2223 defer fake.renameMutex.RUnlock() 2224 fake.savePipelineMutex.RLock() 2225 defer fake.savePipelineMutex.RUnlock() 2226 fake.saveWorkerMutex.RLock() 2227 defer fake.saveWorkerMutex.RUnlock() 2228 fake.updateProviderAuthMutex.RLock() 2229 defer fake.updateProviderAuthMutex.RUnlock() 2230 fake.workersMutex.RLock() 2231 defer fake.workersMutex.RUnlock() 2232 copiedInvocations := map[string][][]interface{}{} 2233 for key, value := range fake.invocations { 2234 copiedInvocations[key] = value 2235 } 2236 return copiedInvocations 2237} 2238 2239func (fake *FakeTeam) recordInvocation(key string, args []interface{}) { 2240 fake.invocationsMutex.Lock() 2241 defer fake.invocationsMutex.Unlock() 2242 if fake.invocations == nil { 2243 fake.invocations = map[string][][]interface{}{} 2244 } 2245 if fake.invocations[key] == nil { 2246 fake.invocations[key] = [][]interface{}{} 2247 } 2248 fake.invocations[key] = append(fake.invocations[key], args) 2249} 2250 2251var _ db.Team = new(FakeTeam) 2252