github.com/DaAlbrecht/cf-cli@v0.0.0-20231128151943-1fe19bb400b9/cf/configuration/coreconfig/coreconfigfakes/fake_repository.go (about) 1 // Code generated by counterfeiter. DO NOT EDIT. 2 package coreconfigfakes 3 4 import ( 5 "sync" 6 7 "code.cloudfoundry.org/cli/cf/configuration/coreconfig" 8 "code.cloudfoundry.org/cli/cf/models" 9 "github.com/blang/semver/v4" 10 ) 11 12 type FakeRepository struct { 13 APIEndpointStub func() string 14 aPIEndpointMutex sync.RWMutex 15 aPIEndpointArgsForCall []struct { 16 } 17 aPIEndpointReturns struct { 18 result1 string 19 } 20 aPIEndpointReturnsOnCall map[int]struct { 21 result1 string 22 } 23 APIVersionStub func() string 24 aPIVersionMutex sync.RWMutex 25 aPIVersionArgsForCall []struct { 26 } 27 aPIVersionReturns struct { 28 result1 string 29 } 30 aPIVersionReturnsOnCall map[int]struct { 31 result1 string 32 } 33 AccessTokenStub func() string 34 accessTokenMutex sync.RWMutex 35 accessTokenArgsForCall []struct { 36 } 37 accessTokenReturns struct { 38 result1 string 39 } 40 accessTokenReturnsOnCall map[int]struct { 41 result1 string 42 } 43 AsyncTimeoutStub func() uint 44 asyncTimeoutMutex sync.RWMutex 45 asyncTimeoutArgsForCall []struct { 46 } 47 asyncTimeoutReturns struct { 48 result1 uint 49 } 50 asyncTimeoutReturnsOnCall map[int]struct { 51 result1 uint 52 } 53 AuthenticationEndpointStub func() string 54 authenticationEndpointMutex sync.RWMutex 55 authenticationEndpointArgsForCall []struct { 56 } 57 authenticationEndpointReturns struct { 58 result1 string 59 } 60 authenticationEndpointReturnsOnCall map[int]struct { 61 result1 string 62 } 63 CLIVersionStub func() string 64 cLIVersionMutex sync.RWMutex 65 cLIVersionArgsForCall []struct { 66 } 67 cLIVersionReturns struct { 68 result1 string 69 } 70 cLIVersionReturnsOnCall map[int]struct { 71 result1 string 72 } 73 ClearSessionStub func() 74 clearSessionMutex sync.RWMutex 75 clearSessionArgsForCall []struct { 76 } 77 CloseStub func() 78 closeMutex sync.RWMutex 79 closeArgsForCall []struct { 80 } 81 ColorEnabledStub func() string 82 colorEnabledMutex sync.RWMutex 83 colorEnabledArgsForCall []struct { 84 } 85 colorEnabledReturns struct { 86 result1 string 87 } 88 colorEnabledReturnsOnCall map[int]struct { 89 result1 string 90 } 91 DopplerEndpointStub func() string 92 dopplerEndpointMutex sync.RWMutex 93 dopplerEndpointArgsForCall []struct { 94 } 95 dopplerEndpointReturns struct { 96 result1 string 97 } 98 dopplerEndpointReturnsOnCall map[int]struct { 99 result1 string 100 } 101 HasAPIEndpointStub func() bool 102 hasAPIEndpointMutex sync.RWMutex 103 hasAPIEndpointArgsForCall []struct { 104 } 105 hasAPIEndpointReturns struct { 106 result1 bool 107 } 108 hasAPIEndpointReturnsOnCall map[int]struct { 109 result1 bool 110 } 111 HasOrganizationStub func() bool 112 hasOrganizationMutex sync.RWMutex 113 hasOrganizationArgsForCall []struct { 114 } 115 hasOrganizationReturns struct { 116 result1 bool 117 } 118 hasOrganizationReturnsOnCall map[int]struct { 119 result1 bool 120 } 121 HasSpaceStub func() bool 122 hasSpaceMutex sync.RWMutex 123 hasSpaceArgsForCall []struct { 124 } 125 hasSpaceReturns struct { 126 result1 bool 127 } 128 hasSpaceReturnsOnCall map[int]struct { 129 result1 bool 130 } 131 IsLoggedInStub func() bool 132 isLoggedInMutex sync.RWMutex 133 isLoggedInArgsForCall []struct { 134 } 135 isLoggedInReturns struct { 136 result1 bool 137 } 138 isLoggedInReturnsOnCall map[int]struct { 139 result1 bool 140 } 141 IsMinAPIVersionStub func(semver.Version) bool 142 isMinAPIVersionMutex sync.RWMutex 143 isMinAPIVersionArgsForCall []struct { 144 arg1 semver.Version 145 } 146 isMinAPIVersionReturns struct { 147 result1 bool 148 } 149 isMinAPIVersionReturnsOnCall map[int]struct { 150 result1 bool 151 } 152 IsMinCLIVersionStub func(string) bool 153 isMinCLIVersionMutex sync.RWMutex 154 isMinCLIVersionArgsForCall []struct { 155 arg1 string 156 } 157 isMinCLIVersionReturns struct { 158 result1 bool 159 } 160 isMinCLIVersionReturnsOnCall map[int]struct { 161 result1 bool 162 } 163 IsSSLDisabledStub func() bool 164 isSSLDisabledMutex sync.RWMutex 165 isSSLDisabledArgsForCall []struct { 166 } 167 isSSLDisabledReturns struct { 168 result1 bool 169 } 170 isSSLDisabledReturnsOnCall map[int]struct { 171 result1 bool 172 } 173 LocaleStub func() string 174 localeMutex sync.RWMutex 175 localeArgsForCall []struct { 176 } 177 localeReturns struct { 178 result1 string 179 } 180 localeReturnsOnCall map[int]struct { 181 result1 string 182 } 183 LogCacheEndpointStub func() string 184 logCacheEndpointMutex sync.RWMutex 185 logCacheEndpointArgsForCall []struct { 186 } 187 logCacheEndpointReturns struct { 188 result1 string 189 } 190 logCacheEndpointReturnsOnCall map[int]struct { 191 result1 string 192 } 193 MinCLIVersionStub func() string 194 minCLIVersionMutex sync.RWMutex 195 minCLIVersionArgsForCall []struct { 196 } 197 minCLIVersionReturns struct { 198 result1 string 199 } 200 minCLIVersionReturnsOnCall map[int]struct { 201 result1 string 202 } 203 MinRecommendedCLIVersionStub func() string 204 minRecommendedCLIVersionMutex sync.RWMutex 205 minRecommendedCLIVersionArgsForCall []struct { 206 } 207 minRecommendedCLIVersionReturns struct { 208 result1 string 209 } 210 minRecommendedCLIVersionReturnsOnCall map[int]struct { 211 result1 string 212 } 213 OrganizationFieldsStub func() models.OrganizationFields 214 organizationFieldsMutex sync.RWMutex 215 organizationFieldsArgsForCall []struct { 216 } 217 organizationFieldsReturns struct { 218 result1 models.OrganizationFields 219 } 220 organizationFieldsReturnsOnCall map[int]struct { 221 result1 models.OrganizationFields 222 } 223 PluginReposStub func() []models.PluginRepo 224 pluginReposMutex sync.RWMutex 225 pluginReposArgsForCall []struct { 226 } 227 pluginReposReturns struct { 228 result1 []models.PluginRepo 229 } 230 pluginReposReturnsOnCall map[int]struct { 231 result1 []models.PluginRepo 232 } 233 RefreshTokenStub func() string 234 refreshTokenMutex sync.RWMutex 235 refreshTokenArgsForCall []struct { 236 } 237 refreshTokenReturns struct { 238 result1 string 239 } 240 refreshTokenReturnsOnCall map[int]struct { 241 result1 string 242 } 243 RoutingAPIEndpointStub func() string 244 routingAPIEndpointMutex sync.RWMutex 245 routingAPIEndpointArgsForCall []struct { 246 } 247 routingAPIEndpointReturns struct { 248 result1 string 249 } 250 routingAPIEndpointReturnsOnCall map[int]struct { 251 result1 string 252 } 253 SSHOAuthClientStub func() string 254 sSHOAuthClientMutex sync.RWMutex 255 sSHOAuthClientArgsForCall []struct { 256 } 257 sSHOAuthClientReturns struct { 258 result1 string 259 } 260 sSHOAuthClientReturnsOnCall map[int]struct { 261 result1 string 262 } 263 SetAPIEndpointStub func(string) 264 setAPIEndpointMutex sync.RWMutex 265 setAPIEndpointArgsForCall []struct { 266 arg1 string 267 } 268 SetAPIVersionStub func(string) 269 setAPIVersionMutex sync.RWMutex 270 setAPIVersionArgsForCall []struct { 271 arg1 string 272 } 273 SetAccessTokenStub func(string) 274 setAccessTokenMutex sync.RWMutex 275 setAccessTokenArgsForCall []struct { 276 arg1 string 277 } 278 SetAsyncTimeoutStub func(uint) 279 setAsyncTimeoutMutex sync.RWMutex 280 setAsyncTimeoutArgsForCall []struct { 281 arg1 uint 282 } 283 SetAuthenticationEndpointStub func(string) 284 setAuthenticationEndpointMutex sync.RWMutex 285 setAuthenticationEndpointArgsForCall []struct { 286 arg1 string 287 } 288 SetCLIVersionStub func(string) 289 setCLIVersionMutex sync.RWMutex 290 setCLIVersionArgsForCall []struct { 291 arg1 string 292 } 293 SetColorEnabledStub func(string) 294 setColorEnabledMutex sync.RWMutex 295 setColorEnabledArgsForCall []struct { 296 arg1 string 297 } 298 SetDopplerEndpointStub func(string) 299 setDopplerEndpointMutex sync.RWMutex 300 setDopplerEndpointArgsForCall []struct { 301 arg1 string 302 } 303 SetLocaleStub func(string) 304 setLocaleMutex sync.RWMutex 305 setLocaleArgsForCall []struct { 306 arg1 string 307 } 308 SetLogCacheEndpointStub func(string) 309 setLogCacheEndpointMutex sync.RWMutex 310 setLogCacheEndpointArgsForCall []struct { 311 arg1 string 312 } 313 SetMinCLIVersionStub func(string) 314 setMinCLIVersionMutex sync.RWMutex 315 setMinCLIVersionArgsForCall []struct { 316 arg1 string 317 } 318 SetMinRecommendedCLIVersionStub func(string) 319 setMinRecommendedCLIVersionMutex sync.RWMutex 320 setMinRecommendedCLIVersionArgsForCall []struct { 321 arg1 string 322 } 323 SetOrganizationFieldsStub func(models.OrganizationFields) 324 setOrganizationFieldsMutex sync.RWMutex 325 setOrganizationFieldsArgsForCall []struct { 326 arg1 models.OrganizationFields 327 } 328 SetPluginRepoStub func(models.PluginRepo) 329 setPluginRepoMutex sync.RWMutex 330 setPluginRepoArgsForCall []struct { 331 arg1 models.PluginRepo 332 } 333 SetRefreshTokenStub func(string) 334 setRefreshTokenMutex sync.RWMutex 335 setRefreshTokenArgsForCall []struct { 336 arg1 string 337 } 338 SetRoutingAPIEndpointStub func(string) 339 setRoutingAPIEndpointMutex sync.RWMutex 340 setRoutingAPIEndpointArgsForCall []struct { 341 arg1 string 342 } 343 SetSSHOAuthClientStub func(string) 344 setSSHOAuthClientMutex sync.RWMutex 345 setSSHOAuthClientArgsForCall []struct { 346 arg1 string 347 } 348 SetSSLDisabledStub func(bool) 349 setSSLDisabledMutex sync.RWMutex 350 setSSLDisabledArgsForCall []struct { 351 arg1 bool 352 } 353 SetSpaceFieldsStub func(models.SpaceFields) 354 setSpaceFieldsMutex sync.RWMutex 355 setSpaceFieldsArgsForCall []struct { 356 arg1 models.SpaceFields 357 } 358 SetTraceStub func(string) 359 setTraceMutex sync.RWMutex 360 setTraceArgsForCall []struct { 361 arg1 string 362 } 363 SetUAAGrantTypeStub func(string) 364 setUAAGrantTypeMutex sync.RWMutex 365 setUAAGrantTypeArgsForCall []struct { 366 arg1 string 367 } 368 SetUAAOAuthClientStub func(string) 369 setUAAOAuthClientMutex sync.RWMutex 370 setUAAOAuthClientArgsForCall []struct { 371 arg1 string 372 } 373 SetUAAOAuthClientSecretStub func(string) 374 setUAAOAuthClientSecretMutex sync.RWMutex 375 setUAAOAuthClientSecretArgsForCall []struct { 376 arg1 string 377 } 378 SetUaaEndpointStub func(string) 379 setUaaEndpointMutex sync.RWMutex 380 setUaaEndpointArgsForCall []struct { 381 arg1 string 382 } 383 SpaceFieldsStub func() models.SpaceFields 384 spaceFieldsMutex sync.RWMutex 385 spaceFieldsArgsForCall []struct { 386 } 387 spaceFieldsReturns struct { 388 result1 models.SpaceFields 389 } 390 spaceFieldsReturnsOnCall map[int]struct { 391 result1 models.SpaceFields 392 } 393 TraceStub func() string 394 traceMutex sync.RWMutex 395 traceArgsForCall []struct { 396 } 397 traceReturns struct { 398 result1 string 399 } 400 traceReturnsOnCall map[int]struct { 401 result1 string 402 } 403 UAAGrantTypeStub func() string 404 uAAGrantTypeMutex sync.RWMutex 405 uAAGrantTypeArgsForCall []struct { 406 } 407 uAAGrantTypeReturns struct { 408 result1 string 409 } 410 uAAGrantTypeReturnsOnCall map[int]struct { 411 result1 string 412 } 413 UAAOAuthClientStub func() string 414 uAAOAuthClientMutex sync.RWMutex 415 uAAOAuthClientArgsForCall []struct { 416 } 417 uAAOAuthClientReturns struct { 418 result1 string 419 } 420 uAAOAuthClientReturnsOnCall map[int]struct { 421 result1 string 422 } 423 UAAOAuthClientSecretStub func() string 424 uAAOAuthClientSecretMutex sync.RWMutex 425 uAAOAuthClientSecretArgsForCall []struct { 426 } 427 uAAOAuthClientSecretReturns struct { 428 result1 string 429 } 430 uAAOAuthClientSecretReturnsOnCall map[int]struct { 431 result1 string 432 } 433 UaaEndpointStub func() string 434 uaaEndpointMutex sync.RWMutex 435 uaaEndpointArgsForCall []struct { 436 } 437 uaaEndpointReturns struct { 438 result1 string 439 } 440 uaaEndpointReturnsOnCall map[int]struct { 441 result1 string 442 } 443 UnSetPluginRepoStub func(int) 444 unSetPluginRepoMutex sync.RWMutex 445 unSetPluginRepoArgsForCall []struct { 446 arg1 int 447 } 448 UserEmailStub func() string 449 userEmailMutex sync.RWMutex 450 userEmailArgsForCall []struct { 451 } 452 userEmailReturns struct { 453 result1 string 454 } 455 userEmailReturnsOnCall map[int]struct { 456 result1 string 457 } 458 UserGUIDStub func() string 459 userGUIDMutex sync.RWMutex 460 userGUIDArgsForCall []struct { 461 } 462 userGUIDReturns struct { 463 result1 string 464 } 465 userGUIDReturnsOnCall map[int]struct { 466 result1 string 467 } 468 UsernameStub func() string 469 usernameMutex sync.RWMutex 470 usernameArgsForCall []struct { 471 } 472 usernameReturns struct { 473 result1 string 474 } 475 usernameReturnsOnCall map[int]struct { 476 result1 string 477 } 478 invocations map[string][][]interface{} 479 invocationsMutex sync.RWMutex 480 } 481 482 func (fake *FakeRepository) APIEndpoint() string { 483 fake.aPIEndpointMutex.Lock() 484 ret, specificReturn := fake.aPIEndpointReturnsOnCall[len(fake.aPIEndpointArgsForCall)] 485 fake.aPIEndpointArgsForCall = append(fake.aPIEndpointArgsForCall, struct { 486 }{}) 487 fake.recordInvocation("APIEndpoint", []interface{}{}) 488 fake.aPIEndpointMutex.Unlock() 489 if fake.APIEndpointStub != nil { 490 return fake.APIEndpointStub() 491 } 492 if specificReturn { 493 return ret.result1 494 } 495 fakeReturns := fake.aPIEndpointReturns 496 return fakeReturns.result1 497 } 498 499 func (fake *FakeRepository) APIEndpointCallCount() int { 500 fake.aPIEndpointMutex.RLock() 501 defer fake.aPIEndpointMutex.RUnlock() 502 return len(fake.aPIEndpointArgsForCall) 503 } 504 505 func (fake *FakeRepository) APIEndpointCalls(stub func() string) { 506 fake.aPIEndpointMutex.Lock() 507 defer fake.aPIEndpointMutex.Unlock() 508 fake.APIEndpointStub = stub 509 } 510 511 func (fake *FakeRepository) APIEndpointReturns(result1 string) { 512 fake.aPIEndpointMutex.Lock() 513 defer fake.aPIEndpointMutex.Unlock() 514 fake.APIEndpointStub = nil 515 fake.aPIEndpointReturns = struct { 516 result1 string 517 }{result1} 518 } 519 520 func (fake *FakeRepository) APIEndpointReturnsOnCall(i int, result1 string) { 521 fake.aPIEndpointMutex.Lock() 522 defer fake.aPIEndpointMutex.Unlock() 523 fake.APIEndpointStub = nil 524 if fake.aPIEndpointReturnsOnCall == nil { 525 fake.aPIEndpointReturnsOnCall = make(map[int]struct { 526 result1 string 527 }) 528 } 529 fake.aPIEndpointReturnsOnCall[i] = struct { 530 result1 string 531 }{result1} 532 } 533 534 func (fake *FakeRepository) APIVersion() string { 535 fake.aPIVersionMutex.Lock() 536 ret, specificReturn := fake.aPIVersionReturnsOnCall[len(fake.aPIVersionArgsForCall)] 537 fake.aPIVersionArgsForCall = append(fake.aPIVersionArgsForCall, struct { 538 }{}) 539 fake.recordInvocation("APIVersion", []interface{}{}) 540 fake.aPIVersionMutex.Unlock() 541 if fake.APIVersionStub != nil { 542 return fake.APIVersionStub() 543 } 544 if specificReturn { 545 return ret.result1 546 } 547 fakeReturns := fake.aPIVersionReturns 548 return fakeReturns.result1 549 } 550 551 func (fake *FakeRepository) APIVersionCallCount() int { 552 fake.aPIVersionMutex.RLock() 553 defer fake.aPIVersionMutex.RUnlock() 554 return len(fake.aPIVersionArgsForCall) 555 } 556 557 func (fake *FakeRepository) APIVersionCalls(stub func() string) { 558 fake.aPIVersionMutex.Lock() 559 defer fake.aPIVersionMutex.Unlock() 560 fake.APIVersionStub = stub 561 } 562 563 func (fake *FakeRepository) APIVersionReturns(result1 string) { 564 fake.aPIVersionMutex.Lock() 565 defer fake.aPIVersionMutex.Unlock() 566 fake.APIVersionStub = nil 567 fake.aPIVersionReturns = struct { 568 result1 string 569 }{result1} 570 } 571 572 func (fake *FakeRepository) APIVersionReturnsOnCall(i int, result1 string) { 573 fake.aPIVersionMutex.Lock() 574 defer fake.aPIVersionMutex.Unlock() 575 fake.APIVersionStub = nil 576 if fake.aPIVersionReturnsOnCall == nil { 577 fake.aPIVersionReturnsOnCall = make(map[int]struct { 578 result1 string 579 }) 580 } 581 fake.aPIVersionReturnsOnCall[i] = struct { 582 result1 string 583 }{result1} 584 } 585 586 func (fake *FakeRepository) AccessToken() string { 587 fake.accessTokenMutex.Lock() 588 ret, specificReturn := fake.accessTokenReturnsOnCall[len(fake.accessTokenArgsForCall)] 589 fake.accessTokenArgsForCall = append(fake.accessTokenArgsForCall, struct { 590 }{}) 591 fake.recordInvocation("AccessToken", []interface{}{}) 592 fake.accessTokenMutex.Unlock() 593 if fake.AccessTokenStub != nil { 594 return fake.AccessTokenStub() 595 } 596 if specificReturn { 597 return ret.result1 598 } 599 fakeReturns := fake.accessTokenReturns 600 return fakeReturns.result1 601 } 602 603 func (fake *FakeRepository) AccessTokenCallCount() int { 604 fake.accessTokenMutex.RLock() 605 defer fake.accessTokenMutex.RUnlock() 606 return len(fake.accessTokenArgsForCall) 607 } 608 609 func (fake *FakeRepository) AccessTokenCalls(stub func() string) { 610 fake.accessTokenMutex.Lock() 611 defer fake.accessTokenMutex.Unlock() 612 fake.AccessTokenStub = stub 613 } 614 615 func (fake *FakeRepository) AccessTokenReturns(result1 string) { 616 fake.accessTokenMutex.Lock() 617 defer fake.accessTokenMutex.Unlock() 618 fake.AccessTokenStub = nil 619 fake.accessTokenReturns = struct { 620 result1 string 621 }{result1} 622 } 623 624 func (fake *FakeRepository) AccessTokenReturnsOnCall(i int, result1 string) { 625 fake.accessTokenMutex.Lock() 626 defer fake.accessTokenMutex.Unlock() 627 fake.AccessTokenStub = nil 628 if fake.accessTokenReturnsOnCall == nil { 629 fake.accessTokenReturnsOnCall = make(map[int]struct { 630 result1 string 631 }) 632 } 633 fake.accessTokenReturnsOnCall[i] = struct { 634 result1 string 635 }{result1} 636 } 637 638 func (fake *FakeRepository) AsyncTimeout() uint { 639 fake.asyncTimeoutMutex.Lock() 640 ret, specificReturn := fake.asyncTimeoutReturnsOnCall[len(fake.asyncTimeoutArgsForCall)] 641 fake.asyncTimeoutArgsForCall = append(fake.asyncTimeoutArgsForCall, struct { 642 }{}) 643 fake.recordInvocation("AsyncTimeout", []interface{}{}) 644 fake.asyncTimeoutMutex.Unlock() 645 if fake.AsyncTimeoutStub != nil { 646 return fake.AsyncTimeoutStub() 647 } 648 if specificReturn { 649 return ret.result1 650 } 651 fakeReturns := fake.asyncTimeoutReturns 652 return fakeReturns.result1 653 } 654 655 func (fake *FakeRepository) AsyncTimeoutCallCount() int { 656 fake.asyncTimeoutMutex.RLock() 657 defer fake.asyncTimeoutMutex.RUnlock() 658 return len(fake.asyncTimeoutArgsForCall) 659 } 660 661 func (fake *FakeRepository) AsyncTimeoutCalls(stub func() uint) { 662 fake.asyncTimeoutMutex.Lock() 663 defer fake.asyncTimeoutMutex.Unlock() 664 fake.AsyncTimeoutStub = stub 665 } 666 667 func (fake *FakeRepository) AsyncTimeoutReturns(result1 uint) { 668 fake.asyncTimeoutMutex.Lock() 669 defer fake.asyncTimeoutMutex.Unlock() 670 fake.AsyncTimeoutStub = nil 671 fake.asyncTimeoutReturns = struct { 672 result1 uint 673 }{result1} 674 } 675 676 func (fake *FakeRepository) AsyncTimeoutReturnsOnCall(i int, result1 uint) { 677 fake.asyncTimeoutMutex.Lock() 678 defer fake.asyncTimeoutMutex.Unlock() 679 fake.AsyncTimeoutStub = nil 680 if fake.asyncTimeoutReturnsOnCall == nil { 681 fake.asyncTimeoutReturnsOnCall = make(map[int]struct { 682 result1 uint 683 }) 684 } 685 fake.asyncTimeoutReturnsOnCall[i] = struct { 686 result1 uint 687 }{result1} 688 } 689 690 func (fake *FakeRepository) AuthenticationEndpoint() string { 691 fake.authenticationEndpointMutex.Lock() 692 ret, specificReturn := fake.authenticationEndpointReturnsOnCall[len(fake.authenticationEndpointArgsForCall)] 693 fake.authenticationEndpointArgsForCall = append(fake.authenticationEndpointArgsForCall, struct { 694 }{}) 695 fake.recordInvocation("AuthenticationEndpoint", []interface{}{}) 696 fake.authenticationEndpointMutex.Unlock() 697 if fake.AuthenticationEndpointStub != nil { 698 return fake.AuthenticationEndpointStub() 699 } 700 if specificReturn { 701 return ret.result1 702 } 703 fakeReturns := fake.authenticationEndpointReturns 704 return fakeReturns.result1 705 } 706 707 func (fake *FakeRepository) AuthenticationEndpointCallCount() int { 708 fake.authenticationEndpointMutex.RLock() 709 defer fake.authenticationEndpointMutex.RUnlock() 710 return len(fake.authenticationEndpointArgsForCall) 711 } 712 713 func (fake *FakeRepository) AuthenticationEndpointCalls(stub func() string) { 714 fake.authenticationEndpointMutex.Lock() 715 defer fake.authenticationEndpointMutex.Unlock() 716 fake.AuthenticationEndpointStub = stub 717 } 718 719 func (fake *FakeRepository) AuthenticationEndpointReturns(result1 string) { 720 fake.authenticationEndpointMutex.Lock() 721 defer fake.authenticationEndpointMutex.Unlock() 722 fake.AuthenticationEndpointStub = nil 723 fake.authenticationEndpointReturns = struct { 724 result1 string 725 }{result1} 726 } 727 728 func (fake *FakeRepository) AuthenticationEndpointReturnsOnCall(i int, result1 string) { 729 fake.authenticationEndpointMutex.Lock() 730 defer fake.authenticationEndpointMutex.Unlock() 731 fake.AuthenticationEndpointStub = nil 732 if fake.authenticationEndpointReturnsOnCall == nil { 733 fake.authenticationEndpointReturnsOnCall = make(map[int]struct { 734 result1 string 735 }) 736 } 737 fake.authenticationEndpointReturnsOnCall[i] = struct { 738 result1 string 739 }{result1} 740 } 741 742 func (fake *FakeRepository) CLIVersion() string { 743 fake.cLIVersionMutex.Lock() 744 ret, specificReturn := fake.cLIVersionReturnsOnCall[len(fake.cLIVersionArgsForCall)] 745 fake.cLIVersionArgsForCall = append(fake.cLIVersionArgsForCall, struct { 746 }{}) 747 fake.recordInvocation("CLIVersion", []interface{}{}) 748 fake.cLIVersionMutex.Unlock() 749 if fake.CLIVersionStub != nil { 750 return fake.CLIVersionStub() 751 } 752 if specificReturn { 753 return ret.result1 754 } 755 fakeReturns := fake.cLIVersionReturns 756 return fakeReturns.result1 757 } 758 759 func (fake *FakeRepository) CLIVersionCallCount() int { 760 fake.cLIVersionMutex.RLock() 761 defer fake.cLIVersionMutex.RUnlock() 762 return len(fake.cLIVersionArgsForCall) 763 } 764 765 func (fake *FakeRepository) CLIVersionCalls(stub func() string) { 766 fake.cLIVersionMutex.Lock() 767 defer fake.cLIVersionMutex.Unlock() 768 fake.CLIVersionStub = stub 769 } 770 771 func (fake *FakeRepository) CLIVersionReturns(result1 string) { 772 fake.cLIVersionMutex.Lock() 773 defer fake.cLIVersionMutex.Unlock() 774 fake.CLIVersionStub = nil 775 fake.cLIVersionReturns = struct { 776 result1 string 777 }{result1} 778 } 779 780 func (fake *FakeRepository) CLIVersionReturnsOnCall(i int, result1 string) { 781 fake.cLIVersionMutex.Lock() 782 defer fake.cLIVersionMutex.Unlock() 783 fake.CLIVersionStub = nil 784 if fake.cLIVersionReturnsOnCall == nil { 785 fake.cLIVersionReturnsOnCall = make(map[int]struct { 786 result1 string 787 }) 788 } 789 fake.cLIVersionReturnsOnCall[i] = struct { 790 result1 string 791 }{result1} 792 } 793 794 func (fake *FakeRepository) ClearSession() { 795 fake.clearSessionMutex.Lock() 796 fake.clearSessionArgsForCall = append(fake.clearSessionArgsForCall, struct { 797 }{}) 798 fake.recordInvocation("ClearSession", []interface{}{}) 799 fake.clearSessionMutex.Unlock() 800 if fake.ClearSessionStub != nil { 801 fake.ClearSessionStub() 802 } 803 } 804 805 func (fake *FakeRepository) ClearSessionCallCount() int { 806 fake.clearSessionMutex.RLock() 807 defer fake.clearSessionMutex.RUnlock() 808 return len(fake.clearSessionArgsForCall) 809 } 810 811 func (fake *FakeRepository) ClearSessionCalls(stub func()) { 812 fake.clearSessionMutex.Lock() 813 defer fake.clearSessionMutex.Unlock() 814 fake.ClearSessionStub = stub 815 } 816 817 func (fake *FakeRepository) Close() { 818 fake.closeMutex.Lock() 819 fake.closeArgsForCall = append(fake.closeArgsForCall, struct { 820 }{}) 821 fake.recordInvocation("Close", []interface{}{}) 822 fake.closeMutex.Unlock() 823 if fake.CloseStub != nil { 824 fake.CloseStub() 825 } 826 } 827 828 func (fake *FakeRepository) CloseCallCount() int { 829 fake.closeMutex.RLock() 830 defer fake.closeMutex.RUnlock() 831 return len(fake.closeArgsForCall) 832 } 833 834 func (fake *FakeRepository) CloseCalls(stub func()) { 835 fake.closeMutex.Lock() 836 defer fake.closeMutex.Unlock() 837 fake.CloseStub = stub 838 } 839 840 func (fake *FakeRepository) ColorEnabled() string { 841 fake.colorEnabledMutex.Lock() 842 ret, specificReturn := fake.colorEnabledReturnsOnCall[len(fake.colorEnabledArgsForCall)] 843 fake.colorEnabledArgsForCall = append(fake.colorEnabledArgsForCall, struct { 844 }{}) 845 fake.recordInvocation("ColorEnabled", []interface{}{}) 846 fake.colorEnabledMutex.Unlock() 847 if fake.ColorEnabledStub != nil { 848 return fake.ColorEnabledStub() 849 } 850 if specificReturn { 851 return ret.result1 852 } 853 fakeReturns := fake.colorEnabledReturns 854 return fakeReturns.result1 855 } 856 857 func (fake *FakeRepository) ColorEnabledCallCount() int { 858 fake.colorEnabledMutex.RLock() 859 defer fake.colorEnabledMutex.RUnlock() 860 return len(fake.colorEnabledArgsForCall) 861 } 862 863 func (fake *FakeRepository) ColorEnabledCalls(stub func() string) { 864 fake.colorEnabledMutex.Lock() 865 defer fake.colorEnabledMutex.Unlock() 866 fake.ColorEnabledStub = stub 867 } 868 869 func (fake *FakeRepository) ColorEnabledReturns(result1 string) { 870 fake.colorEnabledMutex.Lock() 871 defer fake.colorEnabledMutex.Unlock() 872 fake.ColorEnabledStub = nil 873 fake.colorEnabledReturns = struct { 874 result1 string 875 }{result1} 876 } 877 878 func (fake *FakeRepository) ColorEnabledReturnsOnCall(i int, result1 string) { 879 fake.colorEnabledMutex.Lock() 880 defer fake.colorEnabledMutex.Unlock() 881 fake.ColorEnabledStub = nil 882 if fake.colorEnabledReturnsOnCall == nil { 883 fake.colorEnabledReturnsOnCall = make(map[int]struct { 884 result1 string 885 }) 886 } 887 fake.colorEnabledReturnsOnCall[i] = struct { 888 result1 string 889 }{result1} 890 } 891 892 func (fake *FakeRepository) DopplerEndpoint() string { 893 fake.dopplerEndpointMutex.Lock() 894 ret, specificReturn := fake.dopplerEndpointReturnsOnCall[len(fake.dopplerEndpointArgsForCall)] 895 fake.dopplerEndpointArgsForCall = append(fake.dopplerEndpointArgsForCall, struct { 896 }{}) 897 fake.recordInvocation("DopplerEndpoint", []interface{}{}) 898 fake.dopplerEndpointMutex.Unlock() 899 if fake.DopplerEndpointStub != nil { 900 return fake.DopplerEndpointStub() 901 } 902 if specificReturn { 903 return ret.result1 904 } 905 fakeReturns := fake.dopplerEndpointReturns 906 return fakeReturns.result1 907 } 908 909 func (fake *FakeRepository) DopplerEndpointCallCount() int { 910 fake.dopplerEndpointMutex.RLock() 911 defer fake.dopplerEndpointMutex.RUnlock() 912 return len(fake.dopplerEndpointArgsForCall) 913 } 914 915 func (fake *FakeRepository) DopplerEndpointCalls(stub func() string) { 916 fake.dopplerEndpointMutex.Lock() 917 defer fake.dopplerEndpointMutex.Unlock() 918 fake.DopplerEndpointStub = stub 919 } 920 921 func (fake *FakeRepository) DopplerEndpointReturns(result1 string) { 922 fake.dopplerEndpointMutex.Lock() 923 defer fake.dopplerEndpointMutex.Unlock() 924 fake.DopplerEndpointStub = nil 925 fake.dopplerEndpointReturns = struct { 926 result1 string 927 }{result1} 928 } 929 930 func (fake *FakeRepository) DopplerEndpointReturnsOnCall(i int, result1 string) { 931 fake.dopplerEndpointMutex.Lock() 932 defer fake.dopplerEndpointMutex.Unlock() 933 fake.DopplerEndpointStub = nil 934 if fake.dopplerEndpointReturnsOnCall == nil { 935 fake.dopplerEndpointReturnsOnCall = make(map[int]struct { 936 result1 string 937 }) 938 } 939 fake.dopplerEndpointReturnsOnCall[i] = struct { 940 result1 string 941 }{result1} 942 } 943 944 func (fake *FakeRepository) HasAPIEndpoint() bool { 945 fake.hasAPIEndpointMutex.Lock() 946 ret, specificReturn := fake.hasAPIEndpointReturnsOnCall[len(fake.hasAPIEndpointArgsForCall)] 947 fake.hasAPIEndpointArgsForCall = append(fake.hasAPIEndpointArgsForCall, struct { 948 }{}) 949 fake.recordInvocation("HasAPIEndpoint", []interface{}{}) 950 fake.hasAPIEndpointMutex.Unlock() 951 if fake.HasAPIEndpointStub != nil { 952 return fake.HasAPIEndpointStub() 953 } 954 if specificReturn { 955 return ret.result1 956 } 957 fakeReturns := fake.hasAPIEndpointReturns 958 return fakeReturns.result1 959 } 960 961 func (fake *FakeRepository) HasAPIEndpointCallCount() int { 962 fake.hasAPIEndpointMutex.RLock() 963 defer fake.hasAPIEndpointMutex.RUnlock() 964 return len(fake.hasAPIEndpointArgsForCall) 965 } 966 967 func (fake *FakeRepository) HasAPIEndpointCalls(stub func() bool) { 968 fake.hasAPIEndpointMutex.Lock() 969 defer fake.hasAPIEndpointMutex.Unlock() 970 fake.HasAPIEndpointStub = stub 971 } 972 973 func (fake *FakeRepository) HasAPIEndpointReturns(result1 bool) { 974 fake.hasAPIEndpointMutex.Lock() 975 defer fake.hasAPIEndpointMutex.Unlock() 976 fake.HasAPIEndpointStub = nil 977 fake.hasAPIEndpointReturns = struct { 978 result1 bool 979 }{result1} 980 } 981 982 func (fake *FakeRepository) HasAPIEndpointReturnsOnCall(i int, result1 bool) { 983 fake.hasAPIEndpointMutex.Lock() 984 defer fake.hasAPIEndpointMutex.Unlock() 985 fake.HasAPIEndpointStub = nil 986 if fake.hasAPIEndpointReturnsOnCall == nil { 987 fake.hasAPIEndpointReturnsOnCall = make(map[int]struct { 988 result1 bool 989 }) 990 } 991 fake.hasAPIEndpointReturnsOnCall[i] = struct { 992 result1 bool 993 }{result1} 994 } 995 996 func (fake *FakeRepository) HasOrganization() bool { 997 fake.hasOrganizationMutex.Lock() 998 ret, specificReturn := fake.hasOrganizationReturnsOnCall[len(fake.hasOrganizationArgsForCall)] 999 fake.hasOrganizationArgsForCall = append(fake.hasOrganizationArgsForCall, struct { 1000 }{}) 1001 fake.recordInvocation("HasOrganization", []interface{}{}) 1002 fake.hasOrganizationMutex.Unlock() 1003 if fake.HasOrganizationStub != nil { 1004 return fake.HasOrganizationStub() 1005 } 1006 if specificReturn { 1007 return ret.result1 1008 } 1009 fakeReturns := fake.hasOrganizationReturns 1010 return fakeReturns.result1 1011 } 1012 1013 func (fake *FakeRepository) HasOrganizationCallCount() int { 1014 fake.hasOrganizationMutex.RLock() 1015 defer fake.hasOrganizationMutex.RUnlock() 1016 return len(fake.hasOrganizationArgsForCall) 1017 } 1018 1019 func (fake *FakeRepository) HasOrganizationCalls(stub func() bool) { 1020 fake.hasOrganizationMutex.Lock() 1021 defer fake.hasOrganizationMutex.Unlock() 1022 fake.HasOrganizationStub = stub 1023 } 1024 1025 func (fake *FakeRepository) HasOrganizationReturns(result1 bool) { 1026 fake.hasOrganizationMutex.Lock() 1027 defer fake.hasOrganizationMutex.Unlock() 1028 fake.HasOrganizationStub = nil 1029 fake.hasOrganizationReturns = struct { 1030 result1 bool 1031 }{result1} 1032 } 1033 1034 func (fake *FakeRepository) HasOrganizationReturnsOnCall(i int, result1 bool) { 1035 fake.hasOrganizationMutex.Lock() 1036 defer fake.hasOrganizationMutex.Unlock() 1037 fake.HasOrganizationStub = nil 1038 if fake.hasOrganizationReturnsOnCall == nil { 1039 fake.hasOrganizationReturnsOnCall = make(map[int]struct { 1040 result1 bool 1041 }) 1042 } 1043 fake.hasOrganizationReturnsOnCall[i] = struct { 1044 result1 bool 1045 }{result1} 1046 } 1047 1048 func (fake *FakeRepository) HasSpace() bool { 1049 fake.hasSpaceMutex.Lock() 1050 ret, specificReturn := fake.hasSpaceReturnsOnCall[len(fake.hasSpaceArgsForCall)] 1051 fake.hasSpaceArgsForCall = append(fake.hasSpaceArgsForCall, struct { 1052 }{}) 1053 fake.recordInvocation("HasSpace", []interface{}{}) 1054 fake.hasSpaceMutex.Unlock() 1055 if fake.HasSpaceStub != nil { 1056 return fake.HasSpaceStub() 1057 } 1058 if specificReturn { 1059 return ret.result1 1060 } 1061 fakeReturns := fake.hasSpaceReturns 1062 return fakeReturns.result1 1063 } 1064 1065 func (fake *FakeRepository) HasSpaceCallCount() int { 1066 fake.hasSpaceMutex.RLock() 1067 defer fake.hasSpaceMutex.RUnlock() 1068 return len(fake.hasSpaceArgsForCall) 1069 } 1070 1071 func (fake *FakeRepository) HasSpaceCalls(stub func() bool) { 1072 fake.hasSpaceMutex.Lock() 1073 defer fake.hasSpaceMutex.Unlock() 1074 fake.HasSpaceStub = stub 1075 } 1076 1077 func (fake *FakeRepository) HasSpaceReturns(result1 bool) { 1078 fake.hasSpaceMutex.Lock() 1079 defer fake.hasSpaceMutex.Unlock() 1080 fake.HasSpaceStub = nil 1081 fake.hasSpaceReturns = struct { 1082 result1 bool 1083 }{result1} 1084 } 1085 1086 func (fake *FakeRepository) HasSpaceReturnsOnCall(i int, result1 bool) { 1087 fake.hasSpaceMutex.Lock() 1088 defer fake.hasSpaceMutex.Unlock() 1089 fake.HasSpaceStub = nil 1090 if fake.hasSpaceReturnsOnCall == nil { 1091 fake.hasSpaceReturnsOnCall = make(map[int]struct { 1092 result1 bool 1093 }) 1094 } 1095 fake.hasSpaceReturnsOnCall[i] = struct { 1096 result1 bool 1097 }{result1} 1098 } 1099 1100 func (fake *FakeRepository) IsLoggedIn() bool { 1101 fake.isLoggedInMutex.Lock() 1102 ret, specificReturn := fake.isLoggedInReturnsOnCall[len(fake.isLoggedInArgsForCall)] 1103 fake.isLoggedInArgsForCall = append(fake.isLoggedInArgsForCall, struct { 1104 }{}) 1105 fake.recordInvocation("IsLoggedIn", []interface{}{}) 1106 fake.isLoggedInMutex.Unlock() 1107 if fake.IsLoggedInStub != nil { 1108 return fake.IsLoggedInStub() 1109 } 1110 if specificReturn { 1111 return ret.result1 1112 } 1113 fakeReturns := fake.isLoggedInReturns 1114 return fakeReturns.result1 1115 } 1116 1117 func (fake *FakeRepository) IsLoggedInCallCount() int { 1118 fake.isLoggedInMutex.RLock() 1119 defer fake.isLoggedInMutex.RUnlock() 1120 return len(fake.isLoggedInArgsForCall) 1121 } 1122 1123 func (fake *FakeRepository) IsLoggedInCalls(stub func() bool) { 1124 fake.isLoggedInMutex.Lock() 1125 defer fake.isLoggedInMutex.Unlock() 1126 fake.IsLoggedInStub = stub 1127 } 1128 1129 func (fake *FakeRepository) IsLoggedInReturns(result1 bool) { 1130 fake.isLoggedInMutex.Lock() 1131 defer fake.isLoggedInMutex.Unlock() 1132 fake.IsLoggedInStub = nil 1133 fake.isLoggedInReturns = struct { 1134 result1 bool 1135 }{result1} 1136 } 1137 1138 func (fake *FakeRepository) IsLoggedInReturnsOnCall(i int, result1 bool) { 1139 fake.isLoggedInMutex.Lock() 1140 defer fake.isLoggedInMutex.Unlock() 1141 fake.IsLoggedInStub = nil 1142 if fake.isLoggedInReturnsOnCall == nil { 1143 fake.isLoggedInReturnsOnCall = make(map[int]struct { 1144 result1 bool 1145 }) 1146 } 1147 fake.isLoggedInReturnsOnCall[i] = struct { 1148 result1 bool 1149 }{result1} 1150 } 1151 1152 func (fake *FakeRepository) IsMinAPIVersion(arg1 semver.Version) bool { 1153 fake.isMinAPIVersionMutex.Lock() 1154 ret, specificReturn := fake.isMinAPIVersionReturnsOnCall[len(fake.isMinAPIVersionArgsForCall)] 1155 fake.isMinAPIVersionArgsForCall = append(fake.isMinAPIVersionArgsForCall, struct { 1156 arg1 semver.Version 1157 }{arg1}) 1158 fake.recordInvocation("IsMinAPIVersion", []interface{}{arg1}) 1159 fake.isMinAPIVersionMutex.Unlock() 1160 if fake.IsMinAPIVersionStub != nil { 1161 return fake.IsMinAPIVersionStub(arg1) 1162 } 1163 if specificReturn { 1164 return ret.result1 1165 } 1166 fakeReturns := fake.isMinAPIVersionReturns 1167 return fakeReturns.result1 1168 } 1169 1170 func (fake *FakeRepository) IsMinAPIVersionCallCount() int { 1171 fake.isMinAPIVersionMutex.RLock() 1172 defer fake.isMinAPIVersionMutex.RUnlock() 1173 return len(fake.isMinAPIVersionArgsForCall) 1174 } 1175 1176 func (fake *FakeRepository) IsMinAPIVersionCalls(stub func(semver.Version) bool) { 1177 fake.isMinAPIVersionMutex.Lock() 1178 defer fake.isMinAPIVersionMutex.Unlock() 1179 fake.IsMinAPIVersionStub = stub 1180 } 1181 1182 func (fake *FakeRepository) IsMinAPIVersionArgsForCall(i int) semver.Version { 1183 fake.isMinAPIVersionMutex.RLock() 1184 defer fake.isMinAPIVersionMutex.RUnlock() 1185 argsForCall := fake.isMinAPIVersionArgsForCall[i] 1186 return argsForCall.arg1 1187 } 1188 1189 func (fake *FakeRepository) IsMinAPIVersionReturns(result1 bool) { 1190 fake.isMinAPIVersionMutex.Lock() 1191 defer fake.isMinAPIVersionMutex.Unlock() 1192 fake.IsMinAPIVersionStub = nil 1193 fake.isMinAPIVersionReturns = struct { 1194 result1 bool 1195 }{result1} 1196 } 1197 1198 func (fake *FakeRepository) IsMinAPIVersionReturnsOnCall(i int, result1 bool) { 1199 fake.isMinAPIVersionMutex.Lock() 1200 defer fake.isMinAPIVersionMutex.Unlock() 1201 fake.IsMinAPIVersionStub = nil 1202 if fake.isMinAPIVersionReturnsOnCall == nil { 1203 fake.isMinAPIVersionReturnsOnCall = make(map[int]struct { 1204 result1 bool 1205 }) 1206 } 1207 fake.isMinAPIVersionReturnsOnCall[i] = struct { 1208 result1 bool 1209 }{result1} 1210 } 1211 1212 func (fake *FakeRepository) IsMinCLIVersion(arg1 string) bool { 1213 fake.isMinCLIVersionMutex.Lock() 1214 ret, specificReturn := fake.isMinCLIVersionReturnsOnCall[len(fake.isMinCLIVersionArgsForCall)] 1215 fake.isMinCLIVersionArgsForCall = append(fake.isMinCLIVersionArgsForCall, struct { 1216 arg1 string 1217 }{arg1}) 1218 fake.recordInvocation("IsMinCLIVersion", []interface{}{arg1}) 1219 fake.isMinCLIVersionMutex.Unlock() 1220 if fake.IsMinCLIVersionStub != nil { 1221 return fake.IsMinCLIVersionStub(arg1) 1222 } 1223 if specificReturn { 1224 return ret.result1 1225 } 1226 fakeReturns := fake.isMinCLIVersionReturns 1227 return fakeReturns.result1 1228 } 1229 1230 func (fake *FakeRepository) IsMinCLIVersionCallCount() int { 1231 fake.isMinCLIVersionMutex.RLock() 1232 defer fake.isMinCLIVersionMutex.RUnlock() 1233 return len(fake.isMinCLIVersionArgsForCall) 1234 } 1235 1236 func (fake *FakeRepository) IsMinCLIVersionCalls(stub func(string) bool) { 1237 fake.isMinCLIVersionMutex.Lock() 1238 defer fake.isMinCLIVersionMutex.Unlock() 1239 fake.IsMinCLIVersionStub = stub 1240 } 1241 1242 func (fake *FakeRepository) IsMinCLIVersionArgsForCall(i int) string { 1243 fake.isMinCLIVersionMutex.RLock() 1244 defer fake.isMinCLIVersionMutex.RUnlock() 1245 argsForCall := fake.isMinCLIVersionArgsForCall[i] 1246 return argsForCall.arg1 1247 } 1248 1249 func (fake *FakeRepository) IsMinCLIVersionReturns(result1 bool) { 1250 fake.isMinCLIVersionMutex.Lock() 1251 defer fake.isMinCLIVersionMutex.Unlock() 1252 fake.IsMinCLIVersionStub = nil 1253 fake.isMinCLIVersionReturns = struct { 1254 result1 bool 1255 }{result1} 1256 } 1257 1258 func (fake *FakeRepository) IsMinCLIVersionReturnsOnCall(i int, result1 bool) { 1259 fake.isMinCLIVersionMutex.Lock() 1260 defer fake.isMinCLIVersionMutex.Unlock() 1261 fake.IsMinCLIVersionStub = nil 1262 if fake.isMinCLIVersionReturnsOnCall == nil { 1263 fake.isMinCLIVersionReturnsOnCall = make(map[int]struct { 1264 result1 bool 1265 }) 1266 } 1267 fake.isMinCLIVersionReturnsOnCall[i] = struct { 1268 result1 bool 1269 }{result1} 1270 } 1271 1272 func (fake *FakeRepository) IsSSLDisabled() bool { 1273 fake.isSSLDisabledMutex.Lock() 1274 ret, specificReturn := fake.isSSLDisabledReturnsOnCall[len(fake.isSSLDisabledArgsForCall)] 1275 fake.isSSLDisabledArgsForCall = append(fake.isSSLDisabledArgsForCall, struct { 1276 }{}) 1277 fake.recordInvocation("IsSSLDisabled", []interface{}{}) 1278 fake.isSSLDisabledMutex.Unlock() 1279 if fake.IsSSLDisabledStub != nil { 1280 return fake.IsSSLDisabledStub() 1281 } 1282 if specificReturn { 1283 return ret.result1 1284 } 1285 fakeReturns := fake.isSSLDisabledReturns 1286 return fakeReturns.result1 1287 } 1288 1289 func (fake *FakeRepository) IsSSLDisabledCallCount() int { 1290 fake.isSSLDisabledMutex.RLock() 1291 defer fake.isSSLDisabledMutex.RUnlock() 1292 return len(fake.isSSLDisabledArgsForCall) 1293 } 1294 1295 func (fake *FakeRepository) IsSSLDisabledCalls(stub func() bool) { 1296 fake.isSSLDisabledMutex.Lock() 1297 defer fake.isSSLDisabledMutex.Unlock() 1298 fake.IsSSLDisabledStub = stub 1299 } 1300 1301 func (fake *FakeRepository) IsSSLDisabledReturns(result1 bool) { 1302 fake.isSSLDisabledMutex.Lock() 1303 defer fake.isSSLDisabledMutex.Unlock() 1304 fake.IsSSLDisabledStub = nil 1305 fake.isSSLDisabledReturns = struct { 1306 result1 bool 1307 }{result1} 1308 } 1309 1310 func (fake *FakeRepository) IsSSLDisabledReturnsOnCall(i int, result1 bool) { 1311 fake.isSSLDisabledMutex.Lock() 1312 defer fake.isSSLDisabledMutex.Unlock() 1313 fake.IsSSLDisabledStub = nil 1314 if fake.isSSLDisabledReturnsOnCall == nil { 1315 fake.isSSLDisabledReturnsOnCall = make(map[int]struct { 1316 result1 bool 1317 }) 1318 } 1319 fake.isSSLDisabledReturnsOnCall[i] = struct { 1320 result1 bool 1321 }{result1} 1322 } 1323 1324 func (fake *FakeRepository) Locale() string { 1325 fake.localeMutex.Lock() 1326 ret, specificReturn := fake.localeReturnsOnCall[len(fake.localeArgsForCall)] 1327 fake.localeArgsForCall = append(fake.localeArgsForCall, struct { 1328 }{}) 1329 fake.recordInvocation("Locale", []interface{}{}) 1330 fake.localeMutex.Unlock() 1331 if fake.LocaleStub != nil { 1332 return fake.LocaleStub() 1333 } 1334 if specificReturn { 1335 return ret.result1 1336 } 1337 fakeReturns := fake.localeReturns 1338 return fakeReturns.result1 1339 } 1340 1341 func (fake *FakeRepository) LocaleCallCount() int { 1342 fake.localeMutex.RLock() 1343 defer fake.localeMutex.RUnlock() 1344 return len(fake.localeArgsForCall) 1345 } 1346 1347 func (fake *FakeRepository) LocaleCalls(stub func() string) { 1348 fake.localeMutex.Lock() 1349 defer fake.localeMutex.Unlock() 1350 fake.LocaleStub = stub 1351 } 1352 1353 func (fake *FakeRepository) LocaleReturns(result1 string) { 1354 fake.localeMutex.Lock() 1355 defer fake.localeMutex.Unlock() 1356 fake.LocaleStub = nil 1357 fake.localeReturns = struct { 1358 result1 string 1359 }{result1} 1360 } 1361 1362 func (fake *FakeRepository) LocaleReturnsOnCall(i int, result1 string) { 1363 fake.localeMutex.Lock() 1364 defer fake.localeMutex.Unlock() 1365 fake.LocaleStub = nil 1366 if fake.localeReturnsOnCall == nil { 1367 fake.localeReturnsOnCall = make(map[int]struct { 1368 result1 string 1369 }) 1370 } 1371 fake.localeReturnsOnCall[i] = struct { 1372 result1 string 1373 }{result1} 1374 } 1375 1376 func (fake *FakeRepository) LogCacheEndpoint() string { 1377 fake.logCacheEndpointMutex.Lock() 1378 ret, specificReturn := fake.logCacheEndpointReturnsOnCall[len(fake.logCacheEndpointArgsForCall)] 1379 fake.logCacheEndpointArgsForCall = append(fake.logCacheEndpointArgsForCall, struct { 1380 }{}) 1381 fake.recordInvocation("LogCacheEndpoint", []interface{}{}) 1382 fake.logCacheEndpointMutex.Unlock() 1383 if fake.LogCacheEndpointStub != nil { 1384 return fake.LogCacheEndpointStub() 1385 } 1386 if specificReturn { 1387 return ret.result1 1388 } 1389 fakeReturns := fake.logCacheEndpointReturns 1390 return fakeReturns.result1 1391 } 1392 1393 func (fake *FakeRepository) LogCacheEndpointCallCount() int { 1394 fake.logCacheEndpointMutex.RLock() 1395 defer fake.logCacheEndpointMutex.RUnlock() 1396 return len(fake.logCacheEndpointArgsForCall) 1397 } 1398 1399 func (fake *FakeRepository) LogCacheEndpointCalls(stub func() string) { 1400 fake.logCacheEndpointMutex.Lock() 1401 defer fake.logCacheEndpointMutex.Unlock() 1402 fake.LogCacheEndpointStub = stub 1403 } 1404 1405 func (fake *FakeRepository) LogCacheEndpointReturns(result1 string) { 1406 fake.logCacheEndpointMutex.Lock() 1407 defer fake.logCacheEndpointMutex.Unlock() 1408 fake.LogCacheEndpointStub = nil 1409 fake.logCacheEndpointReturns = struct { 1410 result1 string 1411 }{result1} 1412 } 1413 1414 func (fake *FakeRepository) LogCacheEndpointReturnsOnCall(i int, result1 string) { 1415 fake.logCacheEndpointMutex.Lock() 1416 defer fake.logCacheEndpointMutex.Unlock() 1417 fake.LogCacheEndpointStub = nil 1418 if fake.logCacheEndpointReturnsOnCall == nil { 1419 fake.logCacheEndpointReturnsOnCall = make(map[int]struct { 1420 result1 string 1421 }) 1422 } 1423 fake.logCacheEndpointReturnsOnCall[i] = struct { 1424 result1 string 1425 }{result1} 1426 } 1427 1428 func (fake *FakeRepository) MinCLIVersion() string { 1429 fake.minCLIVersionMutex.Lock() 1430 ret, specificReturn := fake.minCLIVersionReturnsOnCall[len(fake.minCLIVersionArgsForCall)] 1431 fake.minCLIVersionArgsForCall = append(fake.minCLIVersionArgsForCall, struct { 1432 }{}) 1433 fake.recordInvocation("MinCLIVersion", []interface{}{}) 1434 fake.minCLIVersionMutex.Unlock() 1435 if fake.MinCLIVersionStub != nil { 1436 return fake.MinCLIVersionStub() 1437 } 1438 if specificReturn { 1439 return ret.result1 1440 } 1441 fakeReturns := fake.minCLIVersionReturns 1442 return fakeReturns.result1 1443 } 1444 1445 func (fake *FakeRepository) MinCLIVersionCallCount() int { 1446 fake.minCLIVersionMutex.RLock() 1447 defer fake.minCLIVersionMutex.RUnlock() 1448 return len(fake.minCLIVersionArgsForCall) 1449 } 1450 1451 func (fake *FakeRepository) MinCLIVersionCalls(stub func() string) { 1452 fake.minCLIVersionMutex.Lock() 1453 defer fake.minCLIVersionMutex.Unlock() 1454 fake.MinCLIVersionStub = stub 1455 } 1456 1457 func (fake *FakeRepository) MinCLIVersionReturns(result1 string) { 1458 fake.minCLIVersionMutex.Lock() 1459 defer fake.minCLIVersionMutex.Unlock() 1460 fake.MinCLIVersionStub = nil 1461 fake.minCLIVersionReturns = struct { 1462 result1 string 1463 }{result1} 1464 } 1465 1466 func (fake *FakeRepository) MinCLIVersionReturnsOnCall(i int, result1 string) { 1467 fake.minCLIVersionMutex.Lock() 1468 defer fake.minCLIVersionMutex.Unlock() 1469 fake.MinCLIVersionStub = nil 1470 if fake.minCLIVersionReturnsOnCall == nil { 1471 fake.minCLIVersionReturnsOnCall = make(map[int]struct { 1472 result1 string 1473 }) 1474 } 1475 fake.minCLIVersionReturnsOnCall[i] = struct { 1476 result1 string 1477 }{result1} 1478 } 1479 1480 func (fake *FakeRepository) MinRecommendedCLIVersion() string { 1481 fake.minRecommendedCLIVersionMutex.Lock() 1482 ret, specificReturn := fake.minRecommendedCLIVersionReturnsOnCall[len(fake.minRecommendedCLIVersionArgsForCall)] 1483 fake.minRecommendedCLIVersionArgsForCall = append(fake.minRecommendedCLIVersionArgsForCall, struct { 1484 }{}) 1485 fake.recordInvocation("MinRecommendedCLIVersion", []interface{}{}) 1486 fake.minRecommendedCLIVersionMutex.Unlock() 1487 if fake.MinRecommendedCLIVersionStub != nil { 1488 return fake.MinRecommendedCLIVersionStub() 1489 } 1490 if specificReturn { 1491 return ret.result1 1492 } 1493 fakeReturns := fake.minRecommendedCLIVersionReturns 1494 return fakeReturns.result1 1495 } 1496 1497 func (fake *FakeRepository) MinRecommendedCLIVersionCallCount() int { 1498 fake.minRecommendedCLIVersionMutex.RLock() 1499 defer fake.minRecommendedCLIVersionMutex.RUnlock() 1500 return len(fake.minRecommendedCLIVersionArgsForCall) 1501 } 1502 1503 func (fake *FakeRepository) MinRecommendedCLIVersionCalls(stub func() string) { 1504 fake.minRecommendedCLIVersionMutex.Lock() 1505 defer fake.minRecommendedCLIVersionMutex.Unlock() 1506 fake.MinRecommendedCLIVersionStub = stub 1507 } 1508 1509 func (fake *FakeRepository) MinRecommendedCLIVersionReturns(result1 string) { 1510 fake.minRecommendedCLIVersionMutex.Lock() 1511 defer fake.minRecommendedCLIVersionMutex.Unlock() 1512 fake.MinRecommendedCLIVersionStub = nil 1513 fake.minRecommendedCLIVersionReturns = struct { 1514 result1 string 1515 }{result1} 1516 } 1517 1518 func (fake *FakeRepository) MinRecommendedCLIVersionReturnsOnCall(i int, result1 string) { 1519 fake.minRecommendedCLIVersionMutex.Lock() 1520 defer fake.minRecommendedCLIVersionMutex.Unlock() 1521 fake.MinRecommendedCLIVersionStub = nil 1522 if fake.minRecommendedCLIVersionReturnsOnCall == nil { 1523 fake.minRecommendedCLIVersionReturnsOnCall = make(map[int]struct { 1524 result1 string 1525 }) 1526 } 1527 fake.minRecommendedCLIVersionReturnsOnCall[i] = struct { 1528 result1 string 1529 }{result1} 1530 } 1531 1532 func (fake *FakeRepository) OrganizationFields() models.OrganizationFields { 1533 fake.organizationFieldsMutex.Lock() 1534 ret, specificReturn := fake.organizationFieldsReturnsOnCall[len(fake.organizationFieldsArgsForCall)] 1535 fake.organizationFieldsArgsForCall = append(fake.organizationFieldsArgsForCall, struct { 1536 }{}) 1537 fake.recordInvocation("OrganizationFields", []interface{}{}) 1538 fake.organizationFieldsMutex.Unlock() 1539 if fake.OrganizationFieldsStub != nil { 1540 return fake.OrganizationFieldsStub() 1541 } 1542 if specificReturn { 1543 return ret.result1 1544 } 1545 fakeReturns := fake.organizationFieldsReturns 1546 return fakeReturns.result1 1547 } 1548 1549 func (fake *FakeRepository) OrganizationFieldsCallCount() int { 1550 fake.organizationFieldsMutex.RLock() 1551 defer fake.organizationFieldsMutex.RUnlock() 1552 return len(fake.organizationFieldsArgsForCall) 1553 } 1554 1555 func (fake *FakeRepository) OrganizationFieldsCalls(stub func() models.OrganizationFields) { 1556 fake.organizationFieldsMutex.Lock() 1557 defer fake.organizationFieldsMutex.Unlock() 1558 fake.OrganizationFieldsStub = stub 1559 } 1560 1561 func (fake *FakeRepository) OrganizationFieldsReturns(result1 models.OrganizationFields) { 1562 fake.organizationFieldsMutex.Lock() 1563 defer fake.organizationFieldsMutex.Unlock() 1564 fake.OrganizationFieldsStub = nil 1565 fake.organizationFieldsReturns = struct { 1566 result1 models.OrganizationFields 1567 }{result1} 1568 } 1569 1570 func (fake *FakeRepository) OrganizationFieldsReturnsOnCall(i int, result1 models.OrganizationFields) { 1571 fake.organizationFieldsMutex.Lock() 1572 defer fake.organizationFieldsMutex.Unlock() 1573 fake.OrganizationFieldsStub = nil 1574 if fake.organizationFieldsReturnsOnCall == nil { 1575 fake.organizationFieldsReturnsOnCall = make(map[int]struct { 1576 result1 models.OrganizationFields 1577 }) 1578 } 1579 fake.organizationFieldsReturnsOnCall[i] = struct { 1580 result1 models.OrganizationFields 1581 }{result1} 1582 } 1583 1584 func (fake *FakeRepository) PluginRepos() []models.PluginRepo { 1585 fake.pluginReposMutex.Lock() 1586 ret, specificReturn := fake.pluginReposReturnsOnCall[len(fake.pluginReposArgsForCall)] 1587 fake.pluginReposArgsForCall = append(fake.pluginReposArgsForCall, struct { 1588 }{}) 1589 fake.recordInvocation("PluginRepos", []interface{}{}) 1590 fake.pluginReposMutex.Unlock() 1591 if fake.PluginReposStub != nil { 1592 return fake.PluginReposStub() 1593 } 1594 if specificReturn { 1595 return ret.result1 1596 } 1597 fakeReturns := fake.pluginReposReturns 1598 return fakeReturns.result1 1599 } 1600 1601 func (fake *FakeRepository) PluginReposCallCount() int { 1602 fake.pluginReposMutex.RLock() 1603 defer fake.pluginReposMutex.RUnlock() 1604 return len(fake.pluginReposArgsForCall) 1605 } 1606 1607 func (fake *FakeRepository) PluginReposCalls(stub func() []models.PluginRepo) { 1608 fake.pluginReposMutex.Lock() 1609 defer fake.pluginReposMutex.Unlock() 1610 fake.PluginReposStub = stub 1611 } 1612 1613 func (fake *FakeRepository) PluginReposReturns(result1 []models.PluginRepo) { 1614 fake.pluginReposMutex.Lock() 1615 defer fake.pluginReposMutex.Unlock() 1616 fake.PluginReposStub = nil 1617 fake.pluginReposReturns = struct { 1618 result1 []models.PluginRepo 1619 }{result1} 1620 } 1621 1622 func (fake *FakeRepository) PluginReposReturnsOnCall(i int, result1 []models.PluginRepo) { 1623 fake.pluginReposMutex.Lock() 1624 defer fake.pluginReposMutex.Unlock() 1625 fake.PluginReposStub = nil 1626 if fake.pluginReposReturnsOnCall == nil { 1627 fake.pluginReposReturnsOnCall = make(map[int]struct { 1628 result1 []models.PluginRepo 1629 }) 1630 } 1631 fake.pluginReposReturnsOnCall[i] = struct { 1632 result1 []models.PluginRepo 1633 }{result1} 1634 } 1635 1636 func (fake *FakeRepository) RefreshToken() string { 1637 fake.refreshTokenMutex.Lock() 1638 ret, specificReturn := fake.refreshTokenReturnsOnCall[len(fake.refreshTokenArgsForCall)] 1639 fake.refreshTokenArgsForCall = append(fake.refreshTokenArgsForCall, struct { 1640 }{}) 1641 fake.recordInvocation("RefreshToken", []interface{}{}) 1642 fake.refreshTokenMutex.Unlock() 1643 if fake.RefreshTokenStub != nil { 1644 return fake.RefreshTokenStub() 1645 } 1646 if specificReturn { 1647 return ret.result1 1648 } 1649 fakeReturns := fake.refreshTokenReturns 1650 return fakeReturns.result1 1651 } 1652 1653 func (fake *FakeRepository) RefreshTokenCallCount() int { 1654 fake.refreshTokenMutex.RLock() 1655 defer fake.refreshTokenMutex.RUnlock() 1656 return len(fake.refreshTokenArgsForCall) 1657 } 1658 1659 func (fake *FakeRepository) RefreshTokenCalls(stub func() string) { 1660 fake.refreshTokenMutex.Lock() 1661 defer fake.refreshTokenMutex.Unlock() 1662 fake.RefreshTokenStub = stub 1663 } 1664 1665 func (fake *FakeRepository) RefreshTokenReturns(result1 string) { 1666 fake.refreshTokenMutex.Lock() 1667 defer fake.refreshTokenMutex.Unlock() 1668 fake.RefreshTokenStub = nil 1669 fake.refreshTokenReturns = struct { 1670 result1 string 1671 }{result1} 1672 } 1673 1674 func (fake *FakeRepository) RefreshTokenReturnsOnCall(i int, result1 string) { 1675 fake.refreshTokenMutex.Lock() 1676 defer fake.refreshTokenMutex.Unlock() 1677 fake.RefreshTokenStub = nil 1678 if fake.refreshTokenReturnsOnCall == nil { 1679 fake.refreshTokenReturnsOnCall = make(map[int]struct { 1680 result1 string 1681 }) 1682 } 1683 fake.refreshTokenReturnsOnCall[i] = struct { 1684 result1 string 1685 }{result1} 1686 } 1687 1688 func (fake *FakeRepository) RoutingAPIEndpoint() string { 1689 fake.routingAPIEndpointMutex.Lock() 1690 ret, specificReturn := fake.routingAPIEndpointReturnsOnCall[len(fake.routingAPIEndpointArgsForCall)] 1691 fake.routingAPIEndpointArgsForCall = append(fake.routingAPIEndpointArgsForCall, struct { 1692 }{}) 1693 fake.recordInvocation("RoutingAPIEndpoint", []interface{}{}) 1694 fake.routingAPIEndpointMutex.Unlock() 1695 if fake.RoutingAPIEndpointStub != nil { 1696 return fake.RoutingAPIEndpointStub() 1697 } 1698 if specificReturn { 1699 return ret.result1 1700 } 1701 fakeReturns := fake.routingAPIEndpointReturns 1702 return fakeReturns.result1 1703 } 1704 1705 func (fake *FakeRepository) RoutingAPIEndpointCallCount() int { 1706 fake.routingAPIEndpointMutex.RLock() 1707 defer fake.routingAPIEndpointMutex.RUnlock() 1708 return len(fake.routingAPIEndpointArgsForCall) 1709 } 1710 1711 func (fake *FakeRepository) RoutingAPIEndpointCalls(stub func() string) { 1712 fake.routingAPIEndpointMutex.Lock() 1713 defer fake.routingAPIEndpointMutex.Unlock() 1714 fake.RoutingAPIEndpointStub = stub 1715 } 1716 1717 func (fake *FakeRepository) RoutingAPIEndpointReturns(result1 string) { 1718 fake.routingAPIEndpointMutex.Lock() 1719 defer fake.routingAPIEndpointMutex.Unlock() 1720 fake.RoutingAPIEndpointStub = nil 1721 fake.routingAPIEndpointReturns = struct { 1722 result1 string 1723 }{result1} 1724 } 1725 1726 func (fake *FakeRepository) RoutingAPIEndpointReturnsOnCall(i int, result1 string) { 1727 fake.routingAPIEndpointMutex.Lock() 1728 defer fake.routingAPIEndpointMutex.Unlock() 1729 fake.RoutingAPIEndpointStub = nil 1730 if fake.routingAPIEndpointReturnsOnCall == nil { 1731 fake.routingAPIEndpointReturnsOnCall = make(map[int]struct { 1732 result1 string 1733 }) 1734 } 1735 fake.routingAPIEndpointReturnsOnCall[i] = struct { 1736 result1 string 1737 }{result1} 1738 } 1739 1740 func (fake *FakeRepository) SSHOAuthClient() string { 1741 fake.sSHOAuthClientMutex.Lock() 1742 ret, specificReturn := fake.sSHOAuthClientReturnsOnCall[len(fake.sSHOAuthClientArgsForCall)] 1743 fake.sSHOAuthClientArgsForCall = append(fake.sSHOAuthClientArgsForCall, struct { 1744 }{}) 1745 fake.recordInvocation("SSHOAuthClient", []interface{}{}) 1746 fake.sSHOAuthClientMutex.Unlock() 1747 if fake.SSHOAuthClientStub != nil { 1748 return fake.SSHOAuthClientStub() 1749 } 1750 if specificReturn { 1751 return ret.result1 1752 } 1753 fakeReturns := fake.sSHOAuthClientReturns 1754 return fakeReturns.result1 1755 } 1756 1757 func (fake *FakeRepository) SSHOAuthClientCallCount() int { 1758 fake.sSHOAuthClientMutex.RLock() 1759 defer fake.sSHOAuthClientMutex.RUnlock() 1760 return len(fake.sSHOAuthClientArgsForCall) 1761 } 1762 1763 func (fake *FakeRepository) SSHOAuthClientCalls(stub func() string) { 1764 fake.sSHOAuthClientMutex.Lock() 1765 defer fake.sSHOAuthClientMutex.Unlock() 1766 fake.SSHOAuthClientStub = stub 1767 } 1768 1769 func (fake *FakeRepository) SSHOAuthClientReturns(result1 string) { 1770 fake.sSHOAuthClientMutex.Lock() 1771 defer fake.sSHOAuthClientMutex.Unlock() 1772 fake.SSHOAuthClientStub = nil 1773 fake.sSHOAuthClientReturns = struct { 1774 result1 string 1775 }{result1} 1776 } 1777 1778 func (fake *FakeRepository) SSHOAuthClientReturnsOnCall(i int, result1 string) { 1779 fake.sSHOAuthClientMutex.Lock() 1780 defer fake.sSHOAuthClientMutex.Unlock() 1781 fake.SSHOAuthClientStub = nil 1782 if fake.sSHOAuthClientReturnsOnCall == nil { 1783 fake.sSHOAuthClientReturnsOnCall = make(map[int]struct { 1784 result1 string 1785 }) 1786 } 1787 fake.sSHOAuthClientReturnsOnCall[i] = struct { 1788 result1 string 1789 }{result1} 1790 } 1791 1792 func (fake *FakeRepository) SetAPIEndpoint(arg1 string) { 1793 fake.setAPIEndpointMutex.Lock() 1794 fake.setAPIEndpointArgsForCall = append(fake.setAPIEndpointArgsForCall, struct { 1795 arg1 string 1796 }{arg1}) 1797 fake.recordInvocation("SetAPIEndpoint", []interface{}{arg1}) 1798 fake.setAPIEndpointMutex.Unlock() 1799 if fake.SetAPIEndpointStub != nil { 1800 fake.SetAPIEndpointStub(arg1) 1801 } 1802 } 1803 1804 func (fake *FakeRepository) SetAPIEndpointCallCount() int { 1805 fake.setAPIEndpointMutex.RLock() 1806 defer fake.setAPIEndpointMutex.RUnlock() 1807 return len(fake.setAPIEndpointArgsForCall) 1808 } 1809 1810 func (fake *FakeRepository) SetAPIEndpointCalls(stub func(string)) { 1811 fake.setAPIEndpointMutex.Lock() 1812 defer fake.setAPIEndpointMutex.Unlock() 1813 fake.SetAPIEndpointStub = stub 1814 } 1815 1816 func (fake *FakeRepository) SetAPIEndpointArgsForCall(i int) string { 1817 fake.setAPIEndpointMutex.RLock() 1818 defer fake.setAPIEndpointMutex.RUnlock() 1819 argsForCall := fake.setAPIEndpointArgsForCall[i] 1820 return argsForCall.arg1 1821 } 1822 1823 func (fake *FakeRepository) SetAPIVersion(arg1 string) { 1824 fake.setAPIVersionMutex.Lock() 1825 fake.setAPIVersionArgsForCall = append(fake.setAPIVersionArgsForCall, struct { 1826 arg1 string 1827 }{arg1}) 1828 fake.recordInvocation("SetAPIVersion", []interface{}{arg1}) 1829 fake.setAPIVersionMutex.Unlock() 1830 if fake.SetAPIVersionStub != nil { 1831 fake.SetAPIVersionStub(arg1) 1832 } 1833 } 1834 1835 func (fake *FakeRepository) SetAPIVersionCallCount() int { 1836 fake.setAPIVersionMutex.RLock() 1837 defer fake.setAPIVersionMutex.RUnlock() 1838 return len(fake.setAPIVersionArgsForCall) 1839 } 1840 1841 func (fake *FakeRepository) SetAPIVersionCalls(stub func(string)) { 1842 fake.setAPIVersionMutex.Lock() 1843 defer fake.setAPIVersionMutex.Unlock() 1844 fake.SetAPIVersionStub = stub 1845 } 1846 1847 func (fake *FakeRepository) SetAPIVersionArgsForCall(i int) string { 1848 fake.setAPIVersionMutex.RLock() 1849 defer fake.setAPIVersionMutex.RUnlock() 1850 argsForCall := fake.setAPIVersionArgsForCall[i] 1851 return argsForCall.arg1 1852 } 1853 1854 func (fake *FakeRepository) SetAccessToken(arg1 string) { 1855 fake.setAccessTokenMutex.Lock() 1856 fake.setAccessTokenArgsForCall = append(fake.setAccessTokenArgsForCall, struct { 1857 arg1 string 1858 }{arg1}) 1859 fake.recordInvocation("SetAccessToken", []interface{}{arg1}) 1860 fake.setAccessTokenMutex.Unlock() 1861 if fake.SetAccessTokenStub != nil { 1862 fake.SetAccessTokenStub(arg1) 1863 } 1864 } 1865 1866 func (fake *FakeRepository) SetAccessTokenCallCount() int { 1867 fake.setAccessTokenMutex.RLock() 1868 defer fake.setAccessTokenMutex.RUnlock() 1869 return len(fake.setAccessTokenArgsForCall) 1870 } 1871 1872 func (fake *FakeRepository) SetAccessTokenCalls(stub func(string)) { 1873 fake.setAccessTokenMutex.Lock() 1874 defer fake.setAccessTokenMutex.Unlock() 1875 fake.SetAccessTokenStub = stub 1876 } 1877 1878 func (fake *FakeRepository) SetAccessTokenArgsForCall(i int) string { 1879 fake.setAccessTokenMutex.RLock() 1880 defer fake.setAccessTokenMutex.RUnlock() 1881 argsForCall := fake.setAccessTokenArgsForCall[i] 1882 return argsForCall.arg1 1883 } 1884 1885 func (fake *FakeRepository) SetAsyncTimeout(arg1 uint) { 1886 fake.setAsyncTimeoutMutex.Lock() 1887 fake.setAsyncTimeoutArgsForCall = append(fake.setAsyncTimeoutArgsForCall, struct { 1888 arg1 uint 1889 }{arg1}) 1890 fake.recordInvocation("SetAsyncTimeout", []interface{}{arg1}) 1891 fake.setAsyncTimeoutMutex.Unlock() 1892 if fake.SetAsyncTimeoutStub != nil { 1893 fake.SetAsyncTimeoutStub(arg1) 1894 } 1895 } 1896 1897 func (fake *FakeRepository) SetAsyncTimeoutCallCount() int { 1898 fake.setAsyncTimeoutMutex.RLock() 1899 defer fake.setAsyncTimeoutMutex.RUnlock() 1900 return len(fake.setAsyncTimeoutArgsForCall) 1901 } 1902 1903 func (fake *FakeRepository) SetAsyncTimeoutCalls(stub func(uint)) { 1904 fake.setAsyncTimeoutMutex.Lock() 1905 defer fake.setAsyncTimeoutMutex.Unlock() 1906 fake.SetAsyncTimeoutStub = stub 1907 } 1908 1909 func (fake *FakeRepository) SetAsyncTimeoutArgsForCall(i int) uint { 1910 fake.setAsyncTimeoutMutex.RLock() 1911 defer fake.setAsyncTimeoutMutex.RUnlock() 1912 argsForCall := fake.setAsyncTimeoutArgsForCall[i] 1913 return argsForCall.arg1 1914 } 1915 1916 func (fake *FakeRepository) SetAuthenticationEndpoint(arg1 string) { 1917 fake.setAuthenticationEndpointMutex.Lock() 1918 fake.setAuthenticationEndpointArgsForCall = append(fake.setAuthenticationEndpointArgsForCall, struct { 1919 arg1 string 1920 }{arg1}) 1921 fake.recordInvocation("SetAuthenticationEndpoint", []interface{}{arg1}) 1922 fake.setAuthenticationEndpointMutex.Unlock() 1923 if fake.SetAuthenticationEndpointStub != nil { 1924 fake.SetAuthenticationEndpointStub(arg1) 1925 } 1926 } 1927 1928 func (fake *FakeRepository) SetAuthenticationEndpointCallCount() int { 1929 fake.setAuthenticationEndpointMutex.RLock() 1930 defer fake.setAuthenticationEndpointMutex.RUnlock() 1931 return len(fake.setAuthenticationEndpointArgsForCall) 1932 } 1933 1934 func (fake *FakeRepository) SetAuthenticationEndpointCalls(stub func(string)) { 1935 fake.setAuthenticationEndpointMutex.Lock() 1936 defer fake.setAuthenticationEndpointMutex.Unlock() 1937 fake.SetAuthenticationEndpointStub = stub 1938 } 1939 1940 func (fake *FakeRepository) SetAuthenticationEndpointArgsForCall(i int) string { 1941 fake.setAuthenticationEndpointMutex.RLock() 1942 defer fake.setAuthenticationEndpointMutex.RUnlock() 1943 argsForCall := fake.setAuthenticationEndpointArgsForCall[i] 1944 return argsForCall.arg1 1945 } 1946 1947 func (fake *FakeRepository) SetCLIVersion(arg1 string) { 1948 fake.setCLIVersionMutex.Lock() 1949 fake.setCLIVersionArgsForCall = append(fake.setCLIVersionArgsForCall, struct { 1950 arg1 string 1951 }{arg1}) 1952 fake.recordInvocation("SetCLIVersion", []interface{}{arg1}) 1953 fake.setCLIVersionMutex.Unlock() 1954 if fake.SetCLIVersionStub != nil { 1955 fake.SetCLIVersionStub(arg1) 1956 } 1957 } 1958 1959 func (fake *FakeRepository) SetCLIVersionCallCount() int { 1960 fake.setCLIVersionMutex.RLock() 1961 defer fake.setCLIVersionMutex.RUnlock() 1962 return len(fake.setCLIVersionArgsForCall) 1963 } 1964 1965 func (fake *FakeRepository) SetCLIVersionCalls(stub func(string)) { 1966 fake.setCLIVersionMutex.Lock() 1967 defer fake.setCLIVersionMutex.Unlock() 1968 fake.SetCLIVersionStub = stub 1969 } 1970 1971 func (fake *FakeRepository) SetCLIVersionArgsForCall(i int) string { 1972 fake.setCLIVersionMutex.RLock() 1973 defer fake.setCLIVersionMutex.RUnlock() 1974 argsForCall := fake.setCLIVersionArgsForCall[i] 1975 return argsForCall.arg1 1976 } 1977 1978 func (fake *FakeRepository) SetColorEnabled(arg1 string) { 1979 fake.setColorEnabledMutex.Lock() 1980 fake.setColorEnabledArgsForCall = append(fake.setColorEnabledArgsForCall, struct { 1981 arg1 string 1982 }{arg1}) 1983 fake.recordInvocation("SetColorEnabled", []interface{}{arg1}) 1984 fake.setColorEnabledMutex.Unlock() 1985 if fake.SetColorEnabledStub != nil { 1986 fake.SetColorEnabledStub(arg1) 1987 } 1988 } 1989 1990 func (fake *FakeRepository) SetColorEnabledCallCount() int { 1991 fake.setColorEnabledMutex.RLock() 1992 defer fake.setColorEnabledMutex.RUnlock() 1993 return len(fake.setColorEnabledArgsForCall) 1994 } 1995 1996 func (fake *FakeRepository) SetColorEnabledCalls(stub func(string)) { 1997 fake.setColorEnabledMutex.Lock() 1998 defer fake.setColorEnabledMutex.Unlock() 1999 fake.SetColorEnabledStub = stub 2000 } 2001 2002 func (fake *FakeRepository) SetColorEnabledArgsForCall(i int) string { 2003 fake.setColorEnabledMutex.RLock() 2004 defer fake.setColorEnabledMutex.RUnlock() 2005 argsForCall := fake.setColorEnabledArgsForCall[i] 2006 return argsForCall.arg1 2007 } 2008 2009 func (fake *FakeRepository) SetDopplerEndpoint(arg1 string) { 2010 fake.setDopplerEndpointMutex.Lock() 2011 fake.setDopplerEndpointArgsForCall = append(fake.setDopplerEndpointArgsForCall, struct { 2012 arg1 string 2013 }{arg1}) 2014 fake.recordInvocation("SetDopplerEndpoint", []interface{}{arg1}) 2015 fake.setDopplerEndpointMutex.Unlock() 2016 if fake.SetDopplerEndpointStub != nil { 2017 fake.SetDopplerEndpointStub(arg1) 2018 } 2019 } 2020 2021 func (fake *FakeRepository) SetDopplerEndpointCallCount() int { 2022 fake.setDopplerEndpointMutex.RLock() 2023 defer fake.setDopplerEndpointMutex.RUnlock() 2024 return len(fake.setDopplerEndpointArgsForCall) 2025 } 2026 2027 func (fake *FakeRepository) SetDopplerEndpointCalls(stub func(string)) { 2028 fake.setDopplerEndpointMutex.Lock() 2029 defer fake.setDopplerEndpointMutex.Unlock() 2030 fake.SetDopplerEndpointStub = stub 2031 } 2032 2033 func (fake *FakeRepository) SetDopplerEndpointArgsForCall(i int) string { 2034 fake.setDopplerEndpointMutex.RLock() 2035 defer fake.setDopplerEndpointMutex.RUnlock() 2036 argsForCall := fake.setDopplerEndpointArgsForCall[i] 2037 return argsForCall.arg1 2038 } 2039 2040 func (fake *FakeRepository) SetLocale(arg1 string) { 2041 fake.setLocaleMutex.Lock() 2042 fake.setLocaleArgsForCall = append(fake.setLocaleArgsForCall, struct { 2043 arg1 string 2044 }{arg1}) 2045 fake.recordInvocation("SetLocale", []interface{}{arg1}) 2046 fake.setLocaleMutex.Unlock() 2047 if fake.SetLocaleStub != nil { 2048 fake.SetLocaleStub(arg1) 2049 } 2050 } 2051 2052 func (fake *FakeRepository) SetLocaleCallCount() int { 2053 fake.setLocaleMutex.RLock() 2054 defer fake.setLocaleMutex.RUnlock() 2055 return len(fake.setLocaleArgsForCall) 2056 } 2057 2058 func (fake *FakeRepository) SetLocaleCalls(stub func(string)) { 2059 fake.setLocaleMutex.Lock() 2060 defer fake.setLocaleMutex.Unlock() 2061 fake.SetLocaleStub = stub 2062 } 2063 2064 func (fake *FakeRepository) SetLocaleArgsForCall(i int) string { 2065 fake.setLocaleMutex.RLock() 2066 defer fake.setLocaleMutex.RUnlock() 2067 argsForCall := fake.setLocaleArgsForCall[i] 2068 return argsForCall.arg1 2069 } 2070 2071 func (fake *FakeRepository) SetLogCacheEndpoint(arg1 string) { 2072 fake.setLogCacheEndpointMutex.Lock() 2073 fake.setLogCacheEndpointArgsForCall = append(fake.setLogCacheEndpointArgsForCall, struct { 2074 arg1 string 2075 }{arg1}) 2076 fake.recordInvocation("SetLogCacheEndpoint", []interface{}{arg1}) 2077 fake.setLogCacheEndpointMutex.Unlock() 2078 if fake.SetLogCacheEndpointStub != nil { 2079 fake.SetLogCacheEndpointStub(arg1) 2080 } 2081 } 2082 2083 func (fake *FakeRepository) SetLogCacheEndpointCallCount() int { 2084 fake.setLogCacheEndpointMutex.RLock() 2085 defer fake.setLogCacheEndpointMutex.RUnlock() 2086 return len(fake.setLogCacheEndpointArgsForCall) 2087 } 2088 2089 func (fake *FakeRepository) SetLogCacheEndpointCalls(stub func(string)) { 2090 fake.setLogCacheEndpointMutex.Lock() 2091 defer fake.setLogCacheEndpointMutex.Unlock() 2092 fake.SetLogCacheEndpointStub = stub 2093 } 2094 2095 func (fake *FakeRepository) SetLogCacheEndpointArgsForCall(i int) string { 2096 fake.setLogCacheEndpointMutex.RLock() 2097 defer fake.setLogCacheEndpointMutex.RUnlock() 2098 argsForCall := fake.setLogCacheEndpointArgsForCall[i] 2099 return argsForCall.arg1 2100 } 2101 2102 func (fake *FakeRepository) SetMinCLIVersion(arg1 string) { 2103 fake.setMinCLIVersionMutex.Lock() 2104 fake.setMinCLIVersionArgsForCall = append(fake.setMinCLIVersionArgsForCall, struct { 2105 arg1 string 2106 }{arg1}) 2107 fake.recordInvocation("SetMinCLIVersion", []interface{}{arg1}) 2108 fake.setMinCLIVersionMutex.Unlock() 2109 if fake.SetMinCLIVersionStub != nil { 2110 fake.SetMinCLIVersionStub(arg1) 2111 } 2112 } 2113 2114 func (fake *FakeRepository) SetMinCLIVersionCallCount() int { 2115 fake.setMinCLIVersionMutex.RLock() 2116 defer fake.setMinCLIVersionMutex.RUnlock() 2117 return len(fake.setMinCLIVersionArgsForCall) 2118 } 2119 2120 func (fake *FakeRepository) SetMinCLIVersionCalls(stub func(string)) { 2121 fake.setMinCLIVersionMutex.Lock() 2122 defer fake.setMinCLIVersionMutex.Unlock() 2123 fake.SetMinCLIVersionStub = stub 2124 } 2125 2126 func (fake *FakeRepository) SetMinCLIVersionArgsForCall(i int) string { 2127 fake.setMinCLIVersionMutex.RLock() 2128 defer fake.setMinCLIVersionMutex.RUnlock() 2129 argsForCall := fake.setMinCLIVersionArgsForCall[i] 2130 return argsForCall.arg1 2131 } 2132 2133 func (fake *FakeRepository) SetMinRecommendedCLIVersion(arg1 string) { 2134 fake.setMinRecommendedCLIVersionMutex.Lock() 2135 fake.setMinRecommendedCLIVersionArgsForCall = append(fake.setMinRecommendedCLIVersionArgsForCall, struct { 2136 arg1 string 2137 }{arg1}) 2138 fake.recordInvocation("SetMinRecommendedCLIVersion", []interface{}{arg1}) 2139 fake.setMinRecommendedCLIVersionMutex.Unlock() 2140 if fake.SetMinRecommendedCLIVersionStub != nil { 2141 fake.SetMinRecommendedCLIVersionStub(arg1) 2142 } 2143 } 2144 2145 func (fake *FakeRepository) SetMinRecommendedCLIVersionCallCount() int { 2146 fake.setMinRecommendedCLIVersionMutex.RLock() 2147 defer fake.setMinRecommendedCLIVersionMutex.RUnlock() 2148 return len(fake.setMinRecommendedCLIVersionArgsForCall) 2149 } 2150 2151 func (fake *FakeRepository) SetMinRecommendedCLIVersionCalls(stub func(string)) { 2152 fake.setMinRecommendedCLIVersionMutex.Lock() 2153 defer fake.setMinRecommendedCLIVersionMutex.Unlock() 2154 fake.SetMinRecommendedCLIVersionStub = stub 2155 } 2156 2157 func (fake *FakeRepository) SetMinRecommendedCLIVersionArgsForCall(i int) string { 2158 fake.setMinRecommendedCLIVersionMutex.RLock() 2159 defer fake.setMinRecommendedCLIVersionMutex.RUnlock() 2160 argsForCall := fake.setMinRecommendedCLIVersionArgsForCall[i] 2161 return argsForCall.arg1 2162 } 2163 2164 func (fake *FakeRepository) SetOrganizationFields(arg1 models.OrganizationFields) { 2165 fake.setOrganizationFieldsMutex.Lock() 2166 fake.setOrganizationFieldsArgsForCall = append(fake.setOrganizationFieldsArgsForCall, struct { 2167 arg1 models.OrganizationFields 2168 }{arg1}) 2169 fake.recordInvocation("SetOrganizationFields", []interface{}{arg1}) 2170 fake.setOrganizationFieldsMutex.Unlock() 2171 if fake.SetOrganizationFieldsStub != nil { 2172 fake.SetOrganizationFieldsStub(arg1) 2173 } 2174 } 2175 2176 func (fake *FakeRepository) SetOrganizationFieldsCallCount() int { 2177 fake.setOrganizationFieldsMutex.RLock() 2178 defer fake.setOrganizationFieldsMutex.RUnlock() 2179 return len(fake.setOrganizationFieldsArgsForCall) 2180 } 2181 2182 func (fake *FakeRepository) SetOrganizationFieldsCalls(stub func(models.OrganizationFields)) { 2183 fake.setOrganizationFieldsMutex.Lock() 2184 defer fake.setOrganizationFieldsMutex.Unlock() 2185 fake.SetOrganizationFieldsStub = stub 2186 } 2187 2188 func (fake *FakeRepository) SetOrganizationFieldsArgsForCall(i int) models.OrganizationFields { 2189 fake.setOrganizationFieldsMutex.RLock() 2190 defer fake.setOrganizationFieldsMutex.RUnlock() 2191 argsForCall := fake.setOrganizationFieldsArgsForCall[i] 2192 return argsForCall.arg1 2193 } 2194 2195 func (fake *FakeRepository) SetPluginRepo(arg1 models.PluginRepo) { 2196 fake.setPluginRepoMutex.Lock() 2197 fake.setPluginRepoArgsForCall = append(fake.setPluginRepoArgsForCall, struct { 2198 arg1 models.PluginRepo 2199 }{arg1}) 2200 fake.recordInvocation("SetPluginRepo", []interface{}{arg1}) 2201 fake.setPluginRepoMutex.Unlock() 2202 if fake.SetPluginRepoStub != nil { 2203 fake.SetPluginRepoStub(arg1) 2204 } 2205 } 2206 2207 func (fake *FakeRepository) SetPluginRepoCallCount() int { 2208 fake.setPluginRepoMutex.RLock() 2209 defer fake.setPluginRepoMutex.RUnlock() 2210 return len(fake.setPluginRepoArgsForCall) 2211 } 2212 2213 func (fake *FakeRepository) SetPluginRepoCalls(stub func(models.PluginRepo)) { 2214 fake.setPluginRepoMutex.Lock() 2215 defer fake.setPluginRepoMutex.Unlock() 2216 fake.SetPluginRepoStub = stub 2217 } 2218 2219 func (fake *FakeRepository) SetPluginRepoArgsForCall(i int) models.PluginRepo { 2220 fake.setPluginRepoMutex.RLock() 2221 defer fake.setPluginRepoMutex.RUnlock() 2222 argsForCall := fake.setPluginRepoArgsForCall[i] 2223 return argsForCall.arg1 2224 } 2225 2226 func (fake *FakeRepository) SetRefreshToken(arg1 string) { 2227 fake.setRefreshTokenMutex.Lock() 2228 fake.setRefreshTokenArgsForCall = append(fake.setRefreshTokenArgsForCall, struct { 2229 arg1 string 2230 }{arg1}) 2231 fake.recordInvocation("SetRefreshToken", []interface{}{arg1}) 2232 fake.setRefreshTokenMutex.Unlock() 2233 if fake.SetRefreshTokenStub != nil { 2234 fake.SetRefreshTokenStub(arg1) 2235 } 2236 } 2237 2238 func (fake *FakeRepository) SetRefreshTokenCallCount() int { 2239 fake.setRefreshTokenMutex.RLock() 2240 defer fake.setRefreshTokenMutex.RUnlock() 2241 return len(fake.setRefreshTokenArgsForCall) 2242 } 2243 2244 func (fake *FakeRepository) SetRefreshTokenCalls(stub func(string)) { 2245 fake.setRefreshTokenMutex.Lock() 2246 defer fake.setRefreshTokenMutex.Unlock() 2247 fake.SetRefreshTokenStub = stub 2248 } 2249 2250 func (fake *FakeRepository) SetRefreshTokenArgsForCall(i int) string { 2251 fake.setRefreshTokenMutex.RLock() 2252 defer fake.setRefreshTokenMutex.RUnlock() 2253 argsForCall := fake.setRefreshTokenArgsForCall[i] 2254 return argsForCall.arg1 2255 } 2256 2257 func (fake *FakeRepository) SetRoutingAPIEndpoint(arg1 string) { 2258 fake.setRoutingAPIEndpointMutex.Lock() 2259 fake.setRoutingAPIEndpointArgsForCall = append(fake.setRoutingAPIEndpointArgsForCall, struct { 2260 arg1 string 2261 }{arg1}) 2262 fake.recordInvocation("SetRoutingAPIEndpoint", []interface{}{arg1}) 2263 fake.setRoutingAPIEndpointMutex.Unlock() 2264 if fake.SetRoutingAPIEndpointStub != nil { 2265 fake.SetRoutingAPIEndpointStub(arg1) 2266 } 2267 } 2268 2269 func (fake *FakeRepository) SetRoutingAPIEndpointCallCount() int { 2270 fake.setRoutingAPIEndpointMutex.RLock() 2271 defer fake.setRoutingAPIEndpointMutex.RUnlock() 2272 return len(fake.setRoutingAPIEndpointArgsForCall) 2273 } 2274 2275 func (fake *FakeRepository) SetRoutingAPIEndpointCalls(stub func(string)) { 2276 fake.setRoutingAPIEndpointMutex.Lock() 2277 defer fake.setRoutingAPIEndpointMutex.Unlock() 2278 fake.SetRoutingAPIEndpointStub = stub 2279 } 2280 2281 func (fake *FakeRepository) SetRoutingAPIEndpointArgsForCall(i int) string { 2282 fake.setRoutingAPIEndpointMutex.RLock() 2283 defer fake.setRoutingAPIEndpointMutex.RUnlock() 2284 argsForCall := fake.setRoutingAPIEndpointArgsForCall[i] 2285 return argsForCall.arg1 2286 } 2287 2288 func (fake *FakeRepository) SetSSHOAuthClient(arg1 string) { 2289 fake.setSSHOAuthClientMutex.Lock() 2290 fake.setSSHOAuthClientArgsForCall = append(fake.setSSHOAuthClientArgsForCall, struct { 2291 arg1 string 2292 }{arg1}) 2293 fake.recordInvocation("SetSSHOAuthClient", []interface{}{arg1}) 2294 fake.setSSHOAuthClientMutex.Unlock() 2295 if fake.SetSSHOAuthClientStub != nil { 2296 fake.SetSSHOAuthClientStub(arg1) 2297 } 2298 } 2299 2300 func (fake *FakeRepository) SetSSHOAuthClientCallCount() int { 2301 fake.setSSHOAuthClientMutex.RLock() 2302 defer fake.setSSHOAuthClientMutex.RUnlock() 2303 return len(fake.setSSHOAuthClientArgsForCall) 2304 } 2305 2306 func (fake *FakeRepository) SetSSHOAuthClientCalls(stub func(string)) { 2307 fake.setSSHOAuthClientMutex.Lock() 2308 defer fake.setSSHOAuthClientMutex.Unlock() 2309 fake.SetSSHOAuthClientStub = stub 2310 } 2311 2312 func (fake *FakeRepository) SetSSHOAuthClientArgsForCall(i int) string { 2313 fake.setSSHOAuthClientMutex.RLock() 2314 defer fake.setSSHOAuthClientMutex.RUnlock() 2315 argsForCall := fake.setSSHOAuthClientArgsForCall[i] 2316 return argsForCall.arg1 2317 } 2318 2319 func (fake *FakeRepository) SetSSLDisabled(arg1 bool) { 2320 fake.setSSLDisabledMutex.Lock() 2321 fake.setSSLDisabledArgsForCall = append(fake.setSSLDisabledArgsForCall, struct { 2322 arg1 bool 2323 }{arg1}) 2324 fake.recordInvocation("SetSSLDisabled", []interface{}{arg1}) 2325 fake.setSSLDisabledMutex.Unlock() 2326 if fake.SetSSLDisabledStub != nil { 2327 fake.SetSSLDisabledStub(arg1) 2328 } 2329 } 2330 2331 func (fake *FakeRepository) SetSSLDisabledCallCount() int { 2332 fake.setSSLDisabledMutex.RLock() 2333 defer fake.setSSLDisabledMutex.RUnlock() 2334 return len(fake.setSSLDisabledArgsForCall) 2335 } 2336 2337 func (fake *FakeRepository) SetSSLDisabledCalls(stub func(bool)) { 2338 fake.setSSLDisabledMutex.Lock() 2339 defer fake.setSSLDisabledMutex.Unlock() 2340 fake.SetSSLDisabledStub = stub 2341 } 2342 2343 func (fake *FakeRepository) SetSSLDisabledArgsForCall(i int) bool { 2344 fake.setSSLDisabledMutex.RLock() 2345 defer fake.setSSLDisabledMutex.RUnlock() 2346 argsForCall := fake.setSSLDisabledArgsForCall[i] 2347 return argsForCall.arg1 2348 } 2349 2350 func (fake *FakeRepository) SetSpaceFields(arg1 models.SpaceFields) { 2351 fake.setSpaceFieldsMutex.Lock() 2352 fake.setSpaceFieldsArgsForCall = append(fake.setSpaceFieldsArgsForCall, struct { 2353 arg1 models.SpaceFields 2354 }{arg1}) 2355 fake.recordInvocation("SetSpaceFields", []interface{}{arg1}) 2356 fake.setSpaceFieldsMutex.Unlock() 2357 if fake.SetSpaceFieldsStub != nil { 2358 fake.SetSpaceFieldsStub(arg1) 2359 } 2360 } 2361 2362 func (fake *FakeRepository) SetSpaceFieldsCallCount() int { 2363 fake.setSpaceFieldsMutex.RLock() 2364 defer fake.setSpaceFieldsMutex.RUnlock() 2365 return len(fake.setSpaceFieldsArgsForCall) 2366 } 2367 2368 func (fake *FakeRepository) SetSpaceFieldsCalls(stub func(models.SpaceFields)) { 2369 fake.setSpaceFieldsMutex.Lock() 2370 defer fake.setSpaceFieldsMutex.Unlock() 2371 fake.SetSpaceFieldsStub = stub 2372 } 2373 2374 func (fake *FakeRepository) SetSpaceFieldsArgsForCall(i int) models.SpaceFields { 2375 fake.setSpaceFieldsMutex.RLock() 2376 defer fake.setSpaceFieldsMutex.RUnlock() 2377 argsForCall := fake.setSpaceFieldsArgsForCall[i] 2378 return argsForCall.arg1 2379 } 2380 2381 func (fake *FakeRepository) SetTrace(arg1 string) { 2382 fake.setTraceMutex.Lock() 2383 fake.setTraceArgsForCall = append(fake.setTraceArgsForCall, struct { 2384 arg1 string 2385 }{arg1}) 2386 fake.recordInvocation("SetTrace", []interface{}{arg1}) 2387 fake.setTraceMutex.Unlock() 2388 if fake.SetTraceStub != nil { 2389 fake.SetTraceStub(arg1) 2390 } 2391 } 2392 2393 func (fake *FakeRepository) SetTraceCallCount() int { 2394 fake.setTraceMutex.RLock() 2395 defer fake.setTraceMutex.RUnlock() 2396 return len(fake.setTraceArgsForCall) 2397 } 2398 2399 func (fake *FakeRepository) SetTraceCalls(stub func(string)) { 2400 fake.setTraceMutex.Lock() 2401 defer fake.setTraceMutex.Unlock() 2402 fake.SetTraceStub = stub 2403 } 2404 2405 func (fake *FakeRepository) SetTraceArgsForCall(i int) string { 2406 fake.setTraceMutex.RLock() 2407 defer fake.setTraceMutex.RUnlock() 2408 argsForCall := fake.setTraceArgsForCall[i] 2409 return argsForCall.arg1 2410 } 2411 2412 func (fake *FakeRepository) SetUAAGrantType(arg1 string) { 2413 fake.setUAAGrantTypeMutex.Lock() 2414 fake.setUAAGrantTypeArgsForCall = append(fake.setUAAGrantTypeArgsForCall, struct { 2415 arg1 string 2416 }{arg1}) 2417 fake.recordInvocation("SetUAAGrantType", []interface{}{arg1}) 2418 fake.setUAAGrantTypeMutex.Unlock() 2419 if fake.SetUAAGrantTypeStub != nil { 2420 fake.SetUAAGrantTypeStub(arg1) 2421 } 2422 } 2423 2424 func (fake *FakeRepository) SetUAAGrantTypeCallCount() int { 2425 fake.setUAAGrantTypeMutex.RLock() 2426 defer fake.setUAAGrantTypeMutex.RUnlock() 2427 return len(fake.setUAAGrantTypeArgsForCall) 2428 } 2429 2430 func (fake *FakeRepository) SetUAAGrantTypeCalls(stub func(string)) { 2431 fake.setUAAGrantTypeMutex.Lock() 2432 defer fake.setUAAGrantTypeMutex.Unlock() 2433 fake.SetUAAGrantTypeStub = stub 2434 } 2435 2436 func (fake *FakeRepository) SetUAAGrantTypeArgsForCall(i int) string { 2437 fake.setUAAGrantTypeMutex.RLock() 2438 defer fake.setUAAGrantTypeMutex.RUnlock() 2439 argsForCall := fake.setUAAGrantTypeArgsForCall[i] 2440 return argsForCall.arg1 2441 } 2442 2443 func (fake *FakeRepository) SetUAAOAuthClient(arg1 string) { 2444 fake.setUAAOAuthClientMutex.Lock() 2445 fake.setUAAOAuthClientArgsForCall = append(fake.setUAAOAuthClientArgsForCall, struct { 2446 arg1 string 2447 }{arg1}) 2448 fake.recordInvocation("SetUAAOAuthClient", []interface{}{arg1}) 2449 fake.setUAAOAuthClientMutex.Unlock() 2450 if fake.SetUAAOAuthClientStub != nil { 2451 fake.SetUAAOAuthClientStub(arg1) 2452 } 2453 } 2454 2455 func (fake *FakeRepository) SetUAAOAuthClientCallCount() int { 2456 fake.setUAAOAuthClientMutex.RLock() 2457 defer fake.setUAAOAuthClientMutex.RUnlock() 2458 return len(fake.setUAAOAuthClientArgsForCall) 2459 } 2460 2461 func (fake *FakeRepository) SetUAAOAuthClientCalls(stub func(string)) { 2462 fake.setUAAOAuthClientMutex.Lock() 2463 defer fake.setUAAOAuthClientMutex.Unlock() 2464 fake.SetUAAOAuthClientStub = stub 2465 } 2466 2467 func (fake *FakeRepository) SetUAAOAuthClientArgsForCall(i int) string { 2468 fake.setUAAOAuthClientMutex.RLock() 2469 defer fake.setUAAOAuthClientMutex.RUnlock() 2470 argsForCall := fake.setUAAOAuthClientArgsForCall[i] 2471 return argsForCall.arg1 2472 } 2473 2474 func (fake *FakeRepository) SetUAAOAuthClientSecret(arg1 string) { 2475 fake.setUAAOAuthClientSecretMutex.Lock() 2476 fake.setUAAOAuthClientSecretArgsForCall = append(fake.setUAAOAuthClientSecretArgsForCall, struct { 2477 arg1 string 2478 }{arg1}) 2479 fake.recordInvocation("SetUAAOAuthClientSecret", []interface{}{arg1}) 2480 fake.setUAAOAuthClientSecretMutex.Unlock() 2481 if fake.SetUAAOAuthClientSecretStub != nil { 2482 fake.SetUAAOAuthClientSecretStub(arg1) 2483 } 2484 } 2485 2486 func (fake *FakeRepository) SetUAAOAuthClientSecretCallCount() int { 2487 fake.setUAAOAuthClientSecretMutex.RLock() 2488 defer fake.setUAAOAuthClientSecretMutex.RUnlock() 2489 return len(fake.setUAAOAuthClientSecretArgsForCall) 2490 } 2491 2492 func (fake *FakeRepository) SetUAAOAuthClientSecretCalls(stub func(string)) { 2493 fake.setUAAOAuthClientSecretMutex.Lock() 2494 defer fake.setUAAOAuthClientSecretMutex.Unlock() 2495 fake.SetUAAOAuthClientSecretStub = stub 2496 } 2497 2498 func (fake *FakeRepository) SetUAAOAuthClientSecretArgsForCall(i int) string { 2499 fake.setUAAOAuthClientSecretMutex.RLock() 2500 defer fake.setUAAOAuthClientSecretMutex.RUnlock() 2501 argsForCall := fake.setUAAOAuthClientSecretArgsForCall[i] 2502 return argsForCall.arg1 2503 } 2504 2505 func (fake *FakeRepository) SetUaaEndpoint(arg1 string) { 2506 fake.setUaaEndpointMutex.Lock() 2507 fake.setUaaEndpointArgsForCall = append(fake.setUaaEndpointArgsForCall, struct { 2508 arg1 string 2509 }{arg1}) 2510 fake.recordInvocation("SetUaaEndpoint", []interface{}{arg1}) 2511 fake.setUaaEndpointMutex.Unlock() 2512 if fake.SetUaaEndpointStub != nil { 2513 fake.SetUaaEndpointStub(arg1) 2514 } 2515 } 2516 2517 func (fake *FakeRepository) SetUaaEndpointCallCount() int { 2518 fake.setUaaEndpointMutex.RLock() 2519 defer fake.setUaaEndpointMutex.RUnlock() 2520 return len(fake.setUaaEndpointArgsForCall) 2521 } 2522 2523 func (fake *FakeRepository) SetUaaEndpointCalls(stub func(string)) { 2524 fake.setUaaEndpointMutex.Lock() 2525 defer fake.setUaaEndpointMutex.Unlock() 2526 fake.SetUaaEndpointStub = stub 2527 } 2528 2529 func (fake *FakeRepository) SetUaaEndpointArgsForCall(i int) string { 2530 fake.setUaaEndpointMutex.RLock() 2531 defer fake.setUaaEndpointMutex.RUnlock() 2532 argsForCall := fake.setUaaEndpointArgsForCall[i] 2533 return argsForCall.arg1 2534 } 2535 2536 func (fake *FakeRepository) SpaceFields() models.SpaceFields { 2537 fake.spaceFieldsMutex.Lock() 2538 ret, specificReturn := fake.spaceFieldsReturnsOnCall[len(fake.spaceFieldsArgsForCall)] 2539 fake.spaceFieldsArgsForCall = append(fake.spaceFieldsArgsForCall, struct { 2540 }{}) 2541 fake.recordInvocation("SpaceFields", []interface{}{}) 2542 fake.spaceFieldsMutex.Unlock() 2543 if fake.SpaceFieldsStub != nil { 2544 return fake.SpaceFieldsStub() 2545 } 2546 if specificReturn { 2547 return ret.result1 2548 } 2549 fakeReturns := fake.spaceFieldsReturns 2550 return fakeReturns.result1 2551 } 2552 2553 func (fake *FakeRepository) SpaceFieldsCallCount() int { 2554 fake.spaceFieldsMutex.RLock() 2555 defer fake.spaceFieldsMutex.RUnlock() 2556 return len(fake.spaceFieldsArgsForCall) 2557 } 2558 2559 func (fake *FakeRepository) SpaceFieldsCalls(stub func() models.SpaceFields) { 2560 fake.spaceFieldsMutex.Lock() 2561 defer fake.spaceFieldsMutex.Unlock() 2562 fake.SpaceFieldsStub = stub 2563 } 2564 2565 func (fake *FakeRepository) SpaceFieldsReturns(result1 models.SpaceFields) { 2566 fake.spaceFieldsMutex.Lock() 2567 defer fake.spaceFieldsMutex.Unlock() 2568 fake.SpaceFieldsStub = nil 2569 fake.spaceFieldsReturns = struct { 2570 result1 models.SpaceFields 2571 }{result1} 2572 } 2573 2574 func (fake *FakeRepository) SpaceFieldsReturnsOnCall(i int, result1 models.SpaceFields) { 2575 fake.spaceFieldsMutex.Lock() 2576 defer fake.spaceFieldsMutex.Unlock() 2577 fake.SpaceFieldsStub = nil 2578 if fake.spaceFieldsReturnsOnCall == nil { 2579 fake.spaceFieldsReturnsOnCall = make(map[int]struct { 2580 result1 models.SpaceFields 2581 }) 2582 } 2583 fake.spaceFieldsReturnsOnCall[i] = struct { 2584 result1 models.SpaceFields 2585 }{result1} 2586 } 2587 2588 func (fake *FakeRepository) Trace() string { 2589 fake.traceMutex.Lock() 2590 ret, specificReturn := fake.traceReturnsOnCall[len(fake.traceArgsForCall)] 2591 fake.traceArgsForCall = append(fake.traceArgsForCall, struct { 2592 }{}) 2593 fake.recordInvocation("Trace", []interface{}{}) 2594 fake.traceMutex.Unlock() 2595 if fake.TraceStub != nil { 2596 return fake.TraceStub() 2597 } 2598 if specificReturn { 2599 return ret.result1 2600 } 2601 fakeReturns := fake.traceReturns 2602 return fakeReturns.result1 2603 } 2604 2605 func (fake *FakeRepository) TraceCallCount() int { 2606 fake.traceMutex.RLock() 2607 defer fake.traceMutex.RUnlock() 2608 return len(fake.traceArgsForCall) 2609 } 2610 2611 func (fake *FakeRepository) TraceCalls(stub func() string) { 2612 fake.traceMutex.Lock() 2613 defer fake.traceMutex.Unlock() 2614 fake.TraceStub = stub 2615 } 2616 2617 func (fake *FakeRepository) TraceReturns(result1 string) { 2618 fake.traceMutex.Lock() 2619 defer fake.traceMutex.Unlock() 2620 fake.TraceStub = nil 2621 fake.traceReturns = struct { 2622 result1 string 2623 }{result1} 2624 } 2625 2626 func (fake *FakeRepository) TraceReturnsOnCall(i int, result1 string) { 2627 fake.traceMutex.Lock() 2628 defer fake.traceMutex.Unlock() 2629 fake.TraceStub = nil 2630 if fake.traceReturnsOnCall == nil { 2631 fake.traceReturnsOnCall = make(map[int]struct { 2632 result1 string 2633 }) 2634 } 2635 fake.traceReturnsOnCall[i] = struct { 2636 result1 string 2637 }{result1} 2638 } 2639 2640 func (fake *FakeRepository) UAAGrantType() string { 2641 fake.uAAGrantTypeMutex.Lock() 2642 ret, specificReturn := fake.uAAGrantTypeReturnsOnCall[len(fake.uAAGrantTypeArgsForCall)] 2643 fake.uAAGrantTypeArgsForCall = append(fake.uAAGrantTypeArgsForCall, struct { 2644 }{}) 2645 fake.recordInvocation("UAAGrantType", []interface{}{}) 2646 fake.uAAGrantTypeMutex.Unlock() 2647 if fake.UAAGrantTypeStub != nil { 2648 return fake.UAAGrantTypeStub() 2649 } 2650 if specificReturn { 2651 return ret.result1 2652 } 2653 fakeReturns := fake.uAAGrantTypeReturns 2654 return fakeReturns.result1 2655 } 2656 2657 func (fake *FakeRepository) UAAGrantTypeCallCount() int { 2658 fake.uAAGrantTypeMutex.RLock() 2659 defer fake.uAAGrantTypeMutex.RUnlock() 2660 return len(fake.uAAGrantTypeArgsForCall) 2661 } 2662 2663 func (fake *FakeRepository) UAAGrantTypeCalls(stub func() string) { 2664 fake.uAAGrantTypeMutex.Lock() 2665 defer fake.uAAGrantTypeMutex.Unlock() 2666 fake.UAAGrantTypeStub = stub 2667 } 2668 2669 func (fake *FakeRepository) UAAGrantTypeReturns(result1 string) { 2670 fake.uAAGrantTypeMutex.Lock() 2671 defer fake.uAAGrantTypeMutex.Unlock() 2672 fake.UAAGrantTypeStub = nil 2673 fake.uAAGrantTypeReturns = struct { 2674 result1 string 2675 }{result1} 2676 } 2677 2678 func (fake *FakeRepository) UAAGrantTypeReturnsOnCall(i int, result1 string) { 2679 fake.uAAGrantTypeMutex.Lock() 2680 defer fake.uAAGrantTypeMutex.Unlock() 2681 fake.UAAGrantTypeStub = nil 2682 if fake.uAAGrantTypeReturnsOnCall == nil { 2683 fake.uAAGrantTypeReturnsOnCall = make(map[int]struct { 2684 result1 string 2685 }) 2686 } 2687 fake.uAAGrantTypeReturnsOnCall[i] = struct { 2688 result1 string 2689 }{result1} 2690 } 2691 2692 func (fake *FakeRepository) UAAOAuthClient() string { 2693 fake.uAAOAuthClientMutex.Lock() 2694 ret, specificReturn := fake.uAAOAuthClientReturnsOnCall[len(fake.uAAOAuthClientArgsForCall)] 2695 fake.uAAOAuthClientArgsForCall = append(fake.uAAOAuthClientArgsForCall, struct { 2696 }{}) 2697 fake.recordInvocation("UAAOAuthClient", []interface{}{}) 2698 fake.uAAOAuthClientMutex.Unlock() 2699 if fake.UAAOAuthClientStub != nil { 2700 return fake.UAAOAuthClientStub() 2701 } 2702 if specificReturn { 2703 return ret.result1 2704 } 2705 fakeReturns := fake.uAAOAuthClientReturns 2706 return fakeReturns.result1 2707 } 2708 2709 func (fake *FakeRepository) UAAOAuthClientCallCount() int { 2710 fake.uAAOAuthClientMutex.RLock() 2711 defer fake.uAAOAuthClientMutex.RUnlock() 2712 return len(fake.uAAOAuthClientArgsForCall) 2713 } 2714 2715 func (fake *FakeRepository) UAAOAuthClientCalls(stub func() string) { 2716 fake.uAAOAuthClientMutex.Lock() 2717 defer fake.uAAOAuthClientMutex.Unlock() 2718 fake.UAAOAuthClientStub = stub 2719 } 2720 2721 func (fake *FakeRepository) UAAOAuthClientReturns(result1 string) { 2722 fake.uAAOAuthClientMutex.Lock() 2723 defer fake.uAAOAuthClientMutex.Unlock() 2724 fake.UAAOAuthClientStub = nil 2725 fake.uAAOAuthClientReturns = struct { 2726 result1 string 2727 }{result1} 2728 } 2729 2730 func (fake *FakeRepository) UAAOAuthClientReturnsOnCall(i int, result1 string) { 2731 fake.uAAOAuthClientMutex.Lock() 2732 defer fake.uAAOAuthClientMutex.Unlock() 2733 fake.UAAOAuthClientStub = nil 2734 if fake.uAAOAuthClientReturnsOnCall == nil { 2735 fake.uAAOAuthClientReturnsOnCall = make(map[int]struct { 2736 result1 string 2737 }) 2738 } 2739 fake.uAAOAuthClientReturnsOnCall[i] = struct { 2740 result1 string 2741 }{result1} 2742 } 2743 2744 func (fake *FakeRepository) UAAOAuthClientSecret() string { 2745 fake.uAAOAuthClientSecretMutex.Lock() 2746 ret, specificReturn := fake.uAAOAuthClientSecretReturnsOnCall[len(fake.uAAOAuthClientSecretArgsForCall)] 2747 fake.uAAOAuthClientSecretArgsForCall = append(fake.uAAOAuthClientSecretArgsForCall, struct { 2748 }{}) 2749 fake.recordInvocation("UAAOAuthClientSecret", []interface{}{}) 2750 fake.uAAOAuthClientSecretMutex.Unlock() 2751 if fake.UAAOAuthClientSecretStub != nil { 2752 return fake.UAAOAuthClientSecretStub() 2753 } 2754 if specificReturn { 2755 return ret.result1 2756 } 2757 fakeReturns := fake.uAAOAuthClientSecretReturns 2758 return fakeReturns.result1 2759 } 2760 2761 func (fake *FakeRepository) UAAOAuthClientSecretCallCount() int { 2762 fake.uAAOAuthClientSecretMutex.RLock() 2763 defer fake.uAAOAuthClientSecretMutex.RUnlock() 2764 return len(fake.uAAOAuthClientSecretArgsForCall) 2765 } 2766 2767 func (fake *FakeRepository) UAAOAuthClientSecretCalls(stub func() string) { 2768 fake.uAAOAuthClientSecretMutex.Lock() 2769 defer fake.uAAOAuthClientSecretMutex.Unlock() 2770 fake.UAAOAuthClientSecretStub = stub 2771 } 2772 2773 func (fake *FakeRepository) UAAOAuthClientSecretReturns(result1 string) { 2774 fake.uAAOAuthClientSecretMutex.Lock() 2775 defer fake.uAAOAuthClientSecretMutex.Unlock() 2776 fake.UAAOAuthClientSecretStub = nil 2777 fake.uAAOAuthClientSecretReturns = struct { 2778 result1 string 2779 }{result1} 2780 } 2781 2782 func (fake *FakeRepository) UAAOAuthClientSecretReturnsOnCall(i int, result1 string) { 2783 fake.uAAOAuthClientSecretMutex.Lock() 2784 defer fake.uAAOAuthClientSecretMutex.Unlock() 2785 fake.UAAOAuthClientSecretStub = nil 2786 if fake.uAAOAuthClientSecretReturnsOnCall == nil { 2787 fake.uAAOAuthClientSecretReturnsOnCall = make(map[int]struct { 2788 result1 string 2789 }) 2790 } 2791 fake.uAAOAuthClientSecretReturnsOnCall[i] = struct { 2792 result1 string 2793 }{result1} 2794 } 2795 2796 func (fake *FakeRepository) UaaEndpoint() string { 2797 fake.uaaEndpointMutex.Lock() 2798 ret, specificReturn := fake.uaaEndpointReturnsOnCall[len(fake.uaaEndpointArgsForCall)] 2799 fake.uaaEndpointArgsForCall = append(fake.uaaEndpointArgsForCall, struct { 2800 }{}) 2801 fake.recordInvocation("UaaEndpoint", []interface{}{}) 2802 fake.uaaEndpointMutex.Unlock() 2803 if fake.UaaEndpointStub != nil { 2804 return fake.UaaEndpointStub() 2805 } 2806 if specificReturn { 2807 return ret.result1 2808 } 2809 fakeReturns := fake.uaaEndpointReturns 2810 return fakeReturns.result1 2811 } 2812 2813 func (fake *FakeRepository) UaaEndpointCallCount() int { 2814 fake.uaaEndpointMutex.RLock() 2815 defer fake.uaaEndpointMutex.RUnlock() 2816 return len(fake.uaaEndpointArgsForCall) 2817 } 2818 2819 func (fake *FakeRepository) UaaEndpointCalls(stub func() string) { 2820 fake.uaaEndpointMutex.Lock() 2821 defer fake.uaaEndpointMutex.Unlock() 2822 fake.UaaEndpointStub = stub 2823 } 2824 2825 func (fake *FakeRepository) UaaEndpointReturns(result1 string) { 2826 fake.uaaEndpointMutex.Lock() 2827 defer fake.uaaEndpointMutex.Unlock() 2828 fake.UaaEndpointStub = nil 2829 fake.uaaEndpointReturns = struct { 2830 result1 string 2831 }{result1} 2832 } 2833 2834 func (fake *FakeRepository) UaaEndpointReturnsOnCall(i int, result1 string) { 2835 fake.uaaEndpointMutex.Lock() 2836 defer fake.uaaEndpointMutex.Unlock() 2837 fake.UaaEndpointStub = nil 2838 if fake.uaaEndpointReturnsOnCall == nil { 2839 fake.uaaEndpointReturnsOnCall = make(map[int]struct { 2840 result1 string 2841 }) 2842 } 2843 fake.uaaEndpointReturnsOnCall[i] = struct { 2844 result1 string 2845 }{result1} 2846 } 2847 2848 func (fake *FakeRepository) UnSetPluginRepo(arg1 int) { 2849 fake.unSetPluginRepoMutex.Lock() 2850 fake.unSetPluginRepoArgsForCall = append(fake.unSetPluginRepoArgsForCall, struct { 2851 arg1 int 2852 }{arg1}) 2853 fake.recordInvocation("UnSetPluginRepo", []interface{}{arg1}) 2854 fake.unSetPluginRepoMutex.Unlock() 2855 if fake.UnSetPluginRepoStub != nil { 2856 fake.UnSetPluginRepoStub(arg1) 2857 } 2858 } 2859 2860 func (fake *FakeRepository) UnSetPluginRepoCallCount() int { 2861 fake.unSetPluginRepoMutex.RLock() 2862 defer fake.unSetPluginRepoMutex.RUnlock() 2863 return len(fake.unSetPluginRepoArgsForCall) 2864 } 2865 2866 func (fake *FakeRepository) UnSetPluginRepoCalls(stub func(int)) { 2867 fake.unSetPluginRepoMutex.Lock() 2868 defer fake.unSetPluginRepoMutex.Unlock() 2869 fake.UnSetPluginRepoStub = stub 2870 } 2871 2872 func (fake *FakeRepository) UnSetPluginRepoArgsForCall(i int) int { 2873 fake.unSetPluginRepoMutex.RLock() 2874 defer fake.unSetPluginRepoMutex.RUnlock() 2875 argsForCall := fake.unSetPluginRepoArgsForCall[i] 2876 return argsForCall.arg1 2877 } 2878 2879 func (fake *FakeRepository) UserEmail() string { 2880 fake.userEmailMutex.Lock() 2881 ret, specificReturn := fake.userEmailReturnsOnCall[len(fake.userEmailArgsForCall)] 2882 fake.userEmailArgsForCall = append(fake.userEmailArgsForCall, struct { 2883 }{}) 2884 fake.recordInvocation("UserEmail", []interface{}{}) 2885 fake.userEmailMutex.Unlock() 2886 if fake.UserEmailStub != nil { 2887 return fake.UserEmailStub() 2888 } 2889 if specificReturn { 2890 return ret.result1 2891 } 2892 fakeReturns := fake.userEmailReturns 2893 return fakeReturns.result1 2894 } 2895 2896 func (fake *FakeRepository) UserEmailCallCount() int { 2897 fake.userEmailMutex.RLock() 2898 defer fake.userEmailMutex.RUnlock() 2899 return len(fake.userEmailArgsForCall) 2900 } 2901 2902 func (fake *FakeRepository) UserEmailCalls(stub func() string) { 2903 fake.userEmailMutex.Lock() 2904 defer fake.userEmailMutex.Unlock() 2905 fake.UserEmailStub = stub 2906 } 2907 2908 func (fake *FakeRepository) UserEmailReturns(result1 string) { 2909 fake.userEmailMutex.Lock() 2910 defer fake.userEmailMutex.Unlock() 2911 fake.UserEmailStub = nil 2912 fake.userEmailReturns = struct { 2913 result1 string 2914 }{result1} 2915 } 2916 2917 func (fake *FakeRepository) UserEmailReturnsOnCall(i int, result1 string) { 2918 fake.userEmailMutex.Lock() 2919 defer fake.userEmailMutex.Unlock() 2920 fake.UserEmailStub = nil 2921 if fake.userEmailReturnsOnCall == nil { 2922 fake.userEmailReturnsOnCall = make(map[int]struct { 2923 result1 string 2924 }) 2925 } 2926 fake.userEmailReturnsOnCall[i] = struct { 2927 result1 string 2928 }{result1} 2929 } 2930 2931 func (fake *FakeRepository) UserGUID() string { 2932 fake.userGUIDMutex.Lock() 2933 ret, specificReturn := fake.userGUIDReturnsOnCall[len(fake.userGUIDArgsForCall)] 2934 fake.userGUIDArgsForCall = append(fake.userGUIDArgsForCall, struct { 2935 }{}) 2936 fake.recordInvocation("UserGUID", []interface{}{}) 2937 fake.userGUIDMutex.Unlock() 2938 if fake.UserGUIDStub != nil { 2939 return fake.UserGUIDStub() 2940 } 2941 if specificReturn { 2942 return ret.result1 2943 } 2944 fakeReturns := fake.userGUIDReturns 2945 return fakeReturns.result1 2946 } 2947 2948 func (fake *FakeRepository) UserGUIDCallCount() int { 2949 fake.userGUIDMutex.RLock() 2950 defer fake.userGUIDMutex.RUnlock() 2951 return len(fake.userGUIDArgsForCall) 2952 } 2953 2954 func (fake *FakeRepository) UserGUIDCalls(stub func() string) { 2955 fake.userGUIDMutex.Lock() 2956 defer fake.userGUIDMutex.Unlock() 2957 fake.UserGUIDStub = stub 2958 } 2959 2960 func (fake *FakeRepository) UserGUIDReturns(result1 string) { 2961 fake.userGUIDMutex.Lock() 2962 defer fake.userGUIDMutex.Unlock() 2963 fake.UserGUIDStub = nil 2964 fake.userGUIDReturns = struct { 2965 result1 string 2966 }{result1} 2967 } 2968 2969 func (fake *FakeRepository) UserGUIDReturnsOnCall(i int, result1 string) { 2970 fake.userGUIDMutex.Lock() 2971 defer fake.userGUIDMutex.Unlock() 2972 fake.UserGUIDStub = nil 2973 if fake.userGUIDReturnsOnCall == nil { 2974 fake.userGUIDReturnsOnCall = make(map[int]struct { 2975 result1 string 2976 }) 2977 } 2978 fake.userGUIDReturnsOnCall[i] = struct { 2979 result1 string 2980 }{result1} 2981 } 2982 2983 func (fake *FakeRepository) Username() string { 2984 fake.usernameMutex.Lock() 2985 ret, specificReturn := fake.usernameReturnsOnCall[len(fake.usernameArgsForCall)] 2986 fake.usernameArgsForCall = append(fake.usernameArgsForCall, struct { 2987 }{}) 2988 fake.recordInvocation("Username", []interface{}{}) 2989 fake.usernameMutex.Unlock() 2990 if fake.UsernameStub != nil { 2991 return fake.UsernameStub() 2992 } 2993 if specificReturn { 2994 return ret.result1 2995 } 2996 fakeReturns := fake.usernameReturns 2997 return fakeReturns.result1 2998 } 2999 3000 func (fake *FakeRepository) UsernameCallCount() int { 3001 fake.usernameMutex.RLock() 3002 defer fake.usernameMutex.RUnlock() 3003 return len(fake.usernameArgsForCall) 3004 } 3005 3006 func (fake *FakeRepository) UsernameCalls(stub func() string) { 3007 fake.usernameMutex.Lock() 3008 defer fake.usernameMutex.Unlock() 3009 fake.UsernameStub = stub 3010 } 3011 3012 func (fake *FakeRepository) UsernameReturns(result1 string) { 3013 fake.usernameMutex.Lock() 3014 defer fake.usernameMutex.Unlock() 3015 fake.UsernameStub = nil 3016 fake.usernameReturns = struct { 3017 result1 string 3018 }{result1} 3019 } 3020 3021 func (fake *FakeRepository) UsernameReturnsOnCall(i int, result1 string) { 3022 fake.usernameMutex.Lock() 3023 defer fake.usernameMutex.Unlock() 3024 fake.UsernameStub = nil 3025 if fake.usernameReturnsOnCall == nil { 3026 fake.usernameReturnsOnCall = make(map[int]struct { 3027 result1 string 3028 }) 3029 } 3030 fake.usernameReturnsOnCall[i] = struct { 3031 result1 string 3032 }{result1} 3033 } 3034 3035 func (fake *FakeRepository) Invocations() map[string][][]interface{} { 3036 fake.invocationsMutex.RLock() 3037 defer fake.invocationsMutex.RUnlock() 3038 fake.aPIEndpointMutex.RLock() 3039 defer fake.aPIEndpointMutex.RUnlock() 3040 fake.aPIVersionMutex.RLock() 3041 defer fake.aPIVersionMutex.RUnlock() 3042 fake.accessTokenMutex.RLock() 3043 defer fake.accessTokenMutex.RUnlock() 3044 fake.asyncTimeoutMutex.RLock() 3045 defer fake.asyncTimeoutMutex.RUnlock() 3046 fake.authenticationEndpointMutex.RLock() 3047 defer fake.authenticationEndpointMutex.RUnlock() 3048 fake.cLIVersionMutex.RLock() 3049 defer fake.cLIVersionMutex.RUnlock() 3050 fake.clearSessionMutex.RLock() 3051 defer fake.clearSessionMutex.RUnlock() 3052 fake.closeMutex.RLock() 3053 defer fake.closeMutex.RUnlock() 3054 fake.colorEnabledMutex.RLock() 3055 defer fake.colorEnabledMutex.RUnlock() 3056 fake.dopplerEndpointMutex.RLock() 3057 defer fake.dopplerEndpointMutex.RUnlock() 3058 fake.hasAPIEndpointMutex.RLock() 3059 defer fake.hasAPIEndpointMutex.RUnlock() 3060 fake.hasOrganizationMutex.RLock() 3061 defer fake.hasOrganizationMutex.RUnlock() 3062 fake.hasSpaceMutex.RLock() 3063 defer fake.hasSpaceMutex.RUnlock() 3064 fake.isLoggedInMutex.RLock() 3065 defer fake.isLoggedInMutex.RUnlock() 3066 fake.isMinAPIVersionMutex.RLock() 3067 defer fake.isMinAPIVersionMutex.RUnlock() 3068 fake.isMinCLIVersionMutex.RLock() 3069 defer fake.isMinCLIVersionMutex.RUnlock() 3070 fake.isSSLDisabledMutex.RLock() 3071 defer fake.isSSLDisabledMutex.RUnlock() 3072 fake.localeMutex.RLock() 3073 defer fake.localeMutex.RUnlock() 3074 fake.logCacheEndpointMutex.RLock() 3075 defer fake.logCacheEndpointMutex.RUnlock() 3076 fake.minCLIVersionMutex.RLock() 3077 defer fake.minCLIVersionMutex.RUnlock() 3078 fake.minRecommendedCLIVersionMutex.RLock() 3079 defer fake.minRecommendedCLIVersionMutex.RUnlock() 3080 fake.organizationFieldsMutex.RLock() 3081 defer fake.organizationFieldsMutex.RUnlock() 3082 fake.pluginReposMutex.RLock() 3083 defer fake.pluginReposMutex.RUnlock() 3084 fake.refreshTokenMutex.RLock() 3085 defer fake.refreshTokenMutex.RUnlock() 3086 fake.routingAPIEndpointMutex.RLock() 3087 defer fake.routingAPIEndpointMutex.RUnlock() 3088 fake.sSHOAuthClientMutex.RLock() 3089 defer fake.sSHOAuthClientMutex.RUnlock() 3090 fake.setAPIEndpointMutex.RLock() 3091 defer fake.setAPIEndpointMutex.RUnlock() 3092 fake.setAPIVersionMutex.RLock() 3093 defer fake.setAPIVersionMutex.RUnlock() 3094 fake.setAccessTokenMutex.RLock() 3095 defer fake.setAccessTokenMutex.RUnlock() 3096 fake.setAsyncTimeoutMutex.RLock() 3097 defer fake.setAsyncTimeoutMutex.RUnlock() 3098 fake.setAuthenticationEndpointMutex.RLock() 3099 defer fake.setAuthenticationEndpointMutex.RUnlock() 3100 fake.setCLIVersionMutex.RLock() 3101 defer fake.setCLIVersionMutex.RUnlock() 3102 fake.setColorEnabledMutex.RLock() 3103 defer fake.setColorEnabledMutex.RUnlock() 3104 fake.setDopplerEndpointMutex.RLock() 3105 defer fake.setDopplerEndpointMutex.RUnlock() 3106 fake.setLocaleMutex.RLock() 3107 defer fake.setLocaleMutex.RUnlock() 3108 fake.setLogCacheEndpointMutex.RLock() 3109 defer fake.setLogCacheEndpointMutex.RUnlock() 3110 fake.setMinCLIVersionMutex.RLock() 3111 defer fake.setMinCLIVersionMutex.RUnlock() 3112 fake.setMinRecommendedCLIVersionMutex.RLock() 3113 defer fake.setMinRecommendedCLIVersionMutex.RUnlock() 3114 fake.setOrganizationFieldsMutex.RLock() 3115 defer fake.setOrganizationFieldsMutex.RUnlock() 3116 fake.setPluginRepoMutex.RLock() 3117 defer fake.setPluginRepoMutex.RUnlock() 3118 fake.setRefreshTokenMutex.RLock() 3119 defer fake.setRefreshTokenMutex.RUnlock() 3120 fake.setRoutingAPIEndpointMutex.RLock() 3121 defer fake.setRoutingAPIEndpointMutex.RUnlock() 3122 fake.setSSHOAuthClientMutex.RLock() 3123 defer fake.setSSHOAuthClientMutex.RUnlock() 3124 fake.setSSLDisabledMutex.RLock() 3125 defer fake.setSSLDisabledMutex.RUnlock() 3126 fake.setSpaceFieldsMutex.RLock() 3127 defer fake.setSpaceFieldsMutex.RUnlock() 3128 fake.setTraceMutex.RLock() 3129 defer fake.setTraceMutex.RUnlock() 3130 fake.setUAAGrantTypeMutex.RLock() 3131 defer fake.setUAAGrantTypeMutex.RUnlock() 3132 fake.setUAAOAuthClientMutex.RLock() 3133 defer fake.setUAAOAuthClientMutex.RUnlock() 3134 fake.setUAAOAuthClientSecretMutex.RLock() 3135 defer fake.setUAAOAuthClientSecretMutex.RUnlock() 3136 fake.setUaaEndpointMutex.RLock() 3137 defer fake.setUaaEndpointMutex.RUnlock() 3138 fake.spaceFieldsMutex.RLock() 3139 defer fake.spaceFieldsMutex.RUnlock() 3140 fake.traceMutex.RLock() 3141 defer fake.traceMutex.RUnlock() 3142 fake.uAAGrantTypeMutex.RLock() 3143 defer fake.uAAGrantTypeMutex.RUnlock() 3144 fake.uAAOAuthClientMutex.RLock() 3145 defer fake.uAAOAuthClientMutex.RUnlock() 3146 fake.uAAOAuthClientSecretMutex.RLock() 3147 defer fake.uAAOAuthClientSecretMutex.RUnlock() 3148 fake.uaaEndpointMutex.RLock() 3149 defer fake.uaaEndpointMutex.RUnlock() 3150 fake.unSetPluginRepoMutex.RLock() 3151 defer fake.unSetPluginRepoMutex.RUnlock() 3152 fake.userEmailMutex.RLock() 3153 defer fake.userEmailMutex.RUnlock() 3154 fake.userGUIDMutex.RLock() 3155 defer fake.userGUIDMutex.RUnlock() 3156 fake.usernameMutex.RLock() 3157 defer fake.usernameMutex.RUnlock() 3158 copiedInvocations := map[string][][]interface{}{} 3159 for key, value := range fake.invocations { 3160 copiedInvocations[key] = value 3161 } 3162 return copiedInvocations 3163 } 3164 3165 func (fake *FakeRepository) recordInvocation(key string, args []interface{}) { 3166 fake.invocationsMutex.Lock() 3167 defer fake.invocationsMutex.Unlock() 3168 if fake.invocations == nil { 3169 fake.invocations = map[string][][]interface{}{} 3170 } 3171 if fake.invocations[key] == nil { 3172 fake.invocations[key] = [][]interface{}{} 3173 } 3174 fake.invocations[key] = append(fake.invocations[key], args) 3175 } 3176 3177 var _ coreconfig.Repository = new(FakeRepository)