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 "github.com/concourse/concourse/vars" 13) 14 15type FakePipeline struct { 16 ArchiveStub func() error 17 archiveMutex sync.RWMutex 18 archiveArgsForCall []struct { 19 } 20 archiveReturns struct { 21 result1 error 22 } 23 archiveReturnsOnCall map[int]struct { 24 result1 error 25 } 26 ArchivedStub func() bool 27 archivedMutex sync.RWMutex 28 archivedArgsForCall []struct { 29 } 30 archivedReturns struct { 31 result1 bool 32 } 33 archivedReturnsOnCall map[int]struct { 34 result1 bool 35 } 36 BuildsStub func(db.Page) ([]db.Build, db.Pagination, error) 37 buildsMutex sync.RWMutex 38 buildsArgsForCall []struct { 39 arg1 db.Page 40 } 41 buildsReturns struct { 42 result1 []db.Build 43 result2 db.Pagination 44 result3 error 45 } 46 buildsReturnsOnCall map[int]struct { 47 result1 []db.Build 48 result2 db.Pagination 49 result3 error 50 } 51 BuildsWithTimeStub func(db.Page) ([]db.Build, db.Pagination, error) 52 buildsWithTimeMutex sync.RWMutex 53 buildsWithTimeArgsForCall []struct { 54 arg1 db.Page 55 } 56 buildsWithTimeReturns struct { 57 result1 []db.Build 58 result2 db.Pagination 59 result3 error 60 } 61 buildsWithTimeReturnsOnCall map[int]struct { 62 result1 []db.Build 63 result2 db.Pagination 64 result3 error 65 } 66 CausalityStub func(int) ([]db.Cause, error) 67 causalityMutex sync.RWMutex 68 causalityArgsForCall []struct { 69 arg1 int 70 } 71 causalityReturns struct { 72 result1 []db.Cause 73 result2 error 74 } 75 causalityReturnsOnCall map[int]struct { 76 result1 []db.Cause 77 result2 error 78 } 79 CheckPausedStub func() (bool, error) 80 checkPausedMutex sync.RWMutex 81 checkPausedArgsForCall []struct { 82 } 83 checkPausedReturns struct { 84 result1 bool 85 result2 error 86 } 87 checkPausedReturnsOnCall map[int]struct { 88 result1 bool 89 result2 error 90 } 91 ConfigStub func() (atc.Config, error) 92 configMutex sync.RWMutex 93 configArgsForCall []struct { 94 } 95 configReturns struct { 96 result1 atc.Config 97 result2 error 98 } 99 configReturnsOnCall map[int]struct { 100 result1 atc.Config 101 result2 error 102 } 103 ConfigVersionStub func() db.ConfigVersion 104 configVersionMutex sync.RWMutex 105 configVersionArgsForCall []struct { 106 } 107 configVersionReturns struct { 108 result1 db.ConfigVersion 109 } 110 configVersionReturnsOnCall map[int]struct { 111 result1 db.ConfigVersion 112 } 113 CreateOneOffBuildStub func() (db.Build, error) 114 createOneOffBuildMutex sync.RWMutex 115 createOneOffBuildArgsForCall []struct { 116 } 117 createOneOffBuildReturns struct { 118 result1 db.Build 119 result2 error 120 } 121 createOneOffBuildReturnsOnCall map[int]struct { 122 result1 db.Build 123 result2 error 124 } 125 CreateStartedBuildStub func(atc.Plan) (db.Build, error) 126 createStartedBuildMutex sync.RWMutex 127 createStartedBuildArgsForCall []struct { 128 arg1 atc.Plan 129 } 130 createStartedBuildReturns struct { 131 result1 db.Build 132 result2 error 133 } 134 createStartedBuildReturnsOnCall map[int]struct { 135 result1 db.Build 136 result2 error 137 } 138 DashboardStub func() (atc.Dashboard, error) 139 dashboardMutex sync.RWMutex 140 dashboardArgsForCall []struct { 141 } 142 dashboardReturns struct { 143 result1 atc.Dashboard 144 result2 error 145 } 146 dashboardReturnsOnCall map[int]struct { 147 result1 atc.Dashboard 148 result2 error 149 } 150 DeleteBuildEventsByBuildIDsStub func([]int) error 151 deleteBuildEventsByBuildIDsMutex sync.RWMutex 152 deleteBuildEventsByBuildIDsArgsForCall []struct { 153 arg1 []int 154 } 155 deleteBuildEventsByBuildIDsReturns struct { 156 result1 error 157 } 158 deleteBuildEventsByBuildIDsReturnsOnCall map[int]struct { 159 result1 error 160 } 161 DestroyStub func() error 162 destroyMutex sync.RWMutex 163 destroyArgsForCall []struct { 164 } 165 destroyReturns struct { 166 result1 error 167 } 168 destroyReturnsOnCall map[int]struct { 169 result1 error 170 } 171 DisplayStub func() *atc.DisplayConfig 172 displayMutex sync.RWMutex 173 displayArgsForCall []struct { 174 } 175 displayReturns struct { 176 result1 *atc.DisplayConfig 177 } 178 displayReturnsOnCall map[int]struct { 179 result1 *atc.DisplayConfig 180 } 181 ExposeStub func() error 182 exposeMutex sync.RWMutex 183 exposeArgsForCall []struct { 184 } 185 exposeReturns struct { 186 result1 error 187 } 188 exposeReturnsOnCall map[int]struct { 189 result1 error 190 } 191 GetBuildsWithVersionAsInputStub func(int, int) ([]db.Build, error) 192 getBuildsWithVersionAsInputMutex sync.RWMutex 193 getBuildsWithVersionAsInputArgsForCall []struct { 194 arg1 int 195 arg2 int 196 } 197 getBuildsWithVersionAsInputReturns struct { 198 result1 []db.Build 199 result2 error 200 } 201 getBuildsWithVersionAsInputReturnsOnCall map[int]struct { 202 result1 []db.Build 203 result2 error 204 } 205 GetBuildsWithVersionAsOutputStub func(int, int) ([]db.Build, error) 206 getBuildsWithVersionAsOutputMutex sync.RWMutex 207 getBuildsWithVersionAsOutputArgsForCall []struct { 208 arg1 int 209 arg2 int 210 } 211 getBuildsWithVersionAsOutputReturns struct { 212 result1 []db.Build 213 result2 error 214 } 215 getBuildsWithVersionAsOutputReturnsOnCall map[int]struct { 216 result1 []db.Build 217 result2 error 218 } 219 GroupsStub func() atc.GroupConfigs 220 groupsMutex sync.RWMutex 221 groupsArgsForCall []struct { 222 } 223 groupsReturns struct { 224 result1 atc.GroupConfigs 225 } 226 groupsReturnsOnCall map[int]struct { 227 result1 atc.GroupConfigs 228 } 229 HideStub func() error 230 hideMutex sync.RWMutex 231 hideArgsForCall []struct { 232 } 233 hideReturns struct { 234 result1 error 235 } 236 hideReturnsOnCall map[int]struct { 237 result1 error 238 } 239 IDStub func() int 240 iDMutex sync.RWMutex 241 iDArgsForCall []struct { 242 } 243 iDReturns struct { 244 result1 int 245 } 246 iDReturnsOnCall map[int]struct { 247 result1 int 248 } 249 JobStub func(string) (db.Job, bool, error) 250 jobMutex sync.RWMutex 251 jobArgsForCall []struct { 252 arg1 string 253 } 254 jobReturns struct { 255 result1 db.Job 256 result2 bool 257 result3 error 258 } 259 jobReturnsOnCall map[int]struct { 260 result1 db.Job 261 result2 bool 262 result3 error 263 } 264 JobsStub func() (db.Jobs, error) 265 jobsMutex sync.RWMutex 266 jobsArgsForCall []struct { 267 } 268 jobsReturns struct { 269 result1 db.Jobs 270 result2 error 271 } 272 jobsReturnsOnCall map[int]struct { 273 result1 db.Jobs 274 result2 error 275 } 276 LastUpdatedStub func() time.Time 277 lastUpdatedMutex sync.RWMutex 278 lastUpdatedArgsForCall []struct { 279 } 280 lastUpdatedReturns struct { 281 result1 time.Time 282 } 283 lastUpdatedReturnsOnCall map[int]struct { 284 result1 time.Time 285 } 286 LoadDebugVersionsDBStub func() (*atc.DebugVersionsDB, error) 287 loadDebugVersionsDBMutex sync.RWMutex 288 loadDebugVersionsDBArgsForCall []struct { 289 } 290 loadDebugVersionsDBReturns struct { 291 result1 *atc.DebugVersionsDB 292 result2 error 293 } 294 loadDebugVersionsDBReturnsOnCall map[int]struct { 295 result1 *atc.DebugVersionsDB 296 result2 error 297 } 298 NameStub func() string 299 nameMutex sync.RWMutex 300 nameArgsForCall []struct { 301 } 302 nameReturns struct { 303 result1 string 304 } 305 nameReturnsOnCall map[int]struct { 306 result1 string 307 } 308 ParentBuildIDStub func() int 309 parentBuildIDMutex sync.RWMutex 310 parentBuildIDArgsForCall []struct { 311 } 312 parentBuildIDReturns struct { 313 result1 int 314 } 315 parentBuildIDReturnsOnCall map[int]struct { 316 result1 int 317 } 318 ParentJobIDStub func() int 319 parentJobIDMutex sync.RWMutex 320 parentJobIDArgsForCall []struct { 321 } 322 parentJobIDReturns struct { 323 result1 int 324 } 325 parentJobIDReturnsOnCall map[int]struct { 326 result1 int 327 } 328 PauseStub func() error 329 pauseMutex sync.RWMutex 330 pauseArgsForCall []struct { 331 } 332 pauseReturns struct { 333 result1 error 334 } 335 pauseReturnsOnCall map[int]struct { 336 result1 error 337 } 338 PausedStub func() bool 339 pausedMutex sync.RWMutex 340 pausedArgsForCall []struct { 341 } 342 pausedReturns struct { 343 result1 bool 344 } 345 pausedReturnsOnCall map[int]struct { 346 result1 bool 347 } 348 PublicStub func() bool 349 publicMutex sync.RWMutex 350 publicArgsForCall []struct { 351 } 352 publicReturns struct { 353 result1 bool 354 } 355 publicReturnsOnCall map[int]struct { 356 result1 bool 357 } 358 ReloadStub func() (bool, error) 359 reloadMutex sync.RWMutex 360 reloadArgsForCall []struct { 361 } 362 reloadReturns struct { 363 result1 bool 364 result2 error 365 } 366 reloadReturnsOnCall map[int]struct { 367 result1 bool 368 result2 error 369 } 370 RenameStub func(string) error 371 renameMutex sync.RWMutex 372 renameArgsForCall []struct { 373 arg1 string 374 } 375 renameReturns struct { 376 result1 error 377 } 378 renameReturnsOnCall map[int]struct { 379 result1 error 380 } 381 ResourceStub func(string) (db.Resource, bool, error) 382 resourceMutex sync.RWMutex 383 resourceArgsForCall []struct { 384 arg1 string 385 } 386 resourceReturns struct { 387 result1 db.Resource 388 result2 bool 389 result3 error 390 } 391 resourceReturnsOnCall map[int]struct { 392 result1 db.Resource 393 result2 bool 394 result3 error 395 } 396 ResourceByIDStub func(int) (db.Resource, bool, error) 397 resourceByIDMutex sync.RWMutex 398 resourceByIDArgsForCall []struct { 399 arg1 int 400 } 401 resourceByIDReturns struct { 402 result1 db.Resource 403 result2 bool 404 result3 error 405 } 406 resourceByIDReturnsOnCall map[int]struct { 407 result1 db.Resource 408 result2 bool 409 result3 error 410 } 411 ResourceTypeStub func(string) (db.ResourceType, bool, error) 412 resourceTypeMutex sync.RWMutex 413 resourceTypeArgsForCall []struct { 414 arg1 string 415 } 416 resourceTypeReturns struct { 417 result1 db.ResourceType 418 result2 bool 419 result3 error 420 } 421 resourceTypeReturnsOnCall map[int]struct { 422 result1 db.ResourceType 423 result2 bool 424 result3 error 425 } 426 ResourceTypeByIDStub func(int) (db.ResourceType, bool, error) 427 resourceTypeByIDMutex sync.RWMutex 428 resourceTypeByIDArgsForCall []struct { 429 arg1 int 430 } 431 resourceTypeByIDReturns struct { 432 result1 db.ResourceType 433 result2 bool 434 result3 error 435 } 436 resourceTypeByIDReturnsOnCall map[int]struct { 437 result1 db.ResourceType 438 result2 bool 439 result3 error 440 } 441 ResourceTypesStub func() (db.ResourceTypes, error) 442 resourceTypesMutex sync.RWMutex 443 resourceTypesArgsForCall []struct { 444 } 445 resourceTypesReturns struct { 446 result1 db.ResourceTypes 447 result2 error 448 } 449 resourceTypesReturnsOnCall map[int]struct { 450 result1 db.ResourceTypes 451 result2 error 452 } 453 ResourceVersionStub func(int) (atc.ResourceVersion, bool, error) 454 resourceVersionMutex sync.RWMutex 455 resourceVersionArgsForCall []struct { 456 arg1 int 457 } 458 resourceVersionReturns struct { 459 result1 atc.ResourceVersion 460 result2 bool 461 result3 error 462 } 463 resourceVersionReturnsOnCall map[int]struct { 464 result1 atc.ResourceVersion 465 result2 bool 466 result3 error 467 } 468 ResourcesStub func() (db.Resources, error) 469 resourcesMutex sync.RWMutex 470 resourcesArgsForCall []struct { 471 } 472 resourcesReturns struct { 473 result1 db.Resources 474 result2 error 475 } 476 resourcesReturnsOnCall map[int]struct { 477 result1 db.Resources 478 result2 error 479 } 480 SetParentIDsStub func(int, int) error 481 setParentIDsMutex sync.RWMutex 482 setParentIDsArgsForCall []struct { 483 arg1 int 484 arg2 int 485 } 486 setParentIDsReturns struct { 487 result1 error 488 } 489 setParentIDsReturnsOnCall map[int]struct { 490 result1 error 491 } 492 TeamIDStub func() int 493 teamIDMutex sync.RWMutex 494 teamIDArgsForCall []struct { 495 } 496 teamIDReturns struct { 497 result1 int 498 } 499 teamIDReturnsOnCall map[int]struct { 500 result1 int 501 } 502 TeamNameStub func() string 503 teamNameMutex sync.RWMutex 504 teamNameArgsForCall []struct { 505 } 506 teamNameReturns struct { 507 result1 string 508 } 509 teamNameReturnsOnCall map[int]struct { 510 result1 string 511 } 512 UnpauseStub func() error 513 unpauseMutex sync.RWMutex 514 unpauseArgsForCall []struct { 515 } 516 unpauseReturns struct { 517 result1 error 518 } 519 unpauseReturnsOnCall map[int]struct { 520 result1 error 521 } 522 VarSourcesStub func() atc.VarSourceConfigs 523 varSourcesMutex sync.RWMutex 524 varSourcesArgsForCall []struct { 525 } 526 varSourcesReturns struct { 527 result1 atc.VarSourceConfigs 528 } 529 varSourcesReturnsOnCall map[int]struct { 530 result1 atc.VarSourceConfigs 531 } 532 VariablesStub func(lager.Logger, creds.Secrets, creds.VarSourcePool) (vars.Variables, error) 533 variablesMutex sync.RWMutex 534 variablesArgsForCall []struct { 535 arg1 lager.Logger 536 arg2 creds.Secrets 537 arg3 creds.VarSourcePool 538 } 539 variablesReturns struct { 540 result1 vars.Variables 541 result2 error 542 } 543 variablesReturnsOnCall map[int]struct { 544 result1 vars.Variables 545 result2 error 546 } 547 invocations map[string][][]interface{} 548 invocationsMutex sync.RWMutex 549} 550 551func (fake *FakePipeline) Archive() error { 552 fake.archiveMutex.Lock() 553 ret, specificReturn := fake.archiveReturnsOnCall[len(fake.archiveArgsForCall)] 554 fake.archiveArgsForCall = append(fake.archiveArgsForCall, struct { 555 }{}) 556 fake.recordInvocation("Archive", []interface{}{}) 557 fake.archiveMutex.Unlock() 558 if fake.ArchiveStub != nil { 559 return fake.ArchiveStub() 560 } 561 if specificReturn { 562 return ret.result1 563 } 564 fakeReturns := fake.archiveReturns 565 return fakeReturns.result1 566} 567 568func (fake *FakePipeline) ArchiveCallCount() int { 569 fake.archiveMutex.RLock() 570 defer fake.archiveMutex.RUnlock() 571 return len(fake.archiveArgsForCall) 572} 573 574func (fake *FakePipeline) ArchiveCalls(stub func() error) { 575 fake.archiveMutex.Lock() 576 defer fake.archiveMutex.Unlock() 577 fake.ArchiveStub = stub 578} 579 580func (fake *FakePipeline) ArchiveReturns(result1 error) { 581 fake.archiveMutex.Lock() 582 defer fake.archiveMutex.Unlock() 583 fake.ArchiveStub = nil 584 fake.archiveReturns = struct { 585 result1 error 586 }{result1} 587} 588 589func (fake *FakePipeline) ArchiveReturnsOnCall(i int, result1 error) { 590 fake.archiveMutex.Lock() 591 defer fake.archiveMutex.Unlock() 592 fake.ArchiveStub = nil 593 if fake.archiveReturnsOnCall == nil { 594 fake.archiveReturnsOnCall = make(map[int]struct { 595 result1 error 596 }) 597 } 598 fake.archiveReturnsOnCall[i] = struct { 599 result1 error 600 }{result1} 601} 602 603func (fake *FakePipeline) Archived() bool { 604 fake.archivedMutex.Lock() 605 ret, specificReturn := fake.archivedReturnsOnCall[len(fake.archivedArgsForCall)] 606 fake.archivedArgsForCall = append(fake.archivedArgsForCall, struct { 607 }{}) 608 fake.recordInvocation("Archived", []interface{}{}) 609 fake.archivedMutex.Unlock() 610 if fake.ArchivedStub != nil { 611 return fake.ArchivedStub() 612 } 613 if specificReturn { 614 return ret.result1 615 } 616 fakeReturns := fake.archivedReturns 617 return fakeReturns.result1 618} 619 620func (fake *FakePipeline) ArchivedCallCount() int { 621 fake.archivedMutex.RLock() 622 defer fake.archivedMutex.RUnlock() 623 return len(fake.archivedArgsForCall) 624} 625 626func (fake *FakePipeline) ArchivedCalls(stub func() bool) { 627 fake.archivedMutex.Lock() 628 defer fake.archivedMutex.Unlock() 629 fake.ArchivedStub = stub 630} 631 632func (fake *FakePipeline) ArchivedReturns(result1 bool) { 633 fake.archivedMutex.Lock() 634 defer fake.archivedMutex.Unlock() 635 fake.ArchivedStub = nil 636 fake.archivedReturns = struct { 637 result1 bool 638 }{result1} 639} 640 641func (fake *FakePipeline) ArchivedReturnsOnCall(i int, result1 bool) { 642 fake.archivedMutex.Lock() 643 defer fake.archivedMutex.Unlock() 644 fake.ArchivedStub = nil 645 if fake.archivedReturnsOnCall == nil { 646 fake.archivedReturnsOnCall = make(map[int]struct { 647 result1 bool 648 }) 649 } 650 fake.archivedReturnsOnCall[i] = struct { 651 result1 bool 652 }{result1} 653} 654 655func (fake *FakePipeline) Builds(arg1 db.Page) ([]db.Build, db.Pagination, error) { 656 fake.buildsMutex.Lock() 657 ret, specificReturn := fake.buildsReturnsOnCall[len(fake.buildsArgsForCall)] 658 fake.buildsArgsForCall = append(fake.buildsArgsForCall, struct { 659 arg1 db.Page 660 }{arg1}) 661 fake.recordInvocation("Builds", []interface{}{arg1}) 662 fake.buildsMutex.Unlock() 663 if fake.BuildsStub != nil { 664 return fake.BuildsStub(arg1) 665 } 666 if specificReturn { 667 return ret.result1, ret.result2, ret.result3 668 } 669 fakeReturns := fake.buildsReturns 670 return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 671} 672 673func (fake *FakePipeline) BuildsCallCount() int { 674 fake.buildsMutex.RLock() 675 defer fake.buildsMutex.RUnlock() 676 return len(fake.buildsArgsForCall) 677} 678 679func (fake *FakePipeline) BuildsCalls(stub func(db.Page) ([]db.Build, db.Pagination, error)) { 680 fake.buildsMutex.Lock() 681 defer fake.buildsMutex.Unlock() 682 fake.BuildsStub = stub 683} 684 685func (fake *FakePipeline) BuildsArgsForCall(i int) db.Page { 686 fake.buildsMutex.RLock() 687 defer fake.buildsMutex.RUnlock() 688 argsForCall := fake.buildsArgsForCall[i] 689 return argsForCall.arg1 690} 691 692func (fake *FakePipeline) BuildsReturns(result1 []db.Build, result2 db.Pagination, result3 error) { 693 fake.buildsMutex.Lock() 694 defer fake.buildsMutex.Unlock() 695 fake.BuildsStub = nil 696 fake.buildsReturns = struct { 697 result1 []db.Build 698 result2 db.Pagination 699 result3 error 700 }{result1, result2, result3} 701} 702 703func (fake *FakePipeline) BuildsReturnsOnCall(i int, result1 []db.Build, result2 db.Pagination, result3 error) { 704 fake.buildsMutex.Lock() 705 defer fake.buildsMutex.Unlock() 706 fake.BuildsStub = nil 707 if fake.buildsReturnsOnCall == nil { 708 fake.buildsReturnsOnCall = make(map[int]struct { 709 result1 []db.Build 710 result2 db.Pagination 711 result3 error 712 }) 713 } 714 fake.buildsReturnsOnCall[i] = struct { 715 result1 []db.Build 716 result2 db.Pagination 717 result3 error 718 }{result1, result2, result3} 719} 720 721func (fake *FakePipeline) BuildsWithTime(arg1 db.Page) ([]db.Build, db.Pagination, error) { 722 fake.buildsWithTimeMutex.Lock() 723 ret, specificReturn := fake.buildsWithTimeReturnsOnCall[len(fake.buildsWithTimeArgsForCall)] 724 fake.buildsWithTimeArgsForCall = append(fake.buildsWithTimeArgsForCall, struct { 725 arg1 db.Page 726 }{arg1}) 727 fake.recordInvocation("BuildsWithTime", []interface{}{arg1}) 728 fake.buildsWithTimeMutex.Unlock() 729 if fake.BuildsWithTimeStub != nil { 730 return fake.BuildsWithTimeStub(arg1) 731 } 732 if specificReturn { 733 return ret.result1, ret.result2, ret.result3 734 } 735 fakeReturns := fake.buildsWithTimeReturns 736 return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 737} 738 739func (fake *FakePipeline) BuildsWithTimeCallCount() int { 740 fake.buildsWithTimeMutex.RLock() 741 defer fake.buildsWithTimeMutex.RUnlock() 742 return len(fake.buildsWithTimeArgsForCall) 743} 744 745func (fake *FakePipeline) BuildsWithTimeCalls(stub func(db.Page) ([]db.Build, db.Pagination, error)) { 746 fake.buildsWithTimeMutex.Lock() 747 defer fake.buildsWithTimeMutex.Unlock() 748 fake.BuildsWithTimeStub = stub 749} 750 751func (fake *FakePipeline) BuildsWithTimeArgsForCall(i int) db.Page { 752 fake.buildsWithTimeMutex.RLock() 753 defer fake.buildsWithTimeMutex.RUnlock() 754 argsForCall := fake.buildsWithTimeArgsForCall[i] 755 return argsForCall.arg1 756} 757 758func (fake *FakePipeline) BuildsWithTimeReturns(result1 []db.Build, result2 db.Pagination, result3 error) { 759 fake.buildsWithTimeMutex.Lock() 760 defer fake.buildsWithTimeMutex.Unlock() 761 fake.BuildsWithTimeStub = nil 762 fake.buildsWithTimeReturns = struct { 763 result1 []db.Build 764 result2 db.Pagination 765 result3 error 766 }{result1, result2, result3} 767} 768 769func (fake *FakePipeline) BuildsWithTimeReturnsOnCall(i int, result1 []db.Build, result2 db.Pagination, result3 error) { 770 fake.buildsWithTimeMutex.Lock() 771 defer fake.buildsWithTimeMutex.Unlock() 772 fake.BuildsWithTimeStub = nil 773 if fake.buildsWithTimeReturnsOnCall == nil { 774 fake.buildsWithTimeReturnsOnCall = make(map[int]struct { 775 result1 []db.Build 776 result2 db.Pagination 777 result3 error 778 }) 779 } 780 fake.buildsWithTimeReturnsOnCall[i] = struct { 781 result1 []db.Build 782 result2 db.Pagination 783 result3 error 784 }{result1, result2, result3} 785} 786 787func (fake *FakePipeline) Causality(arg1 int) ([]db.Cause, error) { 788 fake.causalityMutex.Lock() 789 ret, specificReturn := fake.causalityReturnsOnCall[len(fake.causalityArgsForCall)] 790 fake.causalityArgsForCall = append(fake.causalityArgsForCall, struct { 791 arg1 int 792 }{arg1}) 793 fake.recordInvocation("Causality", []interface{}{arg1}) 794 fake.causalityMutex.Unlock() 795 if fake.CausalityStub != nil { 796 return fake.CausalityStub(arg1) 797 } 798 if specificReturn { 799 return ret.result1, ret.result2 800 } 801 fakeReturns := fake.causalityReturns 802 return fakeReturns.result1, fakeReturns.result2 803} 804 805func (fake *FakePipeline) CausalityCallCount() int { 806 fake.causalityMutex.RLock() 807 defer fake.causalityMutex.RUnlock() 808 return len(fake.causalityArgsForCall) 809} 810 811func (fake *FakePipeline) CausalityCalls(stub func(int) ([]db.Cause, error)) { 812 fake.causalityMutex.Lock() 813 defer fake.causalityMutex.Unlock() 814 fake.CausalityStub = stub 815} 816 817func (fake *FakePipeline) CausalityArgsForCall(i int) int { 818 fake.causalityMutex.RLock() 819 defer fake.causalityMutex.RUnlock() 820 argsForCall := fake.causalityArgsForCall[i] 821 return argsForCall.arg1 822} 823 824func (fake *FakePipeline) CausalityReturns(result1 []db.Cause, result2 error) { 825 fake.causalityMutex.Lock() 826 defer fake.causalityMutex.Unlock() 827 fake.CausalityStub = nil 828 fake.causalityReturns = struct { 829 result1 []db.Cause 830 result2 error 831 }{result1, result2} 832} 833 834func (fake *FakePipeline) CausalityReturnsOnCall(i int, result1 []db.Cause, result2 error) { 835 fake.causalityMutex.Lock() 836 defer fake.causalityMutex.Unlock() 837 fake.CausalityStub = nil 838 if fake.causalityReturnsOnCall == nil { 839 fake.causalityReturnsOnCall = make(map[int]struct { 840 result1 []db.Cause 841 result2 error 842 }) 843 } 844 fake.causalityReturnsOnCall[i] = struct { 845 result1 []db.Cause 846 result2 error 847 }{result1, result2} 848} 849 850func (fake *FakePipeline) CheckPaused() (bool, error) { 851 fake.checkPausedMutex.Lock() 852 ret, specificReturn := fake.checkPausedReturnsOnCall[len(fake.checkPausedArgsForCall)] 853 fake.checkPausedArgsForCall = append(fake.checkPausedArgsForCall, struct { 854 }{}) 855 fake.recordInvocation("CheckPaused", []interface{}{}) 856 fake.checkPausedMutex.Unlock() 857 if fake.CheckPausedStub != nil { 858 return fake.CheckPausedStub() 859 } 860 if specificReturn { 861 return ret.result1, ret.result2 862 } 863 fakeReturns := fake.checkPausedReturns 864 return fakeReturns.result1, fakeReturns.result2 865} 866 867func (fake *FakePipeline) CheckPausedCallCount() int { 868 fake.checkPausedMutex.RLock() 869 defer fake.checkPausedMutex.RUnlock() 870 return len(fake.checkPausedArgsForCall) 871} 872 873func (fake *FakePipeline) CheckPausedCalls(stub func() (bool, error)) { 874 fake.checkPausedMutex.Lock() 875 defer fake.checkPausedMutex.Unlock() 876 fake.CheckPausedStub = stub 877} 878 879func (fake *FakePipeline) CheckPausedReturns(result1 bool, result2 error) { 880 fake.checkPausedMutex.Lock() 881 defer fake.checkPausedMutex.Unlock() 882 fake.CheckPausedStub = nil 883 fake.checkPausedReturns = struct { 884 result1 bool 885 result2 error 886 }{result1, result2} 887} 888 889func (fake *FakePipeline) CheckPausedReturnsOnCall(i int, result1 bool, result2 error) { 890 fake.checkPausedMutex.Lock() 891 defer fake.checkPausedMutex.Unlock() 892 fake.CheckPausedStub = nil 893 if fake.checkPausedReturnsOnCall == nil { 894 fake.checkPausedReturnsOnCall = make(map[int]struct { 895 result1 bool 896 result2 error 897 }) 898 } 899 fake.checkPausedReturnsOnCall[i] = struct { 900 result1 bool 901 result2 error 902 }{result1, result2} 903} 904 905func (fake *FakePipeline) Config() (atc.Config, error) { 906 fake.configMutex.Lock() 907 ret, specificReturn := fake.configReturnsOnCall[len(fake.configArgsForCall)] 908 fake.configArgsForCall = append(fake.configArgsForCall, struct { 909 }{}) 910 fake.recordInvocation("Config", []interface{}{}) 911 fake.configMutex.Unlock() 912 if fake.ConfigStub != nil { 913 return fake.ConfigStub() 914 } 915 if specificReturn { 916 return ret.result1, ret.result2 917 } 918 fakeReturns := fake.configReturns 919 return fakeReturns.result1, fakeReturns.result2 920} 921 922func (fake *FakePipeline) ConfigCallCount() int { 923 fake.configMutex.RLock() 924 defer fake.configMutex.RUnlock() 925 return len(fake.configArgsForCall) 926} 927 928func (fake *FakePipeline) ConfigCalls(stub func() (atc.Config, error)) { 929 fake.configMutex.Lock() 930 defer fake.configMutex.Unlock() 931 fake.ConfigStub = stub 932} 933 934func (fake *FakePipeline) ConfigReturns(result1 atc.Config, result2 error) { 935 fake.configMutex.Lock() 936 defer fake.configMutex.Unlock() 937 fake.ConfigStub = nil 938 fake.configReturns = struct { 939 result1 atc.Config 940 result2 error 941 }{result1, result2} 942} 943 944func (fake *FakePipeline) ConfigReturnsOnCall(i int, result1 atc.Config, result2 error) { 945 fake.configMutex.Lock() 946 defer fake.configMutex.Unlock() 947 fake.ConfigStub = nil 948 if fake.configReturnsOnCall == nil { 949 fake.configReturnsOnCall = make(map[int]struct { 950 result1 atc.Config 951 result2 error 952 }) 953 } 954 fake.configReturnsOnCall[i] = struct { 955 result1 atc.Config 956 result2 error 957 }{result1, result2} 958} 959 960func (fake *FakePipeline) ConfigVersion() db.ConfigVersion { 961 fake.configVersionMutex.Lock() 962 ret, specificReturn := fake.configVersionReturnsOnCall[len(fake.configVersionArgsForCall)] 963 fake.configVersionArgsForCall = append(fake.configVersionArgsForCall, struct { 964 }{}) 965 fake.recordInvocation("ConfigVersion", []interface{}{}) 966 fake.configVersionMutex.Unlock() 967 if fake.ConfigVersionStub != nil { 968 return fake.ConfigVersionStub() 969 } 970 if specificReturn { 971 return ret.result1 972 } 973 fakeReturns := fake.configVersionReturns 974 return fakeReturns.result1 975} 976 977func (fake *FakePipeline) ConfigVersionCallCount() int { 978 fake.configVersionMutex.RLock() 979 defer fake.configVersionMutex.RUnlock() 980 return len(fake.configVersionArgsForCall) 981} 982 983func (fake *FakePipeline) ConfigVersionCalls(stub func() db.ConfigVersion) { 984 fake.configVersionMutex.Lock() 985 defer fake.configVersionMutex.Unlock() 986 fake.ConfigVersionStub = stub 987} 988 989func (fake *FakePipeline) ConfigVersionReturns(result1 db.ConfigVersion) { 990 fake.configVersionMutex.Lock() 991 defer fake.configVersionMutex.Unlock() 992 fake.ConfigVersionStub = nil 993 fake.configVersionReturns = struct { 994 result1 db.ConfigVersion 995 }{result1} 996} 997 998func (fake *FakePipeline) ConfigVersionReturnsOnCall(i int, result1 db.ConfigVersion) { 999 fake.configVersionMutex.Lock() 1000 defer fake.configVersionMutex.Unlock() 1001 fake.ConfigVersionStub = nil 1002 if fake.configVersionReturnsOnCall == nil { 1003 fake.configVersionReturnsOnCall = make(map[int]struct { 1004 result1 db.ConfigVersion 1005 }) 1006 } 1007 fake.configVersionReturnsOnCall[i] = struct { 1008 result1 db.ConfigVersion 1009 }{result1} 1010} 1011 1012func (fake *FakePipeline) CreateOneOffBuild() (db.Build, error) { 1013 fake.createOneOffBuildMutex.Lock() 1014 ret, specificReturn := fake.createOneOffBuildReturnsOnCall[len(fake.createOneOffBuildArgsForCall)] 1015 fake.createOneOffBuildArgsForCall = append(fake.createOneOffBuildArgsForCall, struct { 1016 }{}) 1017 fake.recordInvocation("CreateOneOffBuild", []interface{}{}) 1018 fake.createOneOffBuildMutex.Unlock() 1019 if fake.CreateOneOffBuildStub != nil { 1020 return fake.CreateOneOffBuildStub() 1021 } 1022 if specificReturn { 1023 return ret.result1, ret.result2 1024 } 1025 fakeReturns := fake.createOneOffBuildReturns 1026 return fakeReturns.result1, fakeReturns.result2 1027} 1028 1029func (fake *FakePipeline) CreateOneOffBuildCallCount() int { 1030 fake.createOneOffBuildMutex.RLock() 1031 defer fake.createOneOffBuildMutex.RUnlock() 1032 return len(fake.createOneOffBuildArgsForCall) 1033} 1034 1035func (fake *FakePipeline) CreateOneOffBuildCalls(stub func() (db.Build, error)) { 1036 fake.createOneOffBuildMutex.Lock() 1037 defer fake.createOneOffBuildMutex.Unlock() 1038 fake.CreateOneOffBuildStub = stub 1039} 1040 1041func (fake *FakePipeline) CreateOneOffBuildReturns(result1 db.Build, result2 error) { 1042 fake.createOneOffBuildMutex.Lock() 1043 defer fake.createOneOffBuildMutex.Unlock() 1044 fake.CreateOneOffBuildStub = nil 1045 fake.createOneOffBuildReturns = struct { 1046 result1 db.Build 1047 result2 error 1048 }{result1, result2} 1049} 1050 1051func (fake *FakePipeline) CreateOneOffBuildReturnsOnCall(i int, result1 db.Build, result2 error) { 1052 fake.createOneOffBuildMutex.Lock() 1053 defer fake.createOneOffBuildMutex.Unlock() 1054 fake.CreateOneOffBuildStub = nil 1055 if fake.createOneOffBuildReturnsOnCall == nil { 1056 fake.createOneOffBuildReturnsOnCall = make(map[int]struct { 1057 result1 db.Build 1058 result2 error 1059 }) 1060 } 1061 fake.createOneOffBuildReturnsOnCall[i] = struct { 1062 result1 db.Build 1063 result2 error 1064 }{result1, result2} 1065} 1066 1067func (fake *FakePipeline) CreateStartedBuild(arg1 atc.Plan) (db.Build, error) { 1068 fake.createStartedBuildMutex.Lock() 1069 ret, specificReturn := fake.createStartedBuildReturnsOnCall[len(fake.createStartedBuildArgsForCall)] 1070 fake.createStartedBuildArgsForCall = append(fake.createStartedBuildArgsForCall, struct { 1071 arg1 atc.Plan 1072 }{arg1}) 1073 fake.recordInvocation("CreateStartedBuild", []interface{}{arg1}) 1074 fake.createStartedBuildMutex.Unlock() 1075 if fake.CreateStartedBuildStub != nil { 1076 return fake.CreateStartedBuildStub(arg1) 1077 } 1078 if specificReturn { 1079 return ret.result1, ret.result2 1080 } 1081 fakeReturns := fake.createStartedBuildReturns 1082 return fakeReturns.result1, fakeReturns.result2 1083} 1084 1085func (fake *FakePipeline) CreateStartedBuildCallCount() int { 1086 fake.createStartedBuildMutex.RLock() 1087 defer fake.createStartedBuildMutex.RUnlock() 1088 return len(fake.createStartedBuildArgsForCall) 1089} 1090 1091func (fake *FakePipeline) CreateStartedBuildCalls(stub func(atc.Plan) (db.Build, error)) { 1092 fake.createStartedBuildMutex.Lock() 1093 defer fake.createStartedBuildMutex.Unlock() 1094 fake.CreateStartedBuildStub = stub 1095} 1096 1097func (fake *FakePipeline) CreateStartedBuildArgsForCall(i int) atc.Plan { 1098 fake.createStartedBuildMutex.RLock() 1099 defer fake.createStartedBuildMutex.RUnlock() 1100 argsForCall := fake.createStartedBuildArgsForCall[i] 1101 return argsForCall.arg1 1102} 1103 1104func (fake *FakePipeline) CreateStartedBuildReturns(result1 db.Build, result2 error) { 1105 fake.createStartedBuildMutex.Lock() 1106 defer fake.createStartedBuildMutex.Unlock() 1107 fake.CreateStartedBuildStub = nil 1108 fake.createStartedBuildReturns = struct { 1109 result1 db.Build 1110 result2 error 1111 }{result1, result2} 1112} 1113 1114func (fake *FakePipeline) CreateStartedBuildReturnsOnCall(i int, result1 db.Build, result2 error) { 1115 fake.createStartedBuildMutex.Lock() 1116 defer fake.createStartedBuildMutex.Unlock() 1117 fake.CreateStartedBuildStub = nil 1118 if fake.createStartedBuildReturnsOnCall == nil { 1119 fake.createStartedBuildReturnsOnCall = make(map[int]struct { 1120 result1 db.Build 1121 result2 error 1122 }) 1123 } 1124 fake.createStartedBuildReturnsOnCall[i] = struct { 1125 result1 db.Build 1126 result2 error 1127 }{result1, result2} 1128} 1129 1130func (fake *FakePipeline) Dashboard() (atc.Dashboard, error) { 1131 fake.dashboardMutex.Lock() 1132 ret, specificReturn := fake.dashboardReturnsOnCall[len(fake.dashboardArgsForCall)] 1133 fake.dashboardArgsForCall = append(fake.dashboardArgsForCall, struct { 1134 }{}) 1135 fake.recordInvocation("Dashboard", []interface{}{}) 1136 fake.dashboardMutex.Unlock() 1137 if fake.DashboardStub != nil { 1138 return fake.DashboardStub() 1139 } 1140 if specificReturn { 1141 return ret.result1, ret.result2 1142 } 1143 fakeReturns := fake.dashboardReturns 1144 return fakeReturns.result1, fakeReturns.result2 1145} 1146 1147func (fake *FakePipeline) DashboardCallCount() int { 1148 fake.dashboardMutex.RLock() 1149 defer fake.dashboardMutex.RUnlock() 1150 return len(fake.dashboardArgsForCall) 1151} 1152 1153func (fake *FakePipeline) DashboardCalls(stub func() (atc.Dashboard, error)) { 1154 fake.dashboardMutex.Lock() 1155 defer fake.dashboardMutex.Unlock() 1156 fake.DashboardStub = stub 1157} 1158 1159func (fake *FakePipeline) DashboardReturns(result1 atc.Dashboard, result2 error) { 1160 fake.dashboardMutex.Lock() 1161 defer fake.dashboardMutex.Unlock() 1162 fake.DashboardStub = nil 1163 fake.dashboardReturns = struct { 1164 result1 atc.Dashboard 1165 result2 error 1166 }{result1, result2} 1167} 1168 1169func (fake *FakePipeline) DashboardReturnsOnCall(i int, result1 atc.Dashboard, result2 error) { 1170 fake.dashboardMutex.Lock() 1171 defer fake.dashboardMutex.Unlock() 1172 fake.DashboardStub = nil 1173 if fake.dashboardReturnsOnCall == nil { 1174 fake.dashboardReturnsOnCall = make(map[int]struct { 1175 result1 atc.Dashboard 1176 result2 error 1177 }) 1178 } 1179 fake.dashboardReturnsOnCall[i] = struct { 1180 result1 atc.Dashboard 1181 result2 error 1182 }{result1, result2} 1183} 1184 1185func (fake *FakePipeline) DeleteBuildEventsByBuildIDs(arg1 []int) error { 1186 var arg1Copy []int 1187 if arg1 != nil { 1188 arg1Copy = make([]int, len(arg1)) 1189 copy(arg1Copy, arg1) 1190 } 1191 fake.deleteBuildEventsByBuildIDsMutex.Lock() 1192 ret, specificReturn := fake.deleteBuildEventsByBuildIDsReturnsOnCall[len(fake.deleteBuildEventsByBuildIDsArgsForCall)] 1193 fake.deleteBuildEventsByBuildIDsArgsForCall = append(fake.deleteBuildEventsByBuildIDsArgsForCall, struct { 1194 arg1 []int 1195 }{arg1Copy}) 1196 fake.recordInvocation("DeleteBuildEventsByBuildIDs", []interface{}{arg1Copy}) 1197 fake.deleteBuildEventsByBuildIDsMutex.Unlock() 1198 if fake.DeleteBuildEventsByBuildIDsStub != nil { 1199 return fake.DeleteBuildEventsByBuildIDsStub(arg1) 1200 } 1201 if specificReturn { 1202 return ret.result1 1203 } 1204 fakeReturns := fake.deleteBuildEventsByBuildIDsReturns 1205 return fakeReturns.result1 1206} 1207 1208func (fake *FakePipeline) DeleteBuildEventsByBuildIDsCallCount() int { 1209 fake.deleteBuildEventsByBuildIDsMutex.RLock() 1210 defer fake.deleteBuildEventsByBuildIDsMutex.RUnlock() 1211 return len(fake.deleteBuildEventsByBuildIDsArgsForCall) 1212} 1213 1214func (fake *FakePipeline) DeleteBuildEventsByBuildIDsCalls(stub func([]int) error) { 1215 fake.deleteBuildEventsByBuildIDsMutex.Lock() 1216 defer fake.deleteBuildEventsByBuildIDsMutex.Unlock() 1217 fake.DeleteBuildEventsByBuildIDsStub = stub 1218} 1219 1220func (fake *FakePipeline) DeleteBuildEventsByBuildIDsArgsForCall(i int) []int { 1221 fake.deleteBuildEventsByBuildIDsMutex.RLock() 1222 defer fake.deleteBuildEventsByBuildIDsMutex.RUnlock() 1223 argsForCall := fake.deleteBuildEventsByBuildIDsArgsForCall[i] 1224 return argsForCall.arg1 1225} 1226 1227func (fake *FakePipeline) DeleteBuildEventsByBuildIDsReturns(result1 error) { 1228 fake.deleteBuildEventsByBuildIDsMutex.Lock() 1229 defer fake.deleteBuildEventsByBuildIDsMutex.Unlock() 1230 fake.DeleteBuildEventsByBuildIDsStub = nil 1231 fake.deleteBuildEventsByBuildIDsReturns = struct { 1232 result1 error 1233 }{result1} 1234} 1235 1236func (fake *FakePipeline) DeleteBuildEventsByBuildIDsReturnsOnCall(i int, result1 error) { 1237 fake.deleteBuildEventsByBuildIDsMutex.Lock() 1238 defer fake.deleteBuildEventsByBuildIDsMutex.Unlock() 1239 fake.DeleteBuildEventsByBuildIDsStub = nil 1240 if fake.deleteBuildEventsByBuildIDsReturnsOnCall == nil { 1241 fake.deleteBuildEventsByBuildIDsReturnsOnCall = make(map[int]struct { 1242 result1 error 1243 }) 1244 } 1245 fake.deleteBuildEventsByBuildIDsReturnsOnCall[i] = struct { 1246 result1 error 1247 }{result1} 1248} 1249 1250func (fake *FakePipeline) Destroy() error { 1251 fake.destroyMutex.Lock() 1252 ret, specificReturn := fake.destroyReturnsOnCall[len(fake.destroyArgsForCall)] 1253 fake.destroyArgsForCall = append(fake.destroyArgsForCall, struct { 1254 }{}) 1255 fake.recordInvocation("Destroy", []interface{}{}) 1256 fake.destroyMutex.Unlock() 1257 if fake.DestroyStub != nil { 1258 return fake.DestroyStub() 1259 } 1260 if specificReturn { 1261 return ret.result1 1262 } 1263 fakeReturns := fake.destroyReturns 1264 return fakeReturns.result1 1265} 1266 1267func (fake *FakePipeline) DestroyCallCount() int { 1268 fake.destroyMutex.RLock() 1269 defer fake.destroyMutex.RUnlock() 1270 return len(fake.destroyArgsForCall) 1271} 1272 1273func (fake *FakePipeline) DestroyCalls(stub func() error) { 1274 fake.destroyMutex.Lock() 1275 defer fake.destroyMutex.Unlock() 1276 fake.DestroyStub = stub 1277} 1278 1279func (fake *FakePipeline) DestroyReturns(result1 error) { 1280 fake.destroyMutex.Lock() 1281 defer fake.destroyMutex.Unlock() 1282 fake.DestroyStub = nil 1283 fake.destroyReturns = struct { 1284 result1 error 1285 }{result1} 1286} 1287 1288func (fake *FakePipeline) DestroyReturnsOnCall(i int, result1 error) { 1289 fake.destroyMutex.Lock() 1290 defer fake.destroyMutex.Unlock() 1291 fake.DestroyStub = nil 1292 if fake.destroyReturnsOnCall == nil { 1293 fake.destroyReturnsOnCall = make(map[int]struct { 1294 result1 error 1295 }) 1296 } 1297 fake.destroyReturnsOnCall[i] = struct { 1298 result1 error 1299 }{result1} 1300} 1301 1302func (fake *FakePipeline) Display() *atc.DisplayConfig { 1303 fake.displayMutex.Lock() 1304 ret, specificReturn := fake.displayReturnsOnCall[len(fake.displayArgsForCall)] 1305 fake.displayArgsForCall = append(fake.displayArgsForCall, struct { 1306 }{}) 1307 fake.recordInvocation("Display", []interface{}{}) 1308 fake.displayMutex.Unlock() 1309 if fake.DisplayStub != nil { 1310 return fake.DisplayStub() 1311 } 1312 if specificReturn { 1313 return ret.result1 1314 } 1315 fakeReturns := fake.displayReturns 1316 return fakeReturns.result1 1317} 1318 1319func (fake *FakePipeline) DisplayCallCount() int { 1320 fake.displayMutex.RLock() 1321 defer fake.displayMutex.RUnlock() 1322 return len(fake.displayArgsForCall) 1323} 1324 1325func (fake *FakePipeline) DisplayCalls(stub func() *atc.DisplayConfig) { 1326 fake.displayMutex.Lock() 1327 defer fake.displayMutex.Unlock() 1328 fake.DisplayStub = stub 1329} 1330 1331func (fake *FakePipeline) DisplayReturns(result1 *atc.DisplayConfig) { 1332 fake.displayMutex.Lock() 1333 defer fake.displayMutex.Unlock() 1334 fake.DisplayStub = nil 1335 fake.displayReturns = struct { 1336 result1 *atc.DisplayConfig 1337 }{result1} 1338} 1339 1340func (fake *FakePipeline) DisplayReturnsOnCall(i int, result1 *atc.DisplayConfig) { 1341 fake.displayMutex.Lock() 1342 defer fake.displayMutex.Unlock() 1343 fake.DisplayStub = nil 1344 if fake.displayReturnsOnCall == nil { 1345 fake.displayReturnsOnCall = make(map[int]struct { 1346 result1 *atc.DisplayConfig 1347 }) 1348 } 1349 fake.displayReturnsOnCall[i] = struct { 1350 result1 *atc.DisplayConfig 1351 }{result1} 1352} 1353 1354func (fake *FakePipeline) Expose() error { 1355 fake.exposeMutex.Lock() 1356 ret, specificReturn := fake.exposeReturnsOnCall[len(fake.exposeArgsForCall)] 1357 fake.exposeArgsForCall = append(fake.exposeArgsForCall, struct { 1358 }{}) 1359 fake.recordInvocation("Expose", []interface{}{}) 1360 fake.exposeMutex.Unlock() 1361 if fake.ExposeStub != nil { 1362 return fake.ExposeStub() 1363 } 1364 if specificReturn { 1365 return ret.result1 1366 } 1367 fakeReturns := fake.exposeReturns 1368 return fakeReturns.result1 1369} 1370 1371func (fake *FakePipeline) ExposeCallCount() int { 1372 fake.exposeMutex.RLock() 1373 defer fake.exposeMutex.RUnlock() 1374 return len(fake.exposeArgsForCall) 1375} 1376 1377func (fake *FakePipeline) ExposeCalls(stub func() error) { 1378 fake.exposeMutex.Lock() 1379 defer fake.exposeMutex.Unlock() 1380 fake.ExposeStub = stub 1381} 1382 1383func (fake *FakePipeline) ExposeReturns(result1 error) { 1384 fake.exposeMutex.Lock() 1385 defer fake.exposeMutex.Unlock() 1386 fake.ExposeStub = nil 1387 fake.exposeReturns = struct { 1388 result1 error 1389 }{result1} 1390} 1391 1392func (fake *FakePipeline) ExposeReturnsOnCall(i int, result1 error) { 1393 fake.exposeMutex.Lock() 1394 defer fake.exposeMutex.Unlock() 1395 fake.ExposeStub = nil 1396 if fake.exposeReturnsOnCall == nil { 1397 fake.exposeReturnsOnCall = make(map[int]struct { 1398 result1 error 1399 }) 1400 } 1401 fake.exposeReturnsOnCall[i] = struct { 1402 result1 error 1403 }{result1} 1404} 1405 1406func (fake *FakePipeline) GetBuildsWithVersionAsInput(arg1 int, arg2 int) ([]db.Build, error) { 1407 fake.getBuildsWithVersionAsInputMutex.Lock() 1408 ret, specificReturn := fake.getBuildsWithVersionAsInputReturnsOnCall[len(fake.getBuildsWithVersionAsInputArgsForCall)] 1409 fake.getBuildsWithVersionAsInputArgsForCall = append(fake.getBuildsWithVersionAsInputArgsForCall, struct { 1410 arg1 int 1411 arg2 int 1412 }{arg1, arg2}) 1413 fake.recordInvocation("GetBuildsWithVersionAsInput", []interface{}{arg1, arg2}) 1414 fake.getBuildsWithVersionAsInputMutex.Unlock() 1415 if fake.GetBuildsWithVersionAsInputStub != nil { 1416 return fake.GetBuildsWithVersionAsInputStub(arg1, arg2) 1417 } 1418 if specificReturn { 1419 return ret.result1, ret.result2 1420 } 1421 fakeReturns := fake.getBuildsWithVersionAsInputReturns 1422 return fakeReturns.result1, fakeReturns.result2 1423} 1424 1425func (fake *FakePipeline) GetBuildsWithVersionAsInputCallCount() int { 1426 fake.getBuildsWithVersionAsInputMutex.RLock() 1427 defer fake.getBuildsWithVersionAsInputMutex.RUnlock() 1428 return len(fake.getBuildsWithVersionAsInputArgsForCall) 1429} 1430 1431func (fake *FakePipeline) GetBuildsWithVersionAsInputCalls(stub func(int, int) ([]db.Build, error)) { 1432 fake.getBuildsWithVersionAsInputMutex.Lock() 1433 defer fake.getBuildsWithVersionAsInputMutex.Unlock() 1434 fake.GetBuildsWithVersionAsInputStub = stub 1435} 1436 1437func (fake *FakePipeline) GetBuildsWithVersionAsInputArgsForCall(i int) (int, int) { 1438 fake.getBuildsWithVersionAsInputMutex.RLock() 1439 defer fake.getBuildsWithVersionAsInputMutex.RUnlock() 1440 argsForCall := fake.getBuildsWithVersionAsInputArgsForCall[i] 1441 return argsForCall.arg1, argsForCall.arg2 1442} 1443 1444func (fake *FakePipeline) GetBuildsWithVersionAsInputReturns(result1 []db.Build, result2 error) { 1445 fake.getBuildsWithVersionAsInputMutex.Lock() 1446 defer fake.getBuildsWithVersionAsInputMutex.Unlock() 1447 fake.GetBuildsWithVersionAsInputStub = nil 1448 fake.getBuildsWithVersionAsInputReturns = struct { 1449 result1 []db.Build 1450 result2 error 1451 }{result1, result2} 1452} 1453 1454func (fake *FakePipeline) GetBuildsWithVersionAsInputReturnsOnCall(i int, result1 []db.Build, result2 error) { 1455 fake.getBuildsWithVersionAsInputMutex.Lock() 1456 defer fake.getBuildsWithVersionAsInputMutex.Unlock() 1457 fake.GetBuildsWithVersionAsInputStub = nil 1458 if fake.getBuildsWithVersionAsInputReturnsOnCall == nil { 1459 fake.getBuildsWithVersionAsInputReturnsOnCall = make(map[int]struct { 1460 result1 []db.Build 1461 result2 error 1462 }) 1463 } 1464 fake.getBuildsWithVersionAsInputReturnsOnCall[i] = struct { 1465 result1 []db.Build 1466 result2 error 1467 }{result1, result2} 1468} 1469 1470func (fake *FakePipeline) GetBuildsWithVersionAsOutput(arg1 int, arg2 int) ([]db.Build, error) { 1471 fake.getBuildsWithVersionAsOutputMutex.Lock() 1472 ret, specificReturn := fake.getBuildsWithVersionAsOutputReturnsOnCall[len(fake.getBuildsWithVersionAsOutputArgsForCall)] 1473 fake.getBuildsWithVersionAsOutputArgsForCall = append(fake.getBuildsWithVersionAsOutputArgsForCall, struct { 1474 arg1 int 1475 arg2 int 1476 }{arg1, arg2}) 1477 fake.recordInvocation("GetBuildsWithVersionAsOutput", []interface{}{arg1, arg2}) 1478 fake.getBuildsWithVersionAsOutputMutex.Unlock() 1479 if fake.GetBuildsWithVersionAsOutputStub != nil { 1480 return fake.GetBuildsWithVersionAsOutputStub(arg1, arg2) 1481 } 1482 if specificReturn { 1483 return ret.result1, ret.result2 1484 } 1485 fakeReturns := fake.getBuildsWithVersionAsOutputReturns 1486 return fakeReturns.result1, fakeReturns.result2 1487} 1488 1489func (fake *FakePipeline) GetBuildsWithVersionAsOutputCallCount() int { 1490 fake.getBuildsWithVersionAsOutputMutex.RLock() 1491 defer fake.getBuildsWithVersionAsOutputMutex.RUnlock() 1492 return len(fake.getBuildsWithVersionAsOutputArgsForCall) 1493} 1494 1495func (fake *FakePipeline) GetBuildsWithVersionAsOutputCalls(stub func(int, int) ([]db.Build, error)) { 1496 fake.getBuildsWithVersionAsOutputMutex.Lock() 1497 defer fake.getBuildsWithVersionAsOutputMutex.Unlock() 1498 fake.GetBuildsWithVersionAsOutputStub = stub 1499} 1500 1501func (fake *FakePipeline) GetBuildsWithVersionAsOutputArgsForCall(i int) (int, int) { 1502 fake.getBuildsWithVersionAsOutputMutex.RLock() 1503 defer fake.getBuildsWithVersionAsOutputMutex.RUnlock() 1504 argsForCall := fake.getBuildsWithVersionAsOutputArgsForCall[i] 1505 return argsForCall.arg1, argsForCall.arg2 1506} 1507 1508func (fake *FakePipeline) GetBuildsWithVersionAsOutputReturns(result1 []db.Build, result2 error) { 1509 fake.getBuildsWithVersionAsOutputMutex.Lock() 1510 defer fake.getBuildsWithVersionAsOutputMutex.Unlock() 1511 fake.GetBuildsWithVersionAsOutputStub = nil 1512 fake.getBuildsWithVersionAsOutputReturns = struct { 1513 result1 []db.Build 1514 result2 error 1515 }{result1, result2} 1516} 1517 1518func (fake *FakePipeline) GetBuildsWithVersionAsOutputReturnsOnCall(i int, result1 []db.Build, result2 error) { 1519 fake.getBuildsWithVersionAsOutputMutex.Lock() 1520 defer fake.getBuildsWithVersionAsOutputMutex.Unlock() 1521 fake.GetBuildsWithVersionAsOutputStub = nil 1522 if fake.getBuildsWithVersionAsOutputReturnsOnCall == nil { 1523 fake.getBuildsWithVersionAsOutputReturnsOnCall = make(map[int]struct { 1524 result1 []db.Build 1525 result2 error 1526 }) 1527 } 1528 fake.getBuildsWithVersionAsOutputReturnsOnCall[i] = struct { 1529 result1 []db.Build 1530 result2 error 1531 }{result1, result2} 1532} 1533 1534func (fake *FakePipeline) Groups() atc.GroupConfigs { 1535 fake.groupsMutex.Lock() 1536 ret, specificReturn := fake.groupsReturnsOnCall[len(fake.groupsArgsForCall)] 1537 fake.groupsArgsForCall = append(fake.groupsArgsForCall, struct { 1538 }{}) 1539 fake.recordInvocation("Groups", []interface{}{}) 1540 fake.groupsMutex.Unlock() 1541 if fake.GroupsStub != nil { 1542 return fake.GroupsStub() 1543 } 1544 if specificReturn { 1545 return ret.result1 1546 } 1547 fakeReturns := fake.groupsReturns 1548 return fakeReturns.result1 1549} 1550 1551func (fake *FakePipeline) GroupsCallCount() int { 1552 fake.groupsMutex.RLock() 1553 defer fake.groupsMutex.RUnlock() 1554 return len(fake.groupsArgsForCall) 1555} 1556 1557func (fake *FakePipeline) GroupsCalls(stub func() atc.GroupConfigs) { 1558 fake.groupsMutex.Lock() 1559 defer fake.groupsMutex.Unlock() 1560 fake.GroupsStub = stub 1561} 1562 1563func (fake *FakePipeline) GroupsReturns(result1 atc.GroupConfigs) { 1564 fake.groupsMutex.Lock() 1565 defer fake.groupsMutex.Unlock() 1566 fake.GroupsStub = nil 1567 fake.groupsReturns = struct { 1568 result1 atc.GroupConfigs 1569 }{result1} 1570} 1571 1572func (fake *FakePipeline) GroupsReturnsOnCall(i int, result1 atc.GroupConfigs) { 1573 fake.groupsMutex.Lock() 1574 defer fake.groupsMutex.Unlock() 1575 fake.GroupsStub = nil 1576 if fake.groupsReturnsOnCall == nil { 1577 fake.groupsReturnsOnCall = make(map[int]struct { 1578 result1 atc.GroupConfigs 1579 }) 1580 } 1581 fake.groupsReturnsOnCall[i] = struct { 1582 result1 atc.GroupConfigs 1583 }{result1} 1584} 1585 1586func (fake *FakePipeline) Hide() error { 1587 fake.hideMutex.Lock() 1588 ret, specificReturn := fake.hideReturnsOnCall[len(fake.hideArgsForCall)] 1589 fake.hideArgsForCall = append(fake.hideArgsForCall, struct { 1590 }{}) 1591 fake.recordInvocation("Hide", []interface{}{}) 1592 fake.hideMutex.Unlock() 1593 if fake.HideStub != nil { 1594 return fake.HideStub() 1595 } 1596 if specificReturn { 1597 return ret.result1 1598 } 1599 fakeReturns := fake.hideReturns 1600 return fakeReturns.result1 1601} 1602 1603func (fake *FakePipeline) HideCallCount() int { 1604 fake.hideMutex.RLock() 1605 defer fake.hideMutex.RUnlock() 1606 return len(fake.hideArgsForCall) 1607} 1608 1609func (fake *FakePipeline) HideCalls(stub func() error) { 1610 fake.hideMutex.Lock() 1611 defer fake.hideMutex.Unlock() 1612 fake.HideStub = stub 1613} 1614 1615func (fake *FakePipeline) HideReturns(result1 error) { 1616 fake.hideMutex.Lock() 1617 defer fake.hideMutex.Unlock() 1618 fake.HideStub = nil 1619 fake.hideReturns = struct { 1620 result1 error 1621 }{result1} 1622} 1623 1624func (fake *FakePipeline) HideReturnsOnCall(i int, result1 error) { 1625 fake.hideMutex.Lock() 1626 defer fake.hideMutex.Unlock() 1627 fake.HideStub = nil 1628 if fake.hideReturnsOnCall == nil { 1629 fake.hideReturnsOnCall = make(map[int]struct { 1630 result1 error 1631 }) 1632 } 1633 fake.hideReturnsOnCall[i] = struct { 1634 result1 error 1635 }{result1} 1636} 1637 1638func (fake *FakePipeline) ID() int { 1639 fake.iDMutex.Lock() 1640 ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)] 1641 fake.iDArgsForCall = append(fake.iDArgsForCall, struct { 1642 }{}) 1643 fake.recordInvocation("ID", []interface{}{}) 1644 fake.iDMutex.Unlock() 1645 if fake.IDStub != nil { 1646 return fake.IDStub() 1647 } 1648 if specificReturn { 1649 return ret.result1 1650 } 1651 fakeReturns := fake.iDReturns 1652 return fakeReturns.result1 1653} 1654 1655func (fake *FakePipeline) IDCallCount() int { 1656 fake.iDMutex.RLock() 1657 defer fake.iDMutex.RUnlock() 1658 return len(fake.iDArgsForCall) 1659} 1660 1661func (fake *FakePipeline) IDCalls(stub func() int) { 1662 fake.iDMutex.Lock() 1663 defer fake.iDMutex.Unlock() 1664 fake.IDStub = stub 1665} 1666 1667func (fake *FakePipeline) IDReturns(result1 int) { 1668 fake.iDMutex.Lock() 1669 defer fake.iDMutex.Unlock() 1670 fake.IDStub = nil 1671 fake.iDReturns = struct { 1672 result1 int 1673 }{result1} 1674} 1675 1676func (fake *FakePipeline) IDReturnsOnCall(i int, result1 int) { 1677 fake.iDMutex.Lock() 1678 defer fake.iDMutex.Unlock() 1679 fake.IDStub = nil 1680 if fake.iDReturnsOnCall == nil { 1681 fake.iDReturnsOnCall = make(map[int]struct { 1682 result1 int 1683 }) 1684 } 1685 fake.iDReturnsOnCall[i] = struct { 1686 result1 int 1687 }{result1} 1688} 1689 1690func (fake *FakePipeline) Job(arg1 string) (db.Job, bool, error) { 1691 fake.jobMutex.Lock() 1692 ret, specificReturn := fake.jobReturnsOnCall[len(fake.jobArgsForCall)] 1693 fake.jobArgsForCall = append(fake.jobArgsForCall, struct { 1694 arg1 string 1695 }{arg1}) 1696 fake.recordInvocation("Job", []interface{}{arg1}) 1697 fake.jobMutex.Unlock() 1698 if fake.JobStub != nil { 1699 return fake.JobStub(arg1) 1700 } 1701 if specificReturn { 1702 return ret.result1, ret.result2, ret.result3 1703 } 1704 fakeReturns := fake.jobReturns 1705 return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 1706} 1707 1708func (fake *FakePipeline) JobCallCount() int { 1709 fake.jobMutex.RLock() 1710 defer fake.jobMutex.RUnlock() 1711 return len(fake.jobArgsForCall) 1712} 1713 1714func (fake *FakePipeline) JobCalls(stub func(string) (db.Job, bool, error)) { 1715 fake.jobMutex.Lock() 1716 defer fake.jobMutex.Unlock() 1717 fake.JobStub = stub 1718} 1719 1720func (fake *FakePipeline) JobArgsForCall(i int) string { 1721 fake.jobMutex.RLock() 1722 defer fake.jobMutex.RUnlock() 1723 argsForCall := fake.jobArgsForCall[i] 1724 return argsForCall.arg1 1725} 1726 1727func (fake *FakePipeline) JobReturns(result1 db.Job, result2 bool, result3 error) { 1728 fake.jobMutex.Lock() 1729 defer fake.jobMutex.Unlock() 1730 fake.JobStub = nil 1731 fake.jobReturns = struct { 1732 result1 db.Job 1733 result2 bool 1734 result3 error 1735 }{result1, result2, result3} 1736} 1737 1738func (fake *FakePipeline) JobReturnsOnCall(i int, result1 db.Job, result2 bool, result3 error) { 1739 fake.jobMutex.Lock() 1740 defer fake.jobMutex.Unlock() 1741 fake.JobStub = nil 1742 if fake.jobReturnsOnCall == nil { 1743 fake.jobReturnsOnCall = make(map[int]struct { 1744 result1 db.Job 1745 result2 bool 1746 result3 error 1747 }) 1748 } 1749 fake.jobReturnsOnCall[i] = struct { 1750 result1 db.Job 1751 result2 bool 1752 result3 error 1753 }{result1, result2, result3} 1754} 1755 1756func (fake *FakePipeline) Jobs() (db.Jobs, error) { 1757 fake.jobsMutex.Lock() 1758 ret, specificReturn := fake.jobsReturnsOnCall[len(fake.jobsArgsForCall)] 1759 fake.jobsArgsForCall = append(fake.jobsArgsForCall, struct { 1760 }{}) 1761 fake.recordInvocation("Jobs", []interface{}{}) 1762 fake.jobsMutex.Unlock() 1763 if fake.JobsStub != nil { 1764 return fake.JobsStub() 1765 } 1766 if specificReturn { 1767 return ret.result1, ret.result2 1768 } 1769 fakeReturns := fake.jobsReturns 1770 return fakeReturns.result1, fakeReturns.result2 1771} 1772 1773func (fake *FakePipeline) JobsCallCount() int { 1774 fake.jobsMutex.RLock() 1775 defer fake.jobsMutex.RUnlock() 1776 return len(fake.jobsArgsForCall) 1777} 1778 1779func (fake *FakePipeline) JobsCalls(stub func() (db.Jobs, error)) { 1780 fake.jobsMutex.Lock() 1781 defer fake.jobsMutex.Unlock() 1782 fake.JobsStub = stub 1783} 1784 1785func (fake *FakePipeline) JobsReturns(result1 db.Jobs, result2 error) { 1786 fake.jobsMutex.Lock() 1787 defer fake.jobsMutex.Unlock() 1788 fake.JobsStub = nil 1789 fake.jobsReturns = struct { 1790 result1 db.Jobs 1791 result2 error 1792 }{result1, result2} 1793} 1794 1795func (fake *FakePipeline) JobsReturnsOnCall(i int, result1 db.Jobs, result2 error) { 1796 fake.jobsMutex.Lock() 1797 defer fake.jobsMutex.Unlock() 1798 fake.JobsStub = nil 1799 if fake.jobsReturnsOnCall == nil { 1800 fake.jobsReturnsOnCall = make(map[int]struct { 1801 result1 db.Jobs 1802 result2 error 1803 }) 1804 } 1805 fake.jobsReturnsOnCall[i] = struct { 1806 result1 db.Jobs 1807 result2 error 1808 }{result1, result2} 1809} 1810 1811func (fake *FakePipeline) LastUpdated() time.Time { 1812 fake.lastUpdatedMutex.Lock() 1813 ret, specificReturn := fake.lastUpdatedReturnsOnCall[len(fake.lastUpdatedArgsForCall)] 1814 fake.lastUpdatedArgsForCall = append(fake.lastUpdatedArgsForCall, struct { 1815 }{}) 1816 fake.recordInvocation("LastUpdated", []interface{}{}) 1817 fake.lastUpdatedMutex.Unlock() 1818 if fake.LastUpdatedStub != nil { 1819 return fake.LastUpdatedStub() 1820 } 1821 if specificReturn { 1822 return ret.result1 1823 } 1824 fakeReturns := fake.lastUpdatedReturns 1825 return fakeReturns.result1 1826} 1827 1828func (fake *FakePipeline) LastUpdatedCallCount() int { 1829 fake.lastUpdatedMutex.RLock() 1830 defer fake.lastUpdatedMutex.RUnlock() 1831 return len(fake.lastUpdatedArgsForCall) 1832} 1833 1834func (fake *FakePipeline) LastUpdatedCalls(stub func() time.Time) { 1835 fake.lastUpdatedMutex.Lock() 1836 defer fake.lastUpdatedMutex.Unlock() 1837 fake.LastUpdatedStub = stub 1838} 1839 1840func (fake *FakePipeline) LastUpdatedReturns(result1 time.Time) { 1841 fake.lastUpdatedMutex.Lock() 1842 defer fake.lastUpdatedMutex.Unlock() 1843 fake.LastUpdatedStub = nil 1844 fake.lastUpdatedReturns = struct { 1845 result1 time.Time 1846 }{result1} 1847} 1848 1849func (fake *FakePipeline) LastUpdatedReturnsOnCall(i int, result1 time.Time) { 1850 fake.lastUpdatedMutex.Lock() 1851 defer fake.lastUpdatedMutex.Unlock() 1852 fake.LastUpdatedStub = nil 1853 if fake.lastUpdatedReturnsOnCall == nil { 1854 fake.lastUpdatedReturnsOnCall = make(map[int]struct { 1855 result1 time.Time 1856 }) 1857 } 1858 fake.lastUpdatedReturnsOnCall[i] = struct { 1859 result1 time.Time 1860 }{result1} 1861} 1862 1863func (fake *FakePipeline) LoadDebugVersionsDB() (*atc.DebugVersionsDB, error) { 1864 fake.loadDebugVersionsDBMutex.Lock() 1865 ret, specificReturn := fake.loadDebugVersionsDBReturnsOnCall[len(fake.loadDebugVersionsDBArgsForCall)] 1866 fake.loadDebugVersionsDBArgsForCall = append(fake.loadDebugVersionsDBArgsForCall, struct { 1867 }{}) 1868 fake.recordInvocation("LoadDebugVersionsDB", []interface{}{}) 1869 fake.loadDebugVersionsDBMutex.Unlock() 1870 if fake.LoadDebugVersionsDBStub != nil { 1871 return fake.LoadDebugVersionsDBStub() 1872 } 1873 if specificReturn { 1874 return ret.result1, ret.result2 1875 } 1876 fakeReturns := fake.loadDebugVersionsDBReturns 1877 return fakeReturns.result1, fakeReturns.result2 1878} 1879 1880func (fake *FakePipeline) LoadDebugVersionsDBCallCount() int { 1881 fake.loadDebugVersionsDBMutex.RLock() 1882 defer fake.loadDebugVersionsDBMutex.RUnlock() 1883 return len(fake.loadDebugVersionsDBArgsForCall) 1884} 1885 1886func (fake *FakePipeline) LoadDebugVersionsDBCalls(stub func() (*atc.DebugVersionsDB, error)) { 1887 fake.loadDebugVersionsDBMutex.Lock() 1888 defer fake.loadDebugVersionsDBMutex.Unlock() 1889 fake.LoadDebugVersionsDBStub = stub 1890} 1891 1892func (fake *FakePipeline) LoadDebugVersionsDBReturns(result1 *atc.DebugVersionsDB, result2 error) { 1893 fake.loadDebugVersionsDBMutex.Lock() 1894 defer fake.loadDebugVersionsDBMutex.Unlock() 1895 fake.LoadDebugVersionsDBStub = nil 1896 fake.loadDebugVersionsDBReturns = struct { 1897 result1 *atc.DebugVersionsDB 1898 result2 error 1899 }{result1, result2} 1900} 1901 1902func (fake *FakePipeline) LoadDebugVersionsDBReturnsOnCall(i int, result1 *atc.DebugVersionsDB, result2 error) { 1903 fake.loadDebugVersionsDBMutex.Lock() 1904 defer fake.loadDebugVersionsDBMutex.Unlock() 1905 fake.LoadDebugVersionsDBStub = nil 1906 if fake.loadDebugVersionsDBReturnsOnCall == nil { 1907 fake.loadDebugVersionsDBReturnsOnCall = make(map[int]struct { 1908 result1 *atc.DebugVersionsDB 1909 result2 error 1910 }) 1911 } 1912 fake.loadDebugVersionsDBReturnsOnCall[i] = struct { 1913 result1 *atc.DebugVersionsDB 1914 result2 error 1915 }{result1, result2} 1916} 1917 1918func (fake *FakePipeline) Name() string { 1919 fake.nameMutex.Lock() 1920 ret, specificReturn := fake.nameReturnsOnCall[len(fake.nameArgsForCall)] 1921 fake.nameArgsForCall = append(fake.nameArgsForCall, struct { 1922 }{}) 1923 fake.recordInvocation("Name", []interface{}{}) 1924 fake.nameMutex.Unlock() 1925 if fake.NameStub != nil { 1926 return fake.NameStub() 1927 } 1928 if specificReturn { 1929 return ret.result1 1930 } 1931 fakeReturns := fake.nameReturns 1932 return fakeReturns.result1 1933} 1934 1935func (fake *FakePipeline) NameCallCount() int { 1936 fake.nameMutex.RLock() 1937 defer fake.nameMutex.RUnlock() 1938 return len(fake.nameArgsForCall) 1939} 1940 1941func (fake *FakePipeline) NameCalls(stub func() string) { 1942 fake.nameMutex.Lock() 1943 defer fake.nameMutex.Unlock() 1944 fake.NameStub = stub 1945} 1946 1947func (fake *FakePipeline) NameReturns(result1 string) { 1948 fake.nameMutex.Lock() 1949 defer fake.nameMutex.Unlock() 1950 fake.NameStub = nil 1951 fake.nameReturns = struct { 1952 result1 string 1953 }{result1} 1954} 1955 1956func (fake *FakePipeline) NameReturnsOnCall(i int, result1 string) { 1957 fake.nameMutex.Lock() 1958 defer fake.nameMutex.Unlock() 1959 fake.NameStub = nil 1960 if fake.nameReturnsOnCall == nil { 1961 fake.nameReturnsOnCall = make(map[int]struct { 1962 result1 string 1963 }) 1964 } 1965 fake.nameReturnsOnCall[i] = struct { 1966 result1 string 1967 }{result1} 1968} 1969 1970func (fake *FakePipeline) ParentBuildID() int { 1971 fake.parentBuildIDMutex.Lock() 1972 ret, specificReturn := fake.parentBuildIDReturnsOnCall[len(fake.parentBuildIDArgsForCall)] 1973 fake.parentBuildIDArgsForCall = append(fake.parentBuildIDArgsForCall, struct { 1974 }{}) 1975 fake.recordInvocation("ParentBuildID", []interface{}{}) 1976 fake.parentBuildIDMutex.Unlock() 1977 if fake.ParentBuildIDStub != nil { 1978 return fake.ParentBuildIDStub() 1979 } 1980 if specificReturn { 1981 return ret.result1 1982 } 1983 fakeReturns := fake.parentBuildIDReturns 1984 return fakeReturns.result1 1985} 1986 1987func (fake *FakePipeline) ParentBuildIDCallCount() int { 1988 fake.parentBuildIDMutex.RLock() 1989 defer fake.parentBuildIDMutex.RUnlock() 1990 return len(fake.parentBuildIDArgsForCall) 1991} 1992 1993func (fake *FakePipeline) ParentBuildIDCalls(stub func() int) { 1994 fake.parentBuildIDMutex.Lock() 1995 defer fake.parentBuildIDMutex.Unlock() 1996 fake.ParentBuildIDStub = stub 1997} 1998 1999func (fake *FakePipeline) ParentBuildIDReturns(result1 int) { 2000 fake.parentBuildIDMutex.Lock() 2001 defer fake.parentBuildIDMutex.Unlock() 2002 fake.ParentBuildIDStub = nil 2003 fake.parentBuildIDReturns = struct { 2004 result1 int 2005 }{result1} 2006} 2007 2008func (fake *FakePipeline) ParentBuildIDReturnsOnCall(i int, result1 int) { 2009 fake.parentBuildIDMutex.Lock() 2010 defer fake.parentBuildIDMutex.Unlock() 2011 fake.ParentBuildIDStub = nil 2012 if fake.parentBuildIDReturnsOnCall == nil { 2013 fake.parentBuildIDReturnsOnCall = make(map[int]struct { 2014 result1 int 2015 }) 2016 } 2017 fake.parentBuildIDReturnsOnCall[i] = struct { 2018 result1 int 2019 }{result1} 2020} 2021 2022func (fake *FakePipeline) ParentJobID() int { 2023 fake.parentJobIDMutex.Lock() 2024 ret, specificReturn := fake.parentJobIDReturnsOnCall[len(fake.parentJobIDArgsForCall)] 2025 fake.parentJobIDArgsForCall = append(fake.parentJobIDArgsForCall, struct { 2026 }{}) 2027 fake.recordInvocation("ParentJobID", []interface{}{}) 2028 fake.parentJobIDMutex.Unlock() 2029 if fake.ParentJobIDStub != nil { 2030 return fake.ParentJobIDStub() 2031 } 2032 if specificReturn { 2033 return ret.result1 2034 } 2035 fakeReturns := fake.parentJobIDReturns 2036 return fakeReturns.result1 2037} 2038 2039func (fake *FakePipeline) ParentJobIDCallCount() int { 2040 fake.parentJobIDMutex.RLock() 2041 defer fake.parentJobIDMutex.RUnlock() 2042 return len(fake.parentJobIDArgsForCall) 2043} 2044 2045func (fake *FakePipeline) ParentJobIDCalls(stub func() int) { 2046 fake.parentJobIDMutex.Lock() 2047 defer fake.parentJobIDMutex.Unlock() 2048 fake.ParentJobIDStub = stub 2049} 2050 2051func (fake *FakePipeline) ParentJobIDReturns(result1 int) { 2052 fake.parentJobIDMutex.Lock() 2053 defer fake.parentJobIDMutex.Unlock() 2054 fake.ParentJobIDStub = nil 2055 fake.parentJobIDReturns = struct { 2056 result1 int 2057 }{result1} 2058} 2059 2060func (fake *FakePipeline) ParentJobIDReturnsOnCall(i int, result1 int) { 2061 fake.parentJobIDMutex.Lock() 2062 defer fake.parentJobIDMutex.Unlock() 2063 fake.ParentJobIDStub = nil 2064 if fake.parentJobIDReturnsOnCall == nil { 2065 fake.parentJobIDReturnsOnCall = make(map[int]struct { 2066 result1 int 2067 }) 2068 } 2069 fake.parentJobIDReturnsOnCall[i] = struct { 2070 result1 int 2071 }{result1} 2072} 2073 2074func (fake *FakePipeline) Pause() error { 2075 fake.pauseMutex.Lock() 2076 ret, specificReturn := fake.pauseReturnsOnCall[len(fake.pauseArgsForCall)] 2077 fake.pauseArgsForCall = append(fake.pauseArgsForCall, struct { 2078 }{}) 2079 fake.recordInvocation("Pause", []interface{}{}) 2080 fake.pauseMutex.Unlock() 2081 if fake.PauseStub != nil { 2082 return fake.PauseStub() 2083 } 2084 if specificReturn { 2085 return ret.result1 2086 } 2087 fakeReturns := fake.pauseReturns 2088 return fakeReturns.result1 2089} 2090 2091func (fake *FakePipeline) PauseCallCount() int { 2092 fake.pauseMutex.RLock() 2093 defer fake.pauseMutex.RUnlock() 2094 return len(fake.pauseArgsForCall) 2095} 2096 2097func (fake *FakePipeline) PauseCalls(stub func() error) { 2098 fake.pauseMutex.Lock() 2099 defer fake.pauseMutex.Unlock() 2100 fake.PauseStub = stub 2101} 2102 2103func (fake *FakePipeline) PauseReturns(result1 error) { 2104 fake.pauseMutex.Lock() 2105 defer fake.pauseMutex.Unlock() 2106 fake.PauseStub = nil 2107 fake.pauseReturns = struct { 2108 result1 error 2109 }{result1} 2110} 2111 2112func (fake *FakePipeline) PauseReturnsOnCall(i int, result1 error) { 2113 fake.pauseMutex.Lock() 2114 defer fake.pauseMutex.Unlock() 2115 fake.PauseStub = nil 2116 if fake.pauseReturnsOnCall == nil { 2117 fake.pauseReturnsOnCall = make(map[int]struct { 2118 result1 error 2119 }) 2120 } 2121 fake.pauseReturnsOnCall[i] = struct { 2122 result1 error 2123 }{result1} 2124} 2125 2126func (fake *FakePipeline) Paused() bool { 2127 fake.pausedMutex.Lock() 2128 ret, specificReturn := fake.pausedReturnsOnCall[len(fake.pausedArgsForCall)] 2129 fake.pausedArgsForCall = append(fake.pausedArgsForCall, struct { 2130 }{}) 2131 fake.recordInvocation("Paused", []interface{}{}) 2132 fake.pausedMutex.Unlock() 2133 if fake.PausedStub != nil { 2134 return fake.PausedStub() 2135 } 2136 if specificReturn { 2137 return ret.result1 2138 } 2139 fakeReturns := fake.pausedReturns 2140 return fakeReturns.result1 2141} 2142 2143func (fake *FakePipeline) PausedCallCount() int { 2144 fake.pausedMutex.RLock() 2145 defer fake.pausedMutex.RUnlock() 2146 return len(fake.pausedArgsForCall) 2147} 2148 2149func (fake *FakePipeline) PausedCalls(stub func() bool) { 2150 fake.pausedMutex.Lock() 2151 defer fake.pausedMutex.Unlock() 2152 fake.PausedStub = stub 2153} 2154 2155func (fake *FakePipeline) PausedReturns(result1 bool) { 2156 fake.pausedMutex.Lock() 2157 defer fake.pausedMutex.Unlock() 2158 fake.PausedStub = nil 2159 fake.pausedReturns = struct { 2160 result1 bool 2161 }{result1} 2162} 2163 2164func (fake *FakePipeline) PausedReturnsOnCall(i int, result1 bool) { 2165 fake.pausedMutex.Lock() 2166 defer fake.pausedMutex.Unlock() 2167 fake.PausedStub = nil 2168 if fake.pausedReturnsOnCall == nil { 2169 fake.pausedReturnsOnCall = make(map[int]struct { 2170 result1 bool 2171 }) 2172 } 2173 fake.pausedReturnsOnCall[i] = struct { 2174 result1 bool 2175 }{result1} 2176} 2177 2178func (fake *FakePipeline) Public() bool { 2179 fake.publicMutex.Lock() 2180 ret, specificReturn := fake.publicReturnsOnCall[len(fake.publicArgsForCall)] 2181 fake.publicArgsForCall = append(fake.publicArgsForCall, struct { 2182 }{}) 2183 fake.recordInvocation("Public", []interface{}{}) 2184 fake.publicMutex.Unlock() 2185 if fake.PublicStub != nil { 2186 return fake.PublicStub() 2187 } 2188 if specificReturn { 2189 return ret.result1 2190 } 2191 fakeReturns := fake.publicReturns 2192 return fakeReturns.result1 2193} 2194 2195func (fake *FakePipeline) PublicCallCount() int { 2196 fake.publicMutex.RLock() 2197 defer fake.publicMutex.RUnlock() 2198 return len(fake.publicArgsForCall) 2199} 2200 2201func (fake *FakePipeline) PublicCalls(stub func() bool) { 2202 fake.publicMutex.Lock() 2203 defer fake.publicMutex.Unlock() 2204 fake.PublicStub = stub 2205} 2206 2207func (fake *FakePipeline) PublicReturns(result1 bool) { 2208 fake.publicMutex.Lock() 2209 defer fake.publicMutex.Unlock() 2210 fake.PublicStub = nil 2211 fake.publicReturns = struct { 2212 result1 bool 2213 }{result1} 2214} 2215 2216func (fake *FakePipeline) PublicReturnsOnCall(i int, result1 bool) { 2217 fake.publicMutex.Lock() 2218 defer fake.publicMutex.Unlock() 2219 fake.PublicStub = nil 2220 if fake.publicReturnsOnCall == nil { 2221 fake.publicReturnsOnCall = make(map[int]struct { 2222 result1 bool 2223 }) 2224 } 2225 fake.publicReturnsOnCall[i] = struct { 2226 result1 bool 2227 }{result1} 2228} 2229 2230func (fake *FakePipeline) Reload() (bool, error) { 2231 fake.reloadMutex.Lock() 2232 ret, specificReturn := fake.reloadReturnsOnCall[len(fake.reloadArgsForCall)] 2233 fake.reloadArgsForCall = append(fake.reloadArgsForCall, struct { 2234 }{}) 2235 fake.recordInvocation("Reload", []interface{}{}) 2236 fake.reloadMutex.Unlock() 2237 if fake.ReloadStub != nil { 2238 return fake.ReloadStub() 2239 } 2240 if specificReturn { 2241 return ret.result1, ret.result2 2242 } 2243 fakeReturns := fake.reloadReturns 2244 return fakeReturns.result1, fakeReturns.result2 2245} 2246 2247func (fake *FakePipeline) ReloadCallCount() int { 2248 fake.reloadMutex.RLock() 2249 defer fake.reloadMutex.RUnlock() 2250 return len(fake.reloadArgsForCall) 2251} 2252 2253func (fake *FakePipeline) ReloadCalls(stub func() (bool, error)) { 2254 fake.reloadMutex.Lock() 2255 defer fake.reloadMutex.Unlock() 2256 fake.ReloadStub = stub 2257} 2258 2259func (fake *FakePipeline) ReloadReturns(result1 bool, result2 error) { 2260 fake.reloadMutex.Lock() 2261 defer fake.reloadMutex.Unlock() 2262 fake.ReloadStub = nil 2263 fake.reloadReturns = struct { 2264 result1 bool 2265 result2 error 2266 }{result1, result2} 2267} 2268 2269func (fake *FakePipeline) ReloadReturnsOnCall(i int, result1 bool, result2 error) { 2270 fake.reloadMutex.Lock() 2271 defer fake.reloadMutex.Unlock() 2272 fake.ReloadStub = nil 2273 if fake.reloadReturnsOnCall == nil { 2274 fake.reloadReturnsOnCall = make(map[int]struct { 2275 result1 bool 2276 result2 error 2277 }) 2278 } 2279 fake.reloadReturnsOnCall[i] = struct { 2280 result1 bool 2281 result2 error 2282 }{result1, result2} 2283} 2284 2285func (fake *FakePipeline) Rename(arg1 string) error { 2286 fake.renameMutex.Lock() 2287 ret, specificReturn := fake.renameReturnsOnCall[len(fake.renameArgsForCall)] 2288 fake.renameArgsForCall = append(fake.renameArgsForCall, struct { 2289 arg1 string 2290 }{arg1}) 2291 fake.recordInvocation("Rename", []interface{}{arg1}) 2292 fake.renameMutex.Unlock() 2293 if fake.RenameStub != nil { 2294 return fake.RenameStub(arg1) 2295 } 2296 if specificReturn { 2297 return ret.result1 2298 } 2299 fakeReturns := fake.renameReturns 2300 return fakeReturns.result1 2301} 2302 2303func (fake *FakePipeline) RenameCallCount() int { 2304 fake.renameMutex.RLock() 2305 defer fake.renameMutex.RUnlock() 2306 return len(fake.renameArgsForCall) 2307} 2308 2309func (fake *FakePipeline) RenameCalls(stub func(string) error) { 2310 fake.renameMutex.Lock() 2311 defer fake.renameMutex.Unlock() 2312 fake.RenameStub = stub 2313} 2314 2315func (fake *FakePipeline) RenameArgsForCall(i int) string { 2316 fake.renameMutex.RLock() 2317 defer fake.renameMutex.RUnlock() 2318 argsForCall := fake.renameArgsForCall[i] 2319 return argsForCall.arg1 2320} 2321 2322func (fake *FakePipeline) RenameReturns(result1 error) { 2323 fake.renameMutex.Lock() 2324 defer fake.renameMutex.Unlock() 2325 fake.RenameStub = nil 2326 fake.renameReturns = struct { 2327 result1 error 2328 }{result1} 2329} 2330 2331func (fake *FakePipeline) RenameReturnsOnCall(i int, result1 error) { 2332 fake.renameMutex.Lock() 2333 defer fake.renameMutex.Unlock() 2334 fake.RenameStub = nil 2335 if fake.renameReturnsOnCall == nil { 2336 fake.renameReturnsOnCall = make(map[int]struct { 2337 result1 error 2338 }) 2339 } 2340 fake.renameReturnsOnCall[i] = struct { 2341 result1 error 2342 }{result1} 2343} 2344 2345func (fake *FakePipeline) Resource(arg1 string) (db.Resource, bool, error) { 2346 fake.resourceMutex.Lock() 2347 ret, specificReturn := fake.resourceReturnsOnCall[len(fake.resourceArgsForCall)] 2348 fake.resourceArgsForCall = append(fake.resourceArgsForCall, struct { 2349 arg1 string 2350 }{arg1}) 2351 fake.recordInvocation("Resource", []interface{}{arg1}) 2352 fake.resourceMutex.Unlock() 2353 if fake.ResourceStub != nil { 2354 return fake.ResourceStub(arg1) 2355 } 2356 if specificReturn { 2357 return ret.result1, ret.result2, ret.result3 2358 } 2359 fakeReturns := fake.resourceReturns 2360 return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 2361} 2362 2363func (fake *FakePipeline) ResourceCallCount() int { 2364 fake.resourceMutex.RLock() 2365 defer fake.resourceMutex.RUnlock() 2366 return len(fake.resourceArgsForCall) 2367} 2368 2369func (fake *FakePipeline) ResourceCalls(stub func(string) (db.Resource, bool, error)) { 2370 fake.resourceMutex.Lock() 2371 defer fake.resourceMutex.Unlock() 2372 fake.ResourceStub = stub 2373} 2374 2375func (fake *FakePipeline) ResourceArgsForCall(i int) string { 2376 fake.resourceMutex.RLock() 2377 defer fake.resourceMutex.RUnlock() 2378 argsForCall := fake.resourceArgsForCall[i] 2379 return argsForCall.arg1 2380} 2381 2382func (fake *FakePipeline) ResourceReturns(result1 db.Resource, result2 bool, result3 error) { 2383 fake.resourceMutex.Lock() 2384 defer fake.resourceMutex.Unlock() 2385 fake.ResourceStub = nil 2386 fake.resourceReturns = struct { 2387 result1 db.Resource 2388 result2 bool 2389 result3 error 2390 }{result1, result2, result3} 2391} 2392 2393func (fake *FakePipeline) ResourceReturnsOnCall(i int, result1 db.Resource, result2 bool, result3 error) { 2394 fake.resourceMutex.Lock() 2395 defer fake.resourceMutex.Unlock() 2396 fake.ResourceStub = nil 2397 if fake.resourceReturnsOnCall == nil { 2398 fake.resourceReturnsOnCall = make(map[int]struct { 2399 result1 db.Resource 2400 result2 bool 2401 result3 error 2402 }) 2403 } 2404 fake.resourceReturnsOnCall[i] = struct { 2405 result1 db.Resource 2406 result2 bool 2407 result3 error 2408 }{result1, result2, result3} 2409} 2410 2411func (fake *FakePipeline) ResourceByID(arg1 int) (db.Resource, bool, error) { 2412 fake.resourceByIDMutex.Lock() 2413 ret, specificReturn := fake.resourceByIDReturnsOnCall[len(fake.resourceByIDArgsForCall)] 2414 fake.resourceByIDArgsForCall = append(fake.resourceByIDArgsForCall, struct { 2415 arg1 int 2416 }{arg1}) 2417 fake.recordInvocation("ResourceByID", []interface{}{arg1}) 2418 fake.resourceByIDMutex.Unlock() 2419 if fake.ResourceByIDStub != nil { 2420 return fake.ResourceByIDStub(arg1) 2421 } 2422 if specificReturn { 2423 return ret.result1, ret.result2, ret.result3 2424 } 2425 fakeReturns := fake.resourceByIDReturns 2426 return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 2427} 2428 2429func (fake *FakePipeline) ResourceByIDCallCount() int { 2430 fake.resourceByIDMutex.RLock() 2431 defer fake.resourceByIDMutex.RUnlock() 2432 return len(fake.resourceByIDArgsForCall) 2433} 2434 2435func (fake *FakePipeline) ResourceByIDCalls(stub func(int) (db.Resource, bool, error)) { 2436 fake.resourceByIDMutex.Lock() 2437 defer fake.resourceByIDMutex.Unlock() 2438 fake.ResourceByIDStub = stub 2439} 2440 2441func (fake *FakePipeline) ResourceByIDArgsForCall(i int) int { 2442 fake.resourceByIDMutex.RLock() 2443 defer fake.resourceByIDMutex.RUnlock() 2444 argsForCall := fake.resourceByIDArgsForCall[i] 2445 return argsForCall.arg1 2446} 2447 2448func (fake *FakePipeline) ResourceByIDReturns(result1 db.Resource, result2 bool, result3 error) { 2449 fake.resourceByIDMutex.Lock() 2450 defer fake.resourceByIDMutex.Unlock() 2451 fake.ResourceByIDStub = nil 2452 fake.resourceByIDReturns = struct { 2453 result1 db.Resource 2454 result2 bool 2455 result3 error 2456 }{result1, result2, result3} 2457} 2458 2459func (fake *FakePipeline) ResourceByIDReturnsOnCall(i int, result1 db.Resource, result2 bool, result3 error) { 2460 fake.resourceByIDMutex.Lock() 2461 defer fake.resourceByIDMutex.Unlock() 2462 fake.ResourceByIDStub = nil 2463 if fake.resourceByIDReturnsOnCall == nil { 2464 fake.resourceByIDReturnsOnCall = make(map[int]struct { 2465 result1 db.Resource 2466 result2 bool 2467 result3 error 2468 }) 2469 } 2470 fake.resourceByIDReturnsOnCall[i] = struct { 2471 result1 db.Resource 2472 result2 bool 2473 result3 error 2474 }{result1, result2, result3} 2475} 2476 2477func (fake *FakePipeline) ResourceType(arg1 string) (db.ResourceType, bool, error) { 2478 fake.resourceTypeMutex.Lock() 2479 ret, specificReturn := fake.resourceTypeReturnsOnCall[len(fake.resourceTypeArgsForCall)] 2480 fake.resourceTypeArgsForCall = append(fake.resourceTypeArgsForCall, struct { 2481 arg1 string 2482 }{arg1}) 2483 fake.recordInvocation("ResourceType", []interface{}{arg1}) 2484 fake.resourceTypeMutex.Unlock() 2485 if fake.ResourceTypeStub != nil { 2486 return fake.ResourceTypeStub(arg1) 2487 } 2488 if specificReturn { 2489 return ret.result1, ret.result2, ret.result3 2490 } 2491 fakeReturns := fake.resourceTypeReturns 2492 return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 2493} 2494 2495func (fake *FakePipeline) ResourceTypeCallCount() int { 2496 fake.resourceTypeMutex.RLock() 2497 defer fake.resourceTypeMutex.RUnlock() 2498 return len(fake.resourceTypeArgsForCall) 2499} 2500 2501func (fake *FakePipeline) ResourceTypeCalls(stub func(string) (db.ResourceType, bool, error)) { 2502 fake.resourceTypeMutex.Lock() 2503 defer fake.resourceTypeMutex.Unlock() 2504 fake.ResourceTypeStub = stub 2505} 2506 2507func (fake *FakePipeline) ResourceTypeArgsForCall(i int) string { 2508 fake.resourceTypeMutex.RLock() 2509 defer fake.resourceTypeMutex.RUnlock() 2510 argsForCall := fake.resourceTypeArgsForCall[i] 2511 return argsForCall.arg1 2512} 2513 2514func (fake *FakePipeline) ResourceTypeReturns(result1 db.ResourceType, result2 bool, result3 error) { 2515 fake.resourceTypeMutex.Lock() 2516 defer fake.resourceTypeMutex.Unlock() 2517 fake.ResourceTypeStub = nil 2518 fake.resourceTypeReturns = struct { 2519 result1 db.ResourceType 2520 result2 bool 2521 result3 error 2522 }{result1, result2, result3} 2523} 2524 2525func (fake *FakePipeline) ResourceTypeReturnsOnCall(i int, result1 db.ResourceType, result2 bool, result3 error) { 2526 fake.resourceTypeMutex.Lock() 2527 defer fake.resourceTypeMutex.Unlock() 2528 fake.ResourceTypeStub = nil 2529 if fake.resourceTypeReturnsOnCall == nil { 2530 fake.resourceTypeReturnsOnCall = make(map[int]struct { 2531 result1 db.ResourceType 2532 result2 bool 2533 result3 error 2534 }) 2535 } 2536 fake.resourceTypeReturnsOnCall[i] = struct { 2537 result1 db.ResourceType 2538 result2 bool 2539 result3 error 2540 }{result1, result2, result3} 2541} 2542 2543func (fake *FakePipeline) ResourceTypeByID(arg1 int) (db.ResourceType, bool, error) { 2544 fake.resourceTypeByIDMutex.Lock() 2545 ret, specificReturn := fake.resourceTypeByIDReturnsOnCall[len(fake.resourceTypeByIDArgsForCall)] 2546 fake.resourceTypeByIDArgsForCall = append(fake.resourceTypeByIDArgsForCall, struct { 2547 arg1 int 2548 }{arg1}) 2549 fake.recordInvocation("ResourceTypeByID", []interface{}{arg1}) 2550 fake.resourceTypeByIDMutex.Unlock() 2551 if fake.ResourceTypeByIDStub != nil { 2552 return fake.ResourceTypeByIDStub(arg1) 2553 } 2554 if specificReturn { 2555 return ret.result1, ret.result2, ret.result3 2556 } 2557 fakeReturns := fake.resourceTypeByIDReturns 2558 return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 2559} 2560 2561func (fake *FakePipeline) ResourceTypeByIDCallCount() int { 2562 fake.resourceTypeByIDMutex.RLock() 2563 defer fake.resourceTypeByIDMutex.RUnlock() 2564 return len(fake.resourceTypeByIDArgsForCall) 2565} 2566 2567func (fake *FakePipeline) ResourceTypeByIDCalls(stub func(int) (db.ResourceType, bool, error)) { 2568 fake.resourceTypeByIDMutex.Lock() 2569 defer fake.resourceTypeByIDMutex.Unlock() 2570 fake.ResourceTypeByIDStub = stub 2571} 2572 2573func (fake *FakePipeline) ResourceTypeByIDArgsForCall(i int) int { 2574 fake.resourceTypeByIDMutex.RLock() 2575 defer fake.resourceTypeByIDMutex.RUnlock() 2576 argsForCall := fake.resourceTypeByIDArgsForCall[i] 2577 return argsForCall.arg1 2578} 2579 2580func (fake *FakePipeline) ResourceTypeByIDReturns(result1 db.ResourceType, result2 bool, result3 error) { 2581 fake.resourceTypeByIDMutex.Lock() 2582 defer fake.resourceTypeByIDMutex.Unlock() 2583 fake.ResourceTypeByIDStub = nil 2584 fake.resourceTypeByIDReturns = struct { 2585 result1 db.ResourceType 2586 result2 bool 2587 result3 error 2588 }{result1, result2, result3} 2589} 2590 2591func (fake *FakePipeline) ResourceTypeByIDReturnsOnCall(i int, result1 db.ResourceType, result2 bool, result3 error) { 2592 fake.resourceTypeByIDMutex.Lock() 2593 defer fake.resourceTypeByIDMutex.Unlock() 2594 fake.ResourceTypeByIDStub = nil 2595 if fake.resourceTypeByIDReturnsOnCall == nil { 2596 fake.resourceTypeByIDReturnsOnCall = make(map[int]struct { 2597 result1 db.ResourceType 2598 result2 bool 2599 result3 error 2600 }) 2601 } 2602 fake.resourceTypeByIDReturnsOnCall[i] = struct { 2603 result1 db.ResourceType 2604 result2 bool 2605 result3 error 2606 }{result1, result2, result3} 2607} 2608 2609func (fake *FakePipeline) ResourceTypes() (db.ResourceTypes, error) { 2610 fake.resourceTypesMutex.Lock() 2611 ret, specificReturn := fake.resourceTypesReturnsOnCall[len(fake.resourceTypesArgsForCall)] 2612 fake.resourceTypesArgsForCall = append(fake.resourceTypesArgsForCall, struct { 2613 }{}) 2614 fake.recordInvocation("ResourceTypes", []interface{}{}) 2615 fake.resourceTypesMutex.Unlock() 2616 if fake.ResourceTypesStub != nil { 2617 return fake.ResourceTypesStub() 2618 } 2619 if specificReturn { 2620 return ret.result1, ret.result2 2621 } 2622 fakeReturns := fake.resourceTypesReturns 2623 return fakeReturns.result1, fakeReturns.result2 2624} 2625 2626func (fake *FakePipeline) ResourceTypesCallCount() int { 2627 fake.resourceTypesMutex.RLock() 2628 defer fake.resourceTypesMutex.RUnlock() 2629 return len(fake.resourceTypesArgsForCall) 2630} 2631 2632func (fake *FakePipeline) ResourceTypesCalls(stub func() (db.ResourceTypes, error)) { 2633 fake.resourceTypesMutex.Lock() 2634 defer fake.resourceTypesMutex.Unlock() 2635 fake.ResourceTypesStub = stub 2636} 2637 2638func (fake *FakePipeline) ResourceTypesReturns(result1 db.ResourceTypes, result2 error) { 2639 fake.resourceTypesMutex.Lock() 2640 defer fake.resourceTypesMutex.Unlock() 2641 fake.ResourceTypesStub = nil 2642 fake.resourceTypesReturns = struct { 2643 result1 db.ResourceTypes 2644 result2 error 2645 }{result1, result2} 2646} 2647 2648func (fake *FakePipeline) ResourceTypesReturnsOnCall(i int, result1 db.ResourceTypes, result2 error) { 2649 fake.resourceTypesMutex.Lock() 2650 defer fake.resourceTypesMutex.Unlock() 2651 fake.ResourceTypesStub = nil 2652 if fake.resourceTypesReturnsOnCall == nil { 2653 fake.resourceTypesReturnsOnCall = make(map[int]struct { 2654 result1 db.ResourceTypes 2655 result2 error 2656 }) 2657 } 2658 fake.resourceTypesReturnsOnCall[i] = struct { 2659 result1 db.ResourceTypes 2660 result2 error 2661 }{result1, result2} 2662} 2663 2664func (fake *FakePipeline) ResourceVersion(arg1 int) (atc.ResourceVersion, bool, error) { 2665 fake.resourceVersionMutex.Lock() 2666 ret, specificReturn := fake.resourceVersionReturnsOnCall[len(fake.resourceVersionArgsForCall)] 2667 fake.resourceVersionArgsForCall = append(fake.resourceVersionArgsForCall, struct { 2668 arg1 int 2669 }{arg1}) 2670 fake.recordInvocation("ResourceVersion", []interface{}{arg1}) 2671 fake.resourceVersionMutex.Unlock() 2672 if fake.ResourceVersionStub != nil { 2673 return fake.ResourceVersionStub(arg1) 2674 } 2675 if specificReturn { 2676 return ret.result1, ret.result2, ret.result3 2677 } 2678 fakeReturns := fake.resourceVersionReturns 2679 return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 2680} 2681 2682func (fake *FakePipeline) ResourceVersionCallCount() int { 2683 fake.resourceVersionMutex.RLock() 2684 defer fake.resourceVersionMutex.RUnlock() 2685 return len(fake.resourceVersionArgsForCall) 2686} 2687 2688func (fake *FakePipeline) ResourceVersionCalls(stub func(int) (atc.ResourceVersion, bool, error)) { 2689 fake.resourceVersionMutex.Lock() 2690 defer fake.resourceVersionMutex.Unlock() 2691 fake.ResourceVersionStub = stub 2692} 2693 2694func (fake *FakePipeline) ResourceVersionArgsForCall(i int) int { 2695 fake.resourceVersionMutex.RLock() 2696 defer fake.resourceVersionMutex.RUnlock() 2697 argsForCall := fake.resourceVersionArgsForCall[i] 2698 return argsForCall.arg1 2699} 2700 2701func (fake *FakePipeline) ResourceVersionReturns(result1 atc.ResourceVersion, result2 bool, result3 error) { 2702 fake.resourceVersionMutex.Lock() 2703 defer fake.resourceVersionMutex.Unlock() 2704 fake.ResourceVersionStub = nil 2705 fake.resourceVersionReturns = struct { 2706 result1 atc.ResourceVersion 2707 result2 bool 2708 result3 error 2709 }{result1, result2, result3} 2710} 2711 2712func (fake *FakePipeline) ResourceVersionReturnsOnCall(i int, result1 atc.ResourceVersion, result2 bool, result3 error) { 2713 fake.resourceVersionMutex.Lock() 2714 defer fake.resourceVersionMutex.Unlock() 2715 fake.ResourceVersionStub = nil 2716 if fake.resourceVersionReturnsOnCall == nil { 2717 fake.resourceVersionReturnsOnCall = make(map[int]struct { 2718 result1 atc.ResourceVersion 2719 result2 bool 2720 result3 error 2721 }) 2722 } 2723 fake.resourceVersionReturnsOnCall[i] = struct { 2724 result1 atc.ResourceVersion 2725 result2 bool 2726 result3 error 2727 }{result1, result2, result3} 2728} 2729 2730func (fake *FakePipeline) Resources() (db.Resources, error) { 2731 fake.resourcesMutex.Lock() 2732 ret, specificReturn := fake.resourcesReturnsOnCall[len(fake.resourcesArgsForCall)] 2733 fake.resourcesArgsForCall = append(fake.resourcesArgsForCall, struct { 2734 }{}) 2735 fake.recordInvocation("Resources", []interface{}{}) 2736 fake.resourcesMutex.Unlock() 2737 if fake.ResourcesStub != nil { 2738 return fake.ResourcesStub() 2739 } 2740 if specificReturn { 2741 return ret.result1, ret.result2 2742 } 2743 fakeReturns := fake.resourcesReturns 2744 return fakeReturns.result1, fakeReturns.result2 2745} 2746 2747func (fake *FakePipeline) ResourcesCallCount() int { 2748 fake.resourcesMutex.RLock() 2749 defer fake.resourcesMutex.RUnlock() 2750 return len(fake.resourcesArgsForCall) 2751} 2752 2753func (fake *FakePipeline) ResourcesCalls(stub func() (db.Resources, error)) { 2754 fake.resourcesMutex.Lock() 2755 defer fake.resourcesMutex.Unlock() 2756 fake.ResourcesStub = stub 2757} 2758 2759func (fake *FakePipeline) ResourcesReturns(result1 db.Resources, result2 error) { 2760 fake.resourcesMutex.Lock() 2761 defer fake.resourcesMutex.Unlock() 2762 fake.ResourcesStub = nil 2763 fake.resourcesReturns = struct { 2764 result1 db.Resources 2765 result2 error 2766 }{result1, result2} 2767} 2768 2769func (fake *FakePipeline) ResourcesReturnsOnCall(i int, result1 db.Resources, result2 error) { 2770 fake.resourcesMutex.Lock() 2771 defer fake.resourcesMutex.Unlock() 2772 fake.ResourcesStub = nil 2773 if fake.resourcesReturnsOnCall == nil { 2774 fake.resourcesReturnsOnCall = make(map[int]struct { 2775 result1 db.Resources 2776 result2 error 2777 }) 2778 } 2779 fake.resourcesReturnsOnCall[i] = struct { 2780 result1 db.Resources 2781 result2 error 2782 }{result1, result2} 2783} 2784 2785func (fake *FakePipeline) SetParentIDs(arg1 int, arg2 int) error { 2786 fake.setParentIDsMutex.Lock() 2787 ret, specificReturn := fake.setParentIDsReturnsOnCall[len(fake.setParentIDsArgsForCall)] 2788 fake.setParentIDsArgsForCall = append(fake.setParentIDsArgsForCall, struct { 2789 arg1 int 2790 arg2 int 2791 }{arg1, arg2}) 2792 fake.recordInvocation("SetParentIDs", []interface{}{arg1, arg2}) 2793 fake.setParentIDsMutex.Unlock() 2794 if fake.SetParentIDsStub != nil { 2795 return fake.SetParentIDsStub(arg1, arg2) 2796 } 2797 if specificReturn { 2798 return ret.result1 2799 } 2800 fakeReturns := fake.setParentIDsReturns 2801 return fakeReturns.result1 2802} 2803 2804func (fake *FakePipeline) SetParentIDsCallCount() int { 2805 fake.setParentIDsMutex.RLock() 2806 defer fake.setParentIDsMutex.RUnlock() 2807 return len(fake.setParentIDsArgsForCall) 2808} 2809 2810func (fake *FakePipeline) SetParentIDsCalls(stub func(int, int) error) { 2811 fake.setParentIDsMutex.Lock() 2812 defer fake.setParentIDsMutex.Unlock() 2813 fake.SetParentIDsStub = stub 2814} 2815 2816func (fake *FakePipeline) SetParentIDsArgsForCall(i int) (int, int) { 2817 fake.setParentIDsMutex.RLock() 2818 defer fake.setParentIDsMutex.RUnlock() 2819 argsForCall := fake.setParentIDsArgsForCall[i] 2820 return argsForCall.arg1, argsForCall.arg2 2821} 2822 2823func (fake *FakePipeline) SetParentIDsReturns(result1 error) { 2824 fake.setParentIDsMutex.Lock() 2825 defer fake.setParentIDsMutex.Unlock() 2826 fake.SetParentIDsStub = nil 2827 fake.setParentIDsReturns = struct { 2828 result1 error 2829 }{result1} 2830} 2831 2832func (fake *FakePipeline) SetParentIDsReturnsOnCall(i int, result1 error) { 2833 fake.setParentIDsMutex.Lock() 2834 defer fake.setParentIDsMutex.Unlock() 2835 fake.SetParentIDsStub = nil 2836 if fake.setParentIDsReturnsOnCall == nil { 2837 fake.setParentIDsReturnsOnCall = make(map[int]struct { 2838 result1 error 2839 }) 2840 } 2841 fake.setParentIDsReturnsOnCall[i] = struct { 2842 result1 error 2843 }{result1} 2844} 2845 2846func (fake *FakePipeline) TeamID() int { 2847 fake.teamIDMutex.Lock() 2848 ret, specificReturn := fake.teamIDReturnsOnCall[len(fake.teamIDArgsForCall)] 2849 fake.teamIDArgsForCall = append(fake.teamIDArgsForCall, struct { 2850 }{}) 2851 fake.recordInvocation("TeamID", []interface{}{}) 2852 fake.teamIDMutex.Unlock() 2853 if fake.TeamIDStub != nil { 2854 return fake.TeamIDStub() 2855 } 2856 if specificReturn { 2857 return ret.result1 2858 } 2859 fakeReturns := fake.teamIDReturns 2860 return fakeReturns.result1 2861} 2862 2863func (fake *FakePipeline) TeamIDCallCount() int { 2864 fake.teamIDMutex.RLock() 2865 defer fake.teamIDMutex.RUnlock() 2866 return len(fake.teamIDArgsForCall) 2867} 2868 2869func (fake *FakePipeline) TeamIDCalls(stub func() int) { 2870 fake.teamIDMutex.Lock() 2871 defer fake.teamIDMutex.Unlock() 2872 fake.TeamIDStub = stub 2873} 2874 2875func (fake *FakePipeline) TeamIDReturns(result1 int) { 2876 fake.teamIDMutex.Lock() 2877 defer fake.teamIDMutex.Unlock() 2878 fake.TeamIDStub = nil 2879 fake.teamIDReturns = struct { 2880 result1 int 2881 }{result1} 2882} 2883 2884func (fake *FakePipeline) TeamIDReturnsOnCall(i int, result1 int) { 2885 fake.teamIDMutex.Lock() 2886 defer fake.teamIDMutex.Unlock() 2887 fake.TeamIDStub = nil 2888 if fake.teamIDReturnsOnCall == nil { 2889 fake.teamIDReturnsOnCall = make(map[int]struct { 2890 result1 int 2891 }) 2892 } 2893 fake.teamIDReturnsOnCall[i] = struct { 2894 result1 int 2895 }{result1} 2896} 2897 2898func (fake *FakePipeline) TeamName() string { 2899 fake.teamNameMutex.Lock() 2900 ret, specificReturn := fake.teamNameReturnsOnCall[len(fake.teamNameArgsForCall)] 2901 fake.teamNameArgsForCall = append(fake.teamNameArgsForCall, struct { 2902 }{}) 2903 fake.recordInvocation("TeamName", []interface{}{}) 2904 fake.teamNameMutex.Unlock() 2905 if fake.TeamNameStub != nil { 2906 return fake.TeamNameStub() 2907 } 2908 if specificReturn { 2909 return ret.result1 2910 } 2911 fakeReturns := fake.teamNameReturns 2912 return fakeReturns.result1 2913} 2914 2915func (fake *FakePipeline) TeamNameCallCount() int { 2916 fake.teamNameMutex.RLock() 2917 defer fake.teamNameMutex.RUnlock() 2918 return len(fake.teamNameArgsForCall) 2919} 2920 2921func (fake *FakePipeline) TeamNameCalls(stub func() string) { 2922 fake.teamNameMutex.Lock() 2923 defer fake.teamNameMutex.Unlock() 2924 fake.TeamNameStub = stub 2925} 2926 2927func (fake *FakePipeline) TeamNameReturns(result1 string) { 2928 fake.teamNameMutex.Lock() 2929 defer fake.teamNameMutex.Unlock() 2930 fake.TeamNameStub = nil 2931 fake.teamNameReturns = struct { 2932 result1 string 2933 }{result1} 2934} 2935 2936func (fake *FakePipeline) TeamNameReturnsOnCall(i int, result1 string) { 2937 fake.teamNameMutex.Lock() 2938 defer fake.teamNameMutex.Unlock() 2939 fake.TeamNameStub = nil 2940 if fake.teamNameReturnsOnCall == nil { 2941 fake.teamNameReturnsOnCall = make(map[int]struct { 2942 result1 string 2943 }) 2944 } 2945 fake.teamNameReturnsOnCall[i] = struct { 2946 result1 string 2947 }{result1} 2948} 2949 2950func (fake *FakePipeline) Unpause() error { 2951 fake.unpauseMutex.Lock() 2952 ret, specificReturn := fake.unpauseReturnsOnCall[len(fake.unpauseArgsForCall)] 2953 fake.unpauseArgsForCall = append(fake.unpauseArgsForCall, struct { 2954 }{}) 2955 fake.recordInvocation("Unpause", []interface{}{}) 2956 fake.unpauseMutex.Unlock() 2957 if fake.UnpauseStub != nil { 2958 return fake.UnpauseStub() 2959 } 2960 if specificReturn { 2961 return ret.result1 2962 } 2963 fakeReturns := fake.unpauseReturns 2964 return fakeReturns.result1 2965} 2966 2967func (fake *FakePipeline) UnpauseCallCount() int { 2968 fake.unpauseMutex.RLock() 2969 defer fake.unpauseMutex.RUnlock() 2970 return len(fake.unpauseArgsForCall) 2971} 2972 2973func (fake *FakePipeline) UnpauseCalls(stub func() error) { 2974 fake.unpauseMutex.Lock() 2975 defer fake.unpauseMutex.Unlock() 2976 fake.UnpauseStub = stub 2977} 2978 2979func (fake *FakePipeline) UnpauseReturns(result1 error) { 2980 fake.unpauseMutex.Lock() 2981 defer fake.unpauseMutex.Unlock() 2982 fake.UnpauseStub = nil 2983 fake.unpauseReturns = struct { 2984 result1 error 2985 }{result1} 2986} 2987 2988func (fake *FakePipeline) UnpauseReturnsOnCall(i int, result1 error) { 2989 fake.unpauseMutex.Lock() 2990 defer fake.unpauseMutex.Unlock() 2991 fake.UnpauseStub = nil 2992 if fake.unpauseReturnsOnCall == nil { 2993 fake.unpauseReturnsOnCall = make(map[int]struct { 2994 result1 error 2995 }) 2996 } 2997 fake.unpauseReturnsOnCall[i] = struct { 2998 result1 error 2999 }{result1} 3000} 3001 3002func (fake *FakePipeline) VarSources() atc.VarSourceConfigs { 3003 fake.varSourcesMutex.Lock() 3004 ret, specificReturn := fake.varSourcesReturnsOnCall[len(fake.varSourcesArgsForCall)] 3005 fake.varSourcesArgsForCall = append(fake.varSourcesArgsForCall, struct { 3006 }{}) 3007 fake.recordInvocation("VarSources", []interface{}{}) 3008 fake.varSourcesMutex.Unlock() 3009 if fake.VarSourcesStub != nil { 3010 return fake.VarSourcesStub() 3011 } 3012 if specificReturn { 3013 return ret.result1 3014 } 3015 fakeReturns := fake.varSourcesReturns 3016 return fakeReturns.result1 3017} 3018 3019func (fake *FakePipeline) VarSourcesCallCount() int { 3020 fake.varSourcesMutex.RLock() 3021 defer fake.varSourcesMutex.RUnlock() 3022 return len(fake.varSourcesArgsForCall) 3023} 3024 3025func (fake *FakePipeline) VarSourcesCalls(stub func() atc.VarSourceConfigs) { 3026 fake.varSourcesMutex.Lock() 3027 defer fake.varSourcesMutex.Unlock() 3028 fake.VarSourcesStub = stub 3029} 3030 3031func (fake *FakePipeline) VarSourcesReturns(result1 atc.VarSourceConfigs) { 3032 fake.varSourcesMutex.Lock() 3033 defer fake.varSourcesMutex.Unlock() 3034 fake.VarSourcesStub = nil 3035 fake.varSourcesReturns = struct { 3036 result1 atc.VarSourceConfigs 3037 }{result1} 3038} 3039 3040func (fake *FakePipeline) VarSourcesReturnsOnCall(i int, result1 atc.VarSourceConfigs) { 3041 fake.varSourcesMutex.Lock() 3042 defer fake.varSourcesMutex.Unlock() 3043 fake.VarSourcesStub = nil 3044 if fake.varSourcesReturnsOnCall == nil { 3045 fake.varSourcesReturnsOnCall = make(map[int]struct { 3046 result1 atc.VarSourceConfigs 3047 }) 3048 } 3049 fake.varSourcesReturnsOnCall[i] = struct { 3050 result1 atc.VarSourceConfigs 3051 }{result1} 3052} 3053 3054func (fake *FakePipeline) Variables(arg1 lager.Logger, arg2 creds.Secrets, arg3 creds.VarSourcePool) (vars.Variables, error) { 3055 fake.variablesMutex.Lock() 3056 ret, specificReturn := fake.variablesReturnsOnCall[len(fake.variablesArgsForCall)] 3057 fake.variablesArgsForCall = append(fake.variablesArgsForCall, struct { 3058 arg1 lager.Logger 3059 arg2 creds.Secrets 3060 arg3 creds.VarSourcePool 3061 }{arg1, arg2, arg3}) 3062 fake.recordInvocation("Variables", []interface{}{arg1, arg2, arg3}) 3063 fake.variablesMutex.Unlock() 3064 if fake.VariablesStub != nil { 3065 return fake.VariablesStub(arg1, arg2, arg3) 3066 } 3067 if specificReturn { 3068 return ret.result1, ret.result2 3069 } 3070 fakeReturns := fake.variablesReturns 3071 return fakeReturns.result1, fakeReturns.result2 3072} 3073 3074func (fake *FakePipeline) VariablesCallCount() int { 3075 fake.variablesMutex.RLock() 3076 defer fake.variablesMutex.RUnlock() 3077 return len(fake.variablesArgsForCall) 3078} 3079 3080func (fake *FakePipeline) VariablesCalls(stub func(lager.Logger, creds.Secrets, creds.VarSourcePool) (vars.Variables, error)) { 3081 fake.variablesMutex.Lock() 3082 defer fake.variablesMutex.Unlock() 3083 fake.VariablesStub = stub 3084} 3085 3086func (fake *FakePipeline) VariablesArgsForCall(i int) (lager.Logger, creds.Secrets, creds.VarSourcePool) { 3087 fake.variablesMutex.RLock() 3088 defer fake.variablesMutex.RUnlock() 3089 argsForCall := fake.variablesArgsForCall[i] 3090 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 3091} 3092 3093func (fake *FakePipeline) VariablesReturns(result1 vars.Variables, result2 error) { 3094 fake.variablesMutex.Lock() 3095 defer fake.variablesMutex.Unlock() 3096 fake.VariablesStub = nil 3097 fake.variablesReturns = struct { 3098 result1 vars.Variables 3099 result2 error 3100 }{result1, result2} 3101} 3102 3103func (fake *FakePipeline) VariablesReturnsOnCall(i int, result1 vars.Variables, result2 error) { 3104 fake.variablesMutex.Lock() 3105 defer fake.variablesMutex.Unlock() 3106 fake.VariablesStub = nil 3107 if fake.variablesReturnsOnCall == nil { 3108 fake.variablesReturnsOnCall = make(map[int]struct { 3109 result1 vars.Variables 3110 result2 error 3111 }) 3112 } 3113 fake.variablesReturnsOnCall[i] = struct { 3114 result1 vars.Variables 3115 result2 error 3116 }{result1, result2} 3117} 3118 3119func (fake *FakePipeline) Invocations() map[string][][]interface{} { 3120 fake.invocationsMutex.RLock() 3121 defer fake.invocationsMutex.RUnlock() 3122 fake.archiveMutex.RLock() 3123 defer fake.archiveMutex.RUnlock() 3124 fake.archivedMutex.RLock() 3125 defer fake.archivedMutex.RUnlock() 3126 fake.buildsMutex.RLock() 3127 defer fake.buildsMutex.RUnlock() 3128 fake.buildsWithTimeMutex.RLock() 3129 defer fake.buildsWithTimeMutex.RUnlock() 3130 fake.causalityMutex.RLock() 3131 defer fake.causalityMutex.RUnlock() 3132 fake.checkPausedMutex.RLock() 3133 defer fake.checkPausedMutex.RUnlock() 3134 fake.configMutex.RLock() 3135 defer fake.configMutex.RUnlock() 3136 fake.configVersionMutex.RLock() 3137 defer fake.configVersionMutex.RUnlock() 3138 fake.createOneOffBuildMutex.RLock() 3139 defer fake.createOneOffBuildMutex.RUnlock() 3140 fake.createStartedBuildMutex.RLock() 3141 defer fake.createStartedBuildMutex.RUnlock() 3142 fake.dashboardMutex.RLock() 3143 defer fake.dashboardMutex.RUnlock() 3144 fake.deleteBuildEventsByBuildIDsMutex.RLock() 3145 defer fake.deleteBuildEventsByBuildIDsMutex.RUnlock() 3146 fake.destroyMutex.RLock() 3147 defer fake.destroyMutex.RUnlock() 3148 fake.displayMutex.RLock() 3149 defer fake.displayMutex.RUnlock() 3150 fake.exposeMutex.RLock() 3151 defer fake.exposeMutex.RUnlock() 3152 fake.getBuildsWithVersionAsInputMutex.RLock() 3153 defer fake.getBuildsWithVersionAsInputMutex.RUnlock() 3154 fake.getBuildsWithVersionAsOutputMutex.RLock() 3155 defer fake.getBuildsWithVersionAsOutputMutex.RUnlock() 3156 fake.groupsMutex.RLock() 3157 defer fake.groupsMutex.RUnlock() 3158 fake.hideMutex.RLock() 3159 defer fake.hideMutex.RUnlock() 3160 fake.iDMutex.RLock() 3161 defer fake.iDMutex.RUnlock() 3162 fake.jobMutex.RLock() 3163 defer fake.jobMutex.RUnlock() 3164 fake.jobsMutex.RLock() 3165 defer fake.jobsMutex.RUnlock() 3166 fake.lastUpdatedMutex.RLock() 3167 defer fake.lastUpdatedMutex.RUnlock() 3168 fake.loadDebugVersionsDBMutex.RLock() 3169 defer fake.loadDebugVersionsDBMutex.RUnlock() 3170 fake.nameMutex.RLock() 3171 defer fake.nameMutex.RUnlock() 3172 fake.parentBuildIDMutex.RLock() 3173 defer fake.parentBuildIDMutex.RUnlock() 3174 fake.parentJobIDMutex.RLock() 3175 defer fake.parentJobIDMutex.RUnlock() 3176 fake.pauseMutex.RLock() 3177 defer fake.pauseMutex.RUnlock() 3178 fake.pausedMutex.RLock() 3179 defer fake.pausedMutex.RUnlock() 3180 fake.publicMutex.RLock() 3181 defer fake.publicMutex.RUnlock() 3182 fake.reloadMutex.RLock() 3183 defer fake.reloadMutex.RUnlock() 3184 fake.renameMutex.RLock() 3185 defer fake.renameMutex.RUnlock() 3186 fake.resourceMutex.RLock() 3187 defer fake.resourceMutex.RUnlock() 3188 fake.resourceByIDMutex.RLock() 3189 defer fake.resourceByIDMutex.RUnlock() 3190 fake.resourceTypeMutex.RLock() 3191 defer fake.resourceTypeMutex.RUnlock() 3192 fake.resourceTypeByIDMutex.RLock() 3193 defer fake.resourceTypeByIDMutex.RUnlock() 3194 fake.resourceTypesMutex.RLock() 3195 defer fake.resourceTypesMutex.RUnlock() 3196 fake.resourceVersionMutex.RLock() 3197 defer fake.resourceVersionMutex.RUnlock() 3198 fake.resourcesMutex.RLock() 3199 defer fake.resourcesMutex.RUnlock() 3200 fake.setParentIDsMutex.RLock() 3201 defer fake.setParentIDsMutex.RUnlock() 3202 fake.teamIDMutex.RLock() 3203 defer fake.teamIDMutex.RUnlock() 3204 fake.teamNameMutex.RLock() 3205 defer fake.teamNameMutex.RUnlock() 3206 fake.unpauseMutex.RLock() 3207 defer fake.unpauseMutex.RUnlock() 3208 fake.varSourcesMutex.RLock() 3209 defer fake.varSourcesMutex.RUnlock() 3210 fake.variablesMutex.RLock() 3211 defer fake.variablesMutex.RUnlock() 3212 copiedInvocations := map[string][][]interface{}{} 3213 for key, value := range fake.invocations { 3214 copiedInvocations[key] = value 3215 } 3216 return copiedInvocations 3217} 3218 3219func (fake *FakePipeline) recordInvocation(key string, args []interface{}) { 3220 fake.invocationsMutex.Lock() 3221 defer fake.invocationsMutex.Unlock() 3222 if fake.invocations == nil { 3223 fake.invocations = map[string][][]interface{}{} 3224 } 3225 if fake.invocations[key] == nil { 3226 fake.invocations[key] = [][]interface{}{} 3227 } 3228 fake.invocations[key] = append(fake.invocations[key], args) 3229} 3230 3231var _ db.Pipeline = new(FakePipeline) 3232