github.com/asifdxtreme/cli@v6.1.3-0.20150123051144-9ead8700b4ae+incompatible/cf/configuration/fakes/fake_repository.go (about) 1 // This file was generated by counterfeiter 2 package fakes 3 4 import ( 5 . "github.com/cloudfoundry/cli/cf/configuration/core_config" 6 "github.com/cloudfoundry/cli/cf/models" 7 8 "sync" 9 ) 10 11 type FakeRepository struct { 12 ApiEndpointStub func() string 13 apiEndpointMutex sync.RWMutex 14 apiEndpointArgsForCall []struct{} 15 apiEndpointReturns struct { 16 result1 string 17 } 18 ApiVersionStub func() string 19 apiVersionMutex sync.RWMutex 20 apiVersionArgsForCall []struct{} 21 apiVersionReturns struct { 22 result1 string 23 } 24 HasAPIEndpointStub func() bool 25 hasAPIEndpointMutex sync.RWMutex 26 hasAPIEndpointArgsForCall []struct{} 27 hasAPIEndpointReturns struct { 28 result1 bool 29 } 30 AuthenticationEndpointStub func() string 31 authenticationEndpointMutex sync.RWMutex 32 authenticationEndpointArgsForCall []struct{} 33 authenticationEndpointReturns struct { 34 result1 string 35 } 36 LoggregatorEndpointStub func() string 37 loggregatorEndpointMutex sync.RWMutex 38 loggregatorEndpointArgsForCall []struct{} 39 loggregatorEndpointReturns struct { 40 result1 string 41 } 42 UaaEndpointStub func() string 43 uaaEndpointMutex sync.RWMutex 44 uaaEndpointArgsForCall []struct{} 45 uaaEndpointReturns struct { 46 result1 string 47 } 48 AccessTokenStub func() string 49 accessTokenMutex sync.RWMutex 50 accessTokenArgsForCall []struct{} 51 accessTokenReturns struct { 52 result1 string 53 } 54 RefreshTokenStub func() string 55 refreshTokenMutex sync.RWMutex 56 refreshTokenArgsForCall []struct{} 57 refreshTokenReturns struct { 58 result1 string 59 } 60 OrganizationFieldsStub func() models.OrganizationFields 61 organizationFieldsMutex sync.RWMutex 62 organizationFieldsArgsForCall []struct{} 63 organizationFieldsReturns struct { 64 result1 models.OrganizationFields 65 } 66 HasOrganizationStub func() bool 67 hasOrganizationMutex sync.RWMutex 68 hasOrganizationArgsForCall []struct{} 69 hasOrganizationReturns struct { 70 result1 bool 71 } 72 SpaceFieldsStub func() models.SpaceFields 73 spaceFieldsMutex sync.RWMutex 74 spaceFieldsArgsForCall []struct{} 75 spaceFieldsReturns struct { 76 result1 models.SpaceFields 77 } 78 HasSpaceStub func() bool 79 hasSpaceMutex sync.RWMutex 80 hasSpaceArgsForCall []struct{} 81 hasSpaceReturns struct { 82 result1 bool 83 } 84 UsernameStub func() string 85 usernameMutex sync.RWMutex 86 usernameArgsForCall []struct{} 87 usernameReturns struct { 88 result1 string 89 } 90 UserGuidStub func() string 91 userGuidMutex sync.RWMutex 92 userGuidArgsForCall []struct{} 93 userGuidReturns struct { 94 result1 string 95 } 96 UserEmailStub func() string 97 userEmailMutex sync.RWMutex 98 userEmailArgsForCall []struct{} 99 userEmailReturns struct { 100 result1 string 101 } 102 IsLoggedInStub func() bool 103 isLoggedInMutex sync.RWMutex 104 isLoggedInArgsForCall []struct{} 105 isLoggedInReturns struct { 106 result1 bool 107 } 108 IsSSLDisabledStub func() bool 109 isSSLDisabledMutex sync.RWMutex 110 isSSLDisabledArgsForCall []struct{} 111 isSSLDisabledReturns struct { 112 result1 bool 113 } 114 AsyncTimeoutStub func() uint 115 asyncTimeoutMutex sync.RWMutex 116 asyncTimeoutArgsForCall []struct{} 117 asyncTimeoutReturns struct { 118 result1 uint 119 } 120 TraceStub func() string 121 traceMutex sync.RWMutex 122 traceArgsForCall []struct{} 123 traceReturns struct { 124 result1 string 125 } 126 ColorEnabledStub func() string 127 colorEnabledMutex sync.RWMutex 128 colorEnabledArgsForCall []struct{} 129 colorEnabledReturns struct { 130 result1 string 131 } 132 LocaleStub func() string 133 localeMutex sync.RWMutex 134 localeArgsForCall []struct{} 135 localeReturns struct { 136 result1 string 137 } 138 PluginsStub func() map[string]string 139 pluginsMutex sync.RWMutex 140 pluginsArgsForCall []struct{} 141 pluginsReturns struct { 142 result1 map[string]string 143 } 144 UserHomePathStub func() string 145 userHomePathMutex sync.RWMutex 146 userHomePathArgsForCall []struct{} 147 userHomePathReturns struct { 148 result1 string 149 } 150 ClearSessionStub func() 151 clearSessionMutex sync.RWMutex 152 clearSessionArgsForCall []struct{} 153 SetApiEndpointStub func(string) 154 setApiEndpointMutex sync.RWMutex 155 setApiEndpointArgsForCall []struct { 156 arg1 string 157 } 158 SetApiVersionStub func(string) 159 setApiVersionMutex sync.RWMutex 160 setApiVersionArgsForCall []struct { 161 arg1 string 162 } 163 SetAuthenticationEndpointStub func(string) 164 setAuthenticationEndpointMutex sync.RWMutex 165 setAuthenticationEndpointArgsForCall []struct { 166 arg1 string 167 } 168 SetLoggregatorEndpointStub func(string) 169 setLoggregatorEndpointMutex sync.RWMutex 170 setLoggregatorEndpointArgsForCall []struct { 171 arg1 string 172 } 173 SetUaaEndpointStub func(string) 174 setUaaEndpointMutex sync.RWMutex 175 setUaaEndpointArgsForCall []struct { 176 arg1 string 177 } 178 SetAccessTokenStub func(string) 179 setAccessTokenMutex sync.RWMutex 180 setAccessTokenArgsForCall []struct { 181 arg1 string 182 } 183 SetRefreshTokenStub func(string) 184 setRefreshTokenMutex sync.RWMutex 185 setRefreshTokenArgsForCall []struct { 186 arg1 string 187 } 188 SetOrganizationFieldsStub func(models.OrganizationFields) 189 setOrganizationFieldsMutex sync.RWMutex 190 setOrganizationFieldsArgsForCall []struct { 191 arg1 models.OrganizationFields 192 } 193 SetSpaceFieldsStub func(models.SpaceFields) 194 setSpaceFieldsMutex sync.RWMutex 195 setSpaceFieldsArgsForCall []struct { 196 arg1 models.SpaceFields 197 } 198 SetSSLDisabledStub func(bool) 199 setSSLDisabledMutex sync.RWMutex 200 setSSLDisabledArgsForCall []struct { 201 arg1 bool 202 } 203 SetAsyncTimeoutStub func(uint) 204 setAsyncTimeoutMutex sync.RWMutex 205 setAsyncTimeoutArgsForCall []struct { 206 arg1 uint 207 } 208 SetTraceStub func(string) 209 setTraceMutex sync.RWMutex 210 setTraceArgsForCall []struct { 211 arg1 string 212 } 213 SetColorEnabledStub func(string) 214 setColorEnabledMutex sync.RWMutex 215 setColorEnabledArgsForCall []struct { 216 arg1 string 217 } 218 SetLocaleStub func(string) 219 setLocaleMutex sync.RWMutex 220 setLocaleArgsForCall []struct { 221 arg1 string 222 } 223 SetPluginStub func(string, string) 224 setPluginMutex sync.RWMutex 225 setPluginArgsForCall []struct { 226 arg1 string 227 arg2 string 228 } 229 CloseStub func() 230 closeMutex sync.RWMutex 231 closeArgsForCall []struct{} 232 } 233 234 func (fake *FakeRepository) ApiEndpoint() string { 235 fake.apiEndpointMutex.Lock() 236 defer fake.apiEndpointMutex.Unlock() 237 fake.apiEndpointArgsForCall = append(fake.apiEndpointArgsForCall, struct{}{}) 238 if fake.ApiEndpointStub != nil { 239 return fake.ApiEndpointStub() 240 } else { 241 return fake.apiEndpointReturns.result1 242 } 243 } 244 245 func (fake *FakeRepository) ApiEndpointCallCount() int { 246 fake.apiEndpointMutex.RLock() 247 defer fake.apiEndpointMutex.RUnlock() 248 return len(fake.apiEndpointArgsForCall) 249 } 250 251 func (fake *FakeRepository) ApiEndpointReturns(result1 string) { 252 fake.apiEndpointReturns = struct { 253 result1 string 254 }{result1} 255 } 256 257 func (fake *FakeRepository) ApiVersion() string { 258 fake.apiVersionMutex.Lock() 259 defer fake.apiVersionMutex.Unlock() 260 fake.apiVersionArgsForCall = append(fake.apiVersionArgsForCall, struct{}{}) 261 if fake.ApiVersionStub != nil { 262 return fake.ApiVersionStub() 263 } else { 264 return fake.apiVersionReturns.result1 265 } 266 } 267 268 func (fake *FakeRepository) ApiVersionCallCount() int { 269 fake.apiVersionMutex.RLock() 270 defer fake.apiVersionMutex.RUnlock() 271 return len(fake.apiVersionArgsForCall) 272 } 273 274 func (fake *FakeRepository) ApiVersionReturns(result1 string) { 275 fake.apiVersionReturns = struct { 276 result1 string 277 }{result1} 278 } 279 280 func (fake *FakeRepository) HasAPIEndpoint() bool { 281 fake.hasAPIEndpointMutex.Lock() 282 defer fake.hasAPIEndpointMutex.Unlock() 283 fake.hasAPIEndpointArgsForCall = append(fake.hasAPIEndpointArgsForCall, struct{}{}) 284 if fake.HasAPIEndpointStub != nil { 285 return fake.HasAPIEndpointStub() 286 } else { 287 return fake.hasAPIEndpointReturns.result1 288 } 289 } 290 291 func (fake *FakeRepository) HasAPIEndpointCallCount() int { 292 fake.hasAPIEndpointMutex.RLock() 293 defer fake.hasAPIEndpointMutex.RUnlock() 294 return len(fake.hasAPIEndpointArgsForCall) 295 } 296 297 func (fake *FakeRepository) HasAPIEndpointReturns(result1 bool) { 298 fake.hasAPIEndpointReturns = struct { 299 result1 bool 300 }{result1} 301 } 302 303 func (fake *FakeRepository) AuthenticationEndpoint() string { 304 fake.authenticationEndpointMutex.Lock() 305 defer fake.authenticationEndpointMutex.Unlock() 306 fake.authenticationEndpointArgsForCall = append(fake.authenticationEndpointArgsForCall, struct{}{}) 307 if fake.AuthenticationEndpointStub != nil { 308 return fake.AuthenticationEndpointStub() 309 } else { 310 return fake.authenticationEndpointReturns.result1 311 } 312 } 313 314 func (fake *FakeRepository) AuthenticationEndpointCallCount() int { 315 fake.authenticationEndpointMutex.RLock() 316 defer fake.authenticationEndpointMutex.RUnlock() 317 return len(fake.authenticationEndpointArgsForCall) 318 } 319 320 func (fake *FakeRepository) AuthenticationEndpointReturns(result1 string) { 321 fake.authenticationEndpointReturns = struct { 322 result1 string 323 }{result1} 324 } 325 326 func (fake *FakeRepository) LoggregatorEndpoint() string { 327 fake.loggregatorEndpointMutex.Lock() 328 defer fake.loggregatorEndpointMutex.Unlock() 329 fake.loggregatorEndpointArgsForCall = append(fake.loggregatorEndpointArgsForCall, struct{}{}) 330 if fake.LoggregatorEndpointStub != nil { 331 return fake.LoggregatorEndpointStub() 332 } else { 333 return fake.loggregatorEndpointReturns.result1 334 } 335 } 336 337 func (fake *FakeRepository) LoggregatorEndpointCallCount() int { 338 fake.loggregatorEndpointMutex.RLock() 339 defer fake.loggregatorEndpointMutex.RUnlock() 340 return len(fake.loggregatorEndpointArgsForCall) 341 } 342 343 func (fake *FakeRepository) LoggregatorEndpointReturns(result1 string) { 344 fake.loggregatorEndpointReturns = struct { 345 result1 string 346 }{result1} 347 } 348 349 func (fake *FakeRepository) UaaEndpoint() string { 350 fake.uaaEndpointMutex.Lock() 351 defer fake.uaaEndpointMutex.Unlock() 352 fake.uaaEndpointArgsForCall = append(fake.uaaEndpointArgsForCall, struct{}{}) 353 if fake.UaaEndpointStub != nil { 354 return fake.UaaEndpointStub() 355 } else { 356 return fake.uaaEndpointReturns.result1 357 } 358 } 359 360 func (fake *FakeRepository) UaaEndpointCallCount() int { 361 fake.uaaEndpointMutex.RLock() 362 defer fake.uaaEndpointMutex.RUnlock() 363 return len(fake.uaaEndpointArgsForCall) 364 } 365 366 func (fake *FakeRepository) UaaEndpointReturns(result1 string) { 367 fake.uaaEndpointReturns = struct { 368 result1 string 369 }{result1} 370 } 371 372 func (fake *FakeRepository) AccessToken() string { 373 fake.accessTokenMutex.Lock() 374 defer fake.accessTokenMutex.Unlock() 375 fake.accessTokenArgsForCall = append(fake.accessTokenArgsForCall, struct{}{}) 376 if fake.AccessTokenStub != nil { 377 return fake.AccessTokenStub() 378 } else { 379 return fake.accessTokenReturns.result1 380 } 381 } 382 383 func (fake *FakeRepository) AccessTokenCallCount() int { 384 fake.accessTokenMutex.RLock() 385 defer fake.accessTokenMutex.RUnlock() 386 return len(fake.accessTokenArgsForCall) 387 } 388 389 func (fake *FakeRepository) AccessTokenReturns(result1 string) { 390 fake.accessTokenReturns = struct { 391 result1 string 392 }{result1} 393 } 394 395 func (fake *FakeRepository) RefreshToken() string { 396 fake.refreshTokenMutex.Lock() 397 defer fake.refreshTokenMutex.Unlock() 398 fake.refreshTokenArgsForCall = append(fake.refreshTokenArgsForCall, struct{}{}) 399 if fake.RefreshTokenStub != nil { 400 return fake.RefreshTokenStub() 401 } else { 402 return fake.refreshTokenReturns.result1 403 } 404 } 405 406 func (fake *FakeRepository) RefreshTokenCallCount() int { 407 fake.refreshTokenMutex.RLock() 408 defer fake.refreshTokenMutex.RUnlock() 409 return len(fake.refreshTokenArgsForCall) 410 } 411 412 func (fake *FakeRepository) RefreshTokenReturns(result1 string) { 413 fake.refreshTokenReturns = struct { 414 result1 string 415 }{result1} 416 } 417 418 func (fake *FakeRepository) OrganizationFields() models.OrganizationFields { 419 fake.organizationFieldsMutex.Lock() 420 defer fake.organizationFieldsMutex.Unlock() 421 fake.organizationFieldsArgsForCall = append(fake.organizationFieldsArgsForCall, struct{}{}) 422 if fake.OrganizationFieldsStub != nil { 423 return fake.OrganizationFieldsStub() 424 } else { 425 return fake.organizationFieldsReturns.result1 426 } 427 } 428 429 func (fake *FakeRepository) OrganizationFieldsCallCount() int { 430 fake.organizationFieldsMutex.RLock() 431 defer fake.organizationFieldsMutex.RUnlock() 432 return len(fake.organizationFieldsArgsForCall) 433 } 434 435 func (fake *FakeRepository) OrganizationFieldsReturns(result1 models.OrganizationFields) { 436 fake.organizationFieldsReturns = struct { 437 result1 models.OrganizationFields 438 }{result1} 439 } 440 441 func (fake *FakeRepository) HasOrganization() bool { 442 fake.hasOrganizationMutex.Lock() 443 defer fake.hasOrganizationMutex.Unlock() 444 fake.hasOrganizationArgsForCall = append(fake.hasOrganizationArgsForCall, struct{}{}) 445 if fake.HasOrganizationStub != nil { 446 return fake.HasOrganizationStub() 447 } else { 448 return fake.hasOrganizationReturns.result1 449 } 450 } 451 452 func (fake *FakeRepository) HasOrganizationCallCount() int { 453 fake.hasOrganizationMutex.RLock() 454 defer fake.hasOrganizationMutex.RUnlock() 455 return len(fake.hasOrganizationArgsForCall) 456 } 457 458 func (fake *FakeRepository) HasOrganizationReturns(result1 bool) { 459 fake.hasOrganizationReturns = struct { 460 result1 bool 461 }{result1} 462 } 463 464 func (fake *FakeRepository) SpaceFields() models.SpaceFields { 465 fake.spaceFieldsMutex.Lock() 466 defer fake.spaceFieldsMutex.Unlock() 467 fake.spaceFieldsArgsForCall = append(fake.spaceFieldsArgsForCall, struct{}{}) 468 if fake.SpaceFieldsStub != nil { 469 return fake.SpaceFieldsStub() 470 } else { 471 return fake.spaceFieldsReturns.result1 472 } 473 } 474 475 func (fake *FakeRepository) SpaceFieldsCallCount() int { 476 fake.spaceFieldsMutex.RLock() 477 defer fake.spaceFieldsMutex.RUnlock() 478 return len(fake.spaceFieldsArgsForCall) 479 } 480 481 func (fake *FakeRepository) SpaceFieldsReturns(result1 models.SpaceFields) { 482 fake.spaceFieldsReturns = struct { 483 result1 models.SpaceFields 484 }{result1} 485 } 486 487 func (fake *FakeRepository) HasSpace() bool { 488 fake.hasSpaceMutex.Lock() 489 defer fake.hasSpaceMutex.Unlock() 490 fake.hasSpaceArgsForCall = append(fake.hasSpaceArgsForCall, struct{}{}) 491 if fake.HasSpaceStub != nil { 492 return fake.HasSpaceStub() 493 } else { 494 return fake.hasSpaceReturns.result1 495 } 496 } 497 498 func (fake *FakeRepository) HasSpaceCallCount() int { 499 fake.hasSpaceMutex.RLock() 500 defer fake.hasSpaceMutex.RUnlock() 501 return len(fake.hasSpaceArgsForCall) 502 } 503 504 func (fake *FakeRepository) HasSpaceReturns(result1 bool) { 505 fake.hasSpaceReturns = struct { 506 result1 bool 507 }{result1} 508 } 509 510 func (fake *FakeRepository) Username() string { 511 fake.usernameMutex.Lock() 512 defer fake.usernameMutex.Unlock() 513 fake.usernameArgsForCall = append(fake.usernameArgsForCall, struct{}{}) 514 if fake.UsernameStub != nil { 515 return fake.UsernameStub() 516 } else { 517 return fake.usernameReturns.result1 518 } 519 } 520 521 func (fake *FakeRepository) UsernameCallCount() int { 522 fake.usernameMutex.RLock() 523 defer fake.usernameMutex.RUnlock() 524 return len(fake.usernameArgsForCall) 525 } 526 527 func (fake *FakeRepository) UsernameReturns(result1 string) { 528 fake.usernameReturns = struct { 529 result1 string 530 }{result1} 531 } 532 533 func (fake *FakeRepository) UserGuid() string { 534 fake.userGuidMutex.Lock() 535 defer fake.userGuidMutex.Unlock() 536 fake.userGuidArgsForCall = append(fake.userGuidArgsForCall, struct{}{}) 537 if fake.UserGuidStub != nil { 538 return fake.UserGuidStub() 539 } else { 540 return fake.userGuidReturns.result1 541 } 542 } 543 544 func (fake *FakeRepository) UserGuidCallCount() int { 545 fake.userGuidMutex.RLock() 546 defer fake.userGuidMutex.RUnlock() 547 return len(fake.userGuidArgsForCall) 548 } 549 550 func (fake *FakeRepository) UserGuidReturns(result1 string) { 551 fake.userGuidReturns = struct { 552 result1 string 553 }{result1} 554 } 555 556 func (fake *FakeRepository) UserEmail() string { 557 fake.userEmailMutex.Lock() 558 defer fake.userEmailMutex.Unlock() 559 fake.userEmailArgsForCall = append(fake.userEmailArgsForCall, struct{}{}) 560 if fake.UserEmailStub != nil { 561 return fake.UserEmailStub() 562 } else { 563 return fake.userEmailReturns.result1 564 } 565 } 566 567 func (fake *FakeRepository) UserEmailCallCount() int { 568 fake.userEmailMutex.RLock() 569 defer fake.userEmailMutex.RUnlock() 570 return len(fake.userEmailArgsForCall) 571 } 572 573 func (fake *FakeRepository) UserEmailReturns(result1 string) { 574 fake.userEmailReturns = struct { 575 result1 string 576 }{result1} 577 } 578 579 func (fake *FakeRepository) IsLoggedIn() bool { 580 fake.isLoggedInMutex.Lock() 581 defer fake.isLoggedInMutex.Unlock() 582 fake.isLoggedInArgsForCall = append(fake.isLoggedInArgsForCall, struct{}{}) 583 if fake.IsLoggedInStub != nil { 584 return fake.IsLoggedInStub() 585 } else { 586 return fake.isLoggedInReturns.result1 587 } 588 } 589 590 func (fake *FakeRepository) IsLoggedInCallCount() int { 591 fake.isLoggedInMutex.RLock() 592 defer fake.isLoggedInMutex.RUnlock() 593 return len(fake.isLoggedInArgsForCall) 594 } 595 596 func (fake *FakeRepository) IsLoggedInReturns(result1 bool) { 597 fake.isLoggedInReturns = struct { 598 result1 bool 599 }{result1} 600 } 601 602 func (fake *FakeRepository) IsSSLDisabled() bool { 603 fake.isSSLDisabledMutex.Lock() 604 defer fake.isSSLDisabledMutex.Unlock() 605 fake.isSSLDisabledArgsForCall = append(fake.isSSLDisabledArgsForCall, struct{}{}) 606 if fake.IsSSLDisabledStub != nil { 607 return fake.IsSSLDisabledStub() 608 } else { 609 return fake.isSSLDisabledReturns.result1 610 } 611 } 612 613 func (fake *FakeRepository) IsSSLDisabledCallCount() int { 614 fake.isSSLDisabledMutex.RLock() 615 defer fake.isSSLDisabledMutex.RUnlock() 616 return len(fake.isSSLDisabledArgsForCall) 617 } 618 619 func (fake *FakeRepository) IsSSLDisabledReturns(result1 bool) { 620 fake.isSSLDisabledReturns = struct { 621 result1 bool 622 }{result1} 623 } 624 625 func (fake *FakeRepository) AsyncTimeout() uint { 626 fake.asyncTimeoutMutex.Lock() 627 defer fake.asyncTimeoutMutex.Unlock() 628 fake.asyncTimeoutArgsForCall = append(fake.asyncTimeoutArgsForCall, struct{}{}) 629 if fake.AsyncTimeoutStub != nil { 630 return fake.AsyncTimeoutStub() 631 } else { 632 return fake.asyncTimeoutReturns.result1 633 } 634 } 635 636 func (fake *FakeRepository) AsyncTimeoutCallCount() int { 637 fake.asyncTimeoutMutex.RLock() 638 defer fake.asyncTimeoutMutex.RUnlock() 639 return len(fake.asyncTimeoutArgsForCall) 640 } 641 642 func (fake *FakeRepository) AsyncTimeoutReturns(result1 uint) { 643 fake.asyncTimeoutReturns = struct { 644 result1 uint 645 }{result1} 646 } 647 648 func (fake *FakeRepository) Trace() string { 649 fake.traceMutex.Lock() 650 defer fake.traceMutex.Unlock() 651 fake.traceArgsForCall = append(fake.traceArgsForCall, struct{}{}) 652 if fake.TraceStub != nil { 653 return fake.TraceStub() 654 } else { 655 return fake.traceReturns.result1 656 } 657 } 658 659 func (fake *FakeRepository) TraceCallCount() int { 660 fake.traceMutex.RLock() 661 defer fake.traceMutex.RUnlock() 662 return len(fake.traceArgsForCall) 663 } 664 665 func (fake *FakeRepository) TraceReturns(result1 string) { 666 fake.traceReturns = struct { 667 result1 string 668 }{result1} 669 } 670 671 func (fake *FakeRepository) ColorEnabled() string { 672 fake.colorEnabledMutex.Lock() 673 defer fake.colorEnabledMutex.Unlock() 674 fake.colorEnabledArgsForCall = append(fake.colorEnabledArgsForCall, struct{}{}) 675 if fake.ColorEnabledStub != nil { 676 return fake.ColorEnabledStub() 677 } else { 678 return fake.colorEnabledReturns.result1 679 } 680 } 681 682 func (fake *FakeRepository) ColorEnabledCallCount() int { 683 fake.colorEnabledMutex.RLock() 684 defer fake.colorEnabledMutex.RUnlock() 685 return len(fake.colorEnabledArgsForCall) 686 } 687 688 func (fake *FakeRepository) ColorEnabledReturns(result1 string) { 689 fake.colorEnabledReturns = struct { 690 result1 string 691 }{result1} 692 } 693 694 func (fake *FakeRepository) Locale() string { 695 fake.localeMutex.Lock() 696 defer fake.localeMutex.Unlock() 697 fake.localeArgsForCall = append(fake.localeArgsForCall, struct{}{}) 698 if fake.LocaleStub != nil { 699 return fake.LocaleStub() 700 } else { 701 return fake.localeReturns.result1 702 } 703 } 704 705 func (fake *FakeRepository) LocaleCallCount() int { 706 fake.localeMutex.RLock() 707 defer fake.localeMutex.RUnlock() 708 return len(fake.localeArgsForCall) 709 } 710 711 func (fake *FakeRepository) LocaleReturns(result1 string) { 712 fake.localeReturns = struct { 713 result1 string 714 }{result1} 715 } 716 717 func (fake *FakeRepository) Plugins() map[string]string { 718 fake.pluginsMutex.Lock() 719 defer fake.pluginsMutex.Unlock() 720 fake.pluginsArgsForCall = append(fake.pluginsArgsForCall, struct{}{}) 721 if fake.PluginsStub != nil { 722 return fake.PluginsStub() 723 } else { 724 return fake.pluginsReturns.result1 725 } 726 } 727 728 func (fake *FakeRepository) PluginsCallCount() int { 729 fake.pluginsMutex.RLock() 730 defer fake.pluginsMutex.RUnlock() 731 return len(fake.pluginsArgsForCall) 732 } 733 734 func (fake *FakeRepository) PluginsReturns(result1 map[string]string) { 735 fake.pluginsReturns = struct { 736 result1 map[string]string 737 }{result1} 738 } 739 740 func (fake *FakeRepository) UserHomePath() string { 741 fake.userHomePathMutex.Lock() 742 defer fake.userHomePathMutex.Unlock() 743 fake.userHomePathArgsForCall = append(fake.userHomePathArgsForCall, struct{}{}) 744 if fake.UserHomePathStub != nil { 745 return fake.UserHomePathStub() 746 } else { 747 return fake.userHomePathReturns.result1 748 } 749 } 750 751 func (fake *FakeRepository) UserHomePathCallCount() int { 752 fake.userHomePathMutex.RLock() 753 defer fake.userHomePathMutex.RUnlock() 754 return len(fake.userHomePathArgsForCall) 755 } 756 757 func (fake *FakeRepository) UserHomePathReturns(result1 string) { 758 fake.userHomePathReturns = struct { 759 result1 string 760 }{result1} 761 } 762 763 func (fake *FakeRepository) ClearSession() { 764 fake.clearSessionMutex.Lock() 765 defer fake.clearSessionMutex.Unlock() 766 fake.clearSessionArgsForCall = append(fake.clearSessionArgsForCall, struct{}{}) 767 if fake.ClearSessionStub != nil { 768 fake.ClearSessionStub() 769 } 770 } 771 772 func (fake *FakeRepository) ClearSessionCallCount() int { 773 fake.clearSessionMutex.RLock() 774 defer fake.clearSessionMutex.RUnlock() 775 return len(fake.clearSessionArgsForCall) 776 } 777 778 func (fake *FakeRepository) SetApiEndpoint(arg1 string) { 779 fake.setApiEndpointMutex.Lock() 780 defer fake.setApiEndpointMutex.Unlock() 781 fake.setApiEndpointArgsForCall = append(fake.setApiEndpointArgsForCall, struct { 782 arg1 string 783 }{arg1}) 784 if fake.SetApiEndpointStub != nil { 785 fake.SetApiEndpointStub(arg1) 786 } 787 } 788 789 func (fake *FakeRepository) SetApiEndpointCallCount() int { 790 fake.setApiEndpointMutex.RLock() 791 defer fake.setApiEndpointMutex.RUnlock() 792 return len(fake.setApiEndpointArgsForCall) 793 } 794 795 func (fake *FakeRepository) SetApiEndpointArgsForCall(i int) string { 796 fake.setApiEndpointMutex.RLock() 797 defer fake.setApiEndpointMutex.RUnlock() 798 return fake.setApiEndpointArgsForCall[i].arg1 799 } 800 801 func (fake *FakeRepository) SetApiVersion(arg1 string) { 802 fake.setApiVersionMutex.Lock() 803 defer fake.setApiVersionMutex.Unlock() 804 fake.setApiVersionArgsForCall = append(fake.setApiVersionArgsForCall, struct { 805 arg1 string 806 }{arg1}) 807 if fake.SetApiVersionStub != nil { 808 fake.SetApiVersionStub(arg1) 809 } 810 } 811 812 func (fake *FakeRepository) SetApiVersionCallCount() int { 813 fake.setApiVersionMutex.RLock() 814 defer fake.setApiVersionMutex.RUnlock() 815 return len(fake.setApiVersionArgsForCall) 816 } 817 818 func (fake *FakeRepository) SetApiVersionArgsForCall(i int) string { 819 fake.setApiVersionMutex.RLock() 820 defer fake.setApiVersionMutex.RUnlock() 821 return fake.setApiVersionArgsForCall[i].arg1 822 } 823 824 func (fake *FakeRepository) SetAuthenticationEndpoint(arg1 string) { 825 fake.setAuthenticationEndpointMutex.Lock() 826 defer fake.setAuthenticationEndpointMutex.Unlock() 827 fake.setAuthenticationEndpointArgsForCall = append(fake.setAuthenticationEndpointArgsForCall, struct { 828 arg1 string 829 }{arg1}) 830 if fake.SetAuthenticationEndpointStub != nil { 831 fake.SetAuthenticationEndpointStub(arg1) 832 } 833 } 834 835 func (fake *FakeRepository) SetAuthenticationEndpointCallCount() int { 836 fake.setAuthenticationEndpointMutex.RLock() 837 defer fake.setAuthenticationEndpointMutex.RUnlock() 838 return len(fake.setAuthenticationEndpointArgsForCall) 839 } 840 841 func (fake *FakeRepository) SetAuthenticationEndpointArgsForCall(i int) string { 842 fake.setAuthenticationEndpointMutex.RLock() 843 defer fake.setAuthenticationEndpointMutex.RUnlock() 844 return fake.setAuthenticationEndpointArgsForCall[i].arg1 845 } 846 847 func (fake *FakeRepository) SetLoggregatorEndpoint(arg1 string) { 848 fake.setLoggregatorEndpointMutex.Lock() 849 defer fake.setLoggregatorEndpointMutex.Unlock() 850 fake.setLoggregatorEndpointArgsForCall = append(fake.setLoggregatorEndpointArgsForCall, struct { 851 arg1 string 852 }{arg1}) 853 if fake.SetLoggregatorEndpointStub != nil { 854 fake.SetLoggregatorEndpointStub(arg1) 855 } 856 } 857 858 func (fake *FakeRepository) SetLoggregatorEndpointCallCount() int { 859 fake.setLoggregatorEndpointMutex.RLock() 860 defer fake.setLoggregatorEndpointMutex.RUnlock() 861 return len(fake.setLoggregatorEndpointArgsForCall) 862 } 863 864 func (fake *FakeRepository) SetLoggregatorEndpointArgsForCall(i int) string { 865 fake.setLoggregatorEndpointMutex.RLock() 866 defer fake.setLoggregatorEndpointMutex.RUnlock() 867 return fake.setLoggregatorEndpointArgsForCall[i].arg1 868 } 869 870 func (fake *FakeRepository) SetUaaEndpoint(arg1 string) { 871 fake.setUaaEndpointMutex.Lock() 872 defer fake.setUaaEndpointMutex.Unlock() 873 fake.setUaaEndpointArgsForCall = append(fake.setUaaEndpointArgsForCall, struct { 874 arg1 string 875 }{arg1}) 876 if fake.SetUaaEndpointStub != nil { 877 fake.SetUaaEndpointStub(arg1) 878 } 879 } 880 881 func (fake *FakeRepository) SetUaaEndpointCallCount() int { 882 fake.setUaaEndpointMutex.RLock() 883 defer fake.setUaaEndpointMutex.RUnlock() 884 return len(fake.setUaaEndpointArgsForCall) 885 } 886 887 func (fake *FakeRepository) SetUaaEndpointArgsForCall(i int) string { 888 fake.setUaaEndpointMutex.RLock() 889 defer fake.setUaaEndpointMutex.RUnlock() 890 return fake.setUaaEndpointArgsForCall[i].arg1 891 } 892 893 func (fake *FakeRepository) SetAccessToken(arg1 string) { 894 fake.setAccessTokenMutex.Lock() 895 defer fake.setAccessTokenMutex.Unlock() 896 fake.setAccessTokenArgsForCall = append(fake.setAccessTokenArgsForCall, struct { 897 arg1 string 898 }{arg1}) 899 if fake.SetAccessTokenStub != nil { 900 fake.SetAccessTokenStub(arg1) 901 } 902 } 903 904 func (fake *FakeRepository) SetAccessTokenCallCount() int { 905 fake.setAccessTokenMutex.RLock() 906 defer fake.setAccessTokenMutex.RUnlock() 907 return len(fake.setAccessTokenArgsForCall) 908 } 909 910 func (fake *FakeRepository) SetAccessTokenArgsForCall(i int) string { 911 fake.setAccessTokenMutex.RLock() 912 defer fake.setAccessTokenMutex.RUnlock() 913 return fake.setAccessTokenArgsForCall[i].arg1 914 } 915 916 func (fake *FakeRepository) SetRefreshToken(arg1 string) { 917 fake.setRefreshTokenMutex.Lock() 918 defer fake.setRefreshTokenMutex.Unlock() 919 fake.setRefreshTokenArgsForCall = append(fake.setRefreshTokenArgsForCall, struct { 920 arg1 string 921 }{arg1}) 922 if fake.SetRefreshTokenStub != nil { 923 fake.SetRefreshTokenStub(arg1) 924 } 925 } 926 927 func (fake *FakeRepository) SetRefreshTokenCallCount() int { 928 fake.setRefreshTokenMutex.RLock() 929 defer fake.setRefreshTokenMutex.RUnlock() 930 return len(fake.setRefreshTokenArgsForCall) 931 } 932 933 func (fake *FakeRepository) SetRefreshTokenArgsForCall(i int) string { 934 fake.setRefreshTokenMutex.RLock() 935 defer fake.setRefreshTokenMutex.RUnlock() 936 return fake.setRefreshTokenArgsForCall[i].arg1 937 } 938 939 func (fake *FakeRepository) SetOrganizationFields(arg1 models.OrganizationFields) { 940 fake.setOrganizationFieldsMutex.Lock() 941 defer fake.setOrganizationFieldsMutex.Unlock() 942 fake.setOrganizationFieldsArgsForCall = append(fake.setOrganizationFieldsArgsForCall, struct { 943 arg1 models.OrganizationFields 944 }{arg1}) 945 if fake.SetOrganizationFieldsStub != nil { 946 fake.SetOrganizationFieldsStub(arg1) 947 } 948 } 949 950 func (fake *FakeRepository) SetOrganizationFieldsCallCount() int { 951 fake.setOrganizationFieldsMutex.RLock() 952 defer fake.setOrganizationFieldsMutex.RUnlock() 953 return len(fake.setOrganizationFieldsArgsForCall) 954 } 955 956 func (fake *FakeRepository) SetOrganizationFieldsArgsForCall(i int) models.OrganizationFields { 957 fake.setOrganizationFieldsMutex.RLock() 958 defer fake.setOrganizationFieldsMutex.RUnlock() 959 return fake.setOrganizationFieldsArgsForCall[i].arg1 960 } 961 962 func (fake *FakeRepository) SetSpaceFields(arg1 models.SpaceFields) { 963 fake.setSpaceFieldsMutex.Lock() 964 defer fake.setSpaceFieldsMutex.Unlock() 965 fake.setSpaceFieldsArgsForCall = append(fake.setSpaceFieldsArgsForCall, struct { 966 arg1 models.SpaceFields 967 }{arg1}) 968 if fake.SetSpaceFieldsStub != nil { 969 fake.SetSpaceFieldsStub(arg1) 970 } 971 } 972 973 func (fake *FakeRepository) SetSpaceFieldsCallCount() int { 974 fake.setSpaceFieldsMutex.RLock() 975 defer fake.setSpaceFieldsMutex.RUnlock() 976 return len(fake.setSpaceFieldsArgsForCall) 977 } 978 979 func (fake *FakeRepository) SetSpaceFieldsArgsForCall(i int) models.SpaceFields { 980 fake.setSpaceFieldsMutex.RLock() 981 defer fake.setSpaceFieldsMutex.RUnlock() 982 return fake.setSpaceFieldsArgsForCall[i].arg1 983 } 984 985 func (fake *FakeRepository) SetSSLDisabled(arg1 bool) { 986 fake.setSSLDisabledMutex.Lock() 987 defer fake.setSSLDisabledMutex.Unlock() 988 fake.setSSLDisabledArgsForCall = append(fake.setSSLDisabledArgsForCall, struct { 989 arg1 bool 990 }{arg1}) 991 if fake.SetSSLDisabledStub != nil { 992 fake.SetSSLDisabledStub(arg1) 993 } 994 } 995 996 func (fake *FakeRepository) SetSSLDisabledCallCount() int { 997 fake.setSSLDisabledMutex.RLock() 998 defer fake.setSSLDisabledMutex.RUnlock() 999 return len(fake.setSSLDisabledArgsForCall) 1000 } 1001 1002 func (fake *FakeRepository) SetSSLDisabledArgsForCall(i int) bool { 1003 fake.setSSLDisabledMutex.RLock() 1004 defer fake.setSSLDisabledMutex.RUnlock() 1005 return fake.setSSLDisabledArgsForCall[i].arg1 1006 } 1007 1008 func (fake *FakeRepository) SetAsyncTimeout(arg1 uint) { 1009 fake.setAsyncTimeoutMutex.Lock() 1010 defer fake.setAsyncTimeoutMutex.Unlock() 1011 fake.setAsyncTimeoutArgsForCall = append(fake.setAsyncTimeoutArgsForCall, struct { 1012 arg1 uint 1013 }{arg1}) 1014 if fake.SetAsyncTimeoutStub != nil { 1015 fake.SetAsyncTimeoutStub(arg1) 1016 } 1017 } 1018 1019 func (fake *FakeRepository) SetAsyncTimeoutCallCount() int { 1020 fake.setAsyncTimeoutMutex.RLock() 1021 defer fake.setAsyncTimeoutMutex.RUnlock() 1022 return len(fake.setAsyncTimeoutArgsForCall) 1023 } 1024 1025 func (fake *FakeRepository) SetAsyncTimeoutArgsForCall(i int) uint { 1026 fake.setAsyncTimeoutMutex.RLock() 1027 defer fake.setAsyncTimeoutMutex.RUnlock() 1028 return fake.setAsyncTimeoutArgsForCall[i].arg1 1029 } 1030 1031 func (fake *FakeRepository) SetTrace(arg1 string) { 1032 fake.setTraceMutex.Lock() 1033 defer fake.setTraceMutex.Unlock() 1034 fake.setTraceArgsForCall = append(fake.setTraceArgsForCall, struct { 1035 arg1 string 1036 }{arg1}) 1037 if fake.SetTraceStub != nil { 1038 fake.SetTraceStub(arg1) 1039 } 1040 } 1041 1042 func (fake *FakeRepository) SetTraceCallCount() int { 1043 fake.setTraceMutex.RLock() 1044 defer fake.setTraceMutex.RUnlock() 1045 return len(fake.setTraceArgsForCall) 1046 } 1047 1048 func (fake *FakeRepository) SetTraceArgsForCall(i int) string { 1049 fake.setTraceMutex.RLock() 1050 defer fake.setTraceMutex.RUnlock() 1051 return fake.setTraceArgsForCall[i].arg1 1052 } 1053 1054 func (fake *FakeRepository) SetColorEnabled(arg1 string) { 1055 fake.setColorEnabledMutex.Lock() 1056 defer fake.setColorEnabledMutex.Unlock() 1057 fake.setColorEnabledArgsForCall = append(fake.setColorEnabledArgsForCall, struct { 1058 arg1 string 1059 }{arg1}) 1060 if fake.SetColorEnabledStub != nil { 1061 fake.SetColorEnabledStub(arg1) 1062 } 1063 } 1064 1065 func (fake *FakeRepository) SetColorEnabledCallCount() int { 1066 fake.setColorEnabledMutex.RLock() 1067 defer fake.setColorEnabledMutex.RUnlock() 1068 return len(fake.setColorEnabledArgsForCall) 1069 } 1070 1071 func (fake *FakeRepository) SetColorEnabledArgsForCall(i int) string { 1072 fake.setColorEnabledMutex.RLock() 1073 defer fake.setColorEnabledMutex.RUnlock() 1074 return fake.setColorEnabledArgsForCall[i].arg1 1075 } 1076 1077 func (fake *FakeRepository) SetLocale(arg1 string) { 1078 fake.setLocaleMutex.Lock() 1079 defer fake.setLocaleMutex.Unlock() 1080 fake.setLocaleArgsForCall = append(fake.setLocaleArgsForCall, struct { 1081 arg1 string 1082 }{arg1}) 1083 if fake.SetLocaleStub != nil { 1084 fake.SetLocaleStub(arg1) 1085 } 1086 } 1087 1088 func (fake *FakeRepository) SetLocaleCallCount() int { 1089 fake.setLocaleMutex.RLock() 1090 defer fake.setLocaleMutex.RUnlock() 1091 return len(fake.setLocaleArgsForCall) 1092 } 1093 1094 func (fake *FakeRepository) SetLocaleArgsForCall(i int) string { 1095 fake.setLocaleMutex.RLock() 1096 defer fake.setLocaleMutex.RUnlock() 1097 return fake.setLocaleArgsForCall[i].arg1 1098 } 1099 1100 func (fake *FakeRepository) SetPlugin(arg1 string, arg2 string) { 1101 fake.setPluginMutex.Lock() 1102 defer fake.setPluginMutex.Unlock() 1103 fake.setPluginArgsForCall = append(fake.setPluginArgsForCall, struct { 1104 arg1 string 1105 arg2 string 1106 }{arg1, arg2}) 1107 if fake.SetPluginStub != nil { 1108 fake.SetPluginStub(arg1, arg2) 1109 } 1110 } 1111 1112 func (fake *FakeRepository) SetPluginCallCount() int { 1113 fake.setPluginMutex.RLock() 1114 defer fake.setPluginMutex.RUnlock() 1115 return len(fake.setPluginArgsForCall) 1116 } 1117 1118 func (fake *FakeRepository) SetPluginArgsForCall(i int) (string, string) { 1119 fake.setPluginMutex.RLock() 1120 defer fake.setPluginMutex.RUnlock() 1121 return fake.setPluginArgsForCall[i].arg1, fake.setPluginArgsForCall[i].arg2 1122 } 1123 1124 func (fake *FakeRepository) Close() { 1125 fake.closeMutex.Lock() 1126 defer fake.closeMutex.Unlock() 1127 fake.closeArgsForCall = append(fake.closeArgsForCall, struct{}{}) 1128 if fake.CloseStub != nil { 1129 fake.CloseStub() 1130 } 1131 } 1132 1133 func (fake *FakeRepository) CloseCallCount() int { 1134 fake.closeMutex.RLock() 1135 defer fake.closeMutex.RUnlock() 1136 return len(fake.closeArgsForCall) 1137 } 1138 1139 var _ Repository = new(FakeRepository)