1// Code generated by counterfeiter. DO NOT EDIT. 2package fakes 3 4import ( 5 "sync" 6 7 "istio.io/istio/pilot/pkg/model" 8 "istio.io/istio/pkg/config/schema/collection" 9 "istio.io/istio/pkg/config/schema/resource" 10 "istio.io/pkg/ledger" 11) 12 13type ConfigStoreCache struct { 14 CreateStub func(model.Config) (string, error) 15 createMutex sync.RWMutex 16 createArgsForCall []struct { 17 arg1 model.Config 18 } 19 createReturns struct { 20 result1 string 21 result2 error 22 } 23 createReturnsOnCall map[int]struct { 24 result1 string 25 result2 error 26 } 27 DeleteStub func(resource.GroupVersionKind, string, string) error 28 deleteMutex sync.RWMutex 29 deleteArgsForCall []struct { 30 arg1 resource.GroupVersionKind 31 arg2 string 32 arg3 string 33 } 34 deleteReturns struct { 35 result1 error 36 } 37 deleteReturnsOnCall map[int]struct { 38 result1 error 39 } 40 GetStub func(resource.GroupVersionKind, string, string) *model.Config 41 getMutex sync.RWMutex 42 getArgsForCall []struct { 43 arg1 resource.GroupVersionKind 44 arg2 string 45 arg3 string 46 } 47 getReturns struct { 48 result1 *model.Config 49 } 50 getReturnsOnCall map[int]struct { 51 result1 *model.Config 52 } 53 GetLedgerStub func() ledger.Ledger 54 getLedgerMutex sync.RWMutex 55 getLedgerArgsForCall []struct { 56 } 57 getLedgerReturns struct { 58 result1 ledger.Ledger 59 } 60 getLedgerReturnsOnCall map[int]struct { 61 result1 ledger.Ledger 62 } 63 GetResourceAtVersionStub func(string, string) (string, error) 64 getResourceAtVersionMutex sync.RWMutex 65 getResourceAtVersionArgsForCall []struct { 66 arg1 string 67 arg2 string 68 } 69 getResourceAtVersionReturns struct { 70 result1 string 71 result2 error 72 } 73 getResourceAtVersionReturnsOnCall map[int]struct { 74 result1 string 75 result2 error 76 } 77 HasSyncedStub func() bool 78 hasSyncedMutex sync.RWMutex 79 hasSyncedArgsForCall []struct { 80 } 81 hasSyncedReturns struct { 82 result1 bool 83 } 84 hasSyncedReturnsOnCall map[int]struct { 85 result1 bool 86 } 87 ListStub func(resource.GroupVersionKind, string) ([]model.Config, error) 88 listMutex sync.RWMutex 89 listArgsForCall []struct { 90 arg1 resource.GroupVersionKind 91 arg2 string 92 } 93 listReturns struct { 94 result1 []model.Config 95 result2 error 96 } 97 listReturnsOnCall map[int]struct { 98 result1 []model.Config 99 result2 error 100 } 101 RegisterEventHandlerStub func(resource.GroupVersionKind, func(model.Config, model.Config, model.Event)) 102 registerEventHandlerMutex sync.RWMutex 103 registerEventHandlerArgsForCall []struct { 104 arg1 resource.GroupVersionKind 105 arg2 func(model.Config, model.Config, model.Event) 106 } 107 RunStub func(<-chan struct{}) 108 runMutex sync.RWMutex 109 runArgsForCall []struct { 110 arg1 <-chan struct{} 111 } 112 SchemasStub func() collection.Schemas 113 schemasMutex sync.RWMutex 114 schemasArgsForCall []struct { 115 } 116 schemasReturns struct { 117 result1 collection.Schemas 118 } 119 schemasReturnsOnCall map[int]struct { 120 result1 collection.Schemas 121 } 122 SetLedgerStub func(ledger.Ledger) error 123 setLedgerMutex sync.RWMutex 124 setLedgerArgsForCall []struct { 125 arg1 ledger.Ledger 126 } 127 setLedgerReturns struct { 128 result1 error 129 } 130 setLedgerReturnsOnCall map[int]struct { 131 result1 error 132 } 133 UpdateStub func(model.Config) (string, error) 134 updateMutex sync.RWMutex 135 updateArgsForCall []struct { 136 arg1 model.Config 137 } 138 updateReturns struct { 139 result1 string 140 result2 error 141 } 142 updateReturnsOnCall map[int]struct { 143 result1 string 144 result2 error 145 } 146 VersionStub func() string 147 versionMutex sync.RWMutex 148 versionArgsForCall []struct { 149 } 150 versionReturns struct { 151 result1 string 152 } 153 versionReturnsOnCall map[int]struct { 154 result1 string 155 } 156 invocations map[string][][]interface{} 157 invocationsMutex sync.RWMutex 158} 159 160func (fake *ConfigStoreCache) Create(arg1 model.Config) (string, error) { 161 fake.createMutex.Lock() 162 ret, specificReturn := fake.createReturnsOnCall[len(fake.createArgsForCall)] 163 fake.createArgsForCall = append(fake.createArgsForCall, struct { 164 arg1 model.Config 165 }{arg1}) 166 fake.recordInvocation("Create", []interface{}{arg1}) 167 fake.createMutex.Unlock() 168 if fake.CreateStub != nil { 169 return fake.CreateStub(arg1) 170 } 171 if specificReturn { 172 return ret.result1, ret.result2 173 } 174 fakeReturns := fake.createReturns 175 return fakeReturns.result1, fakeReturns.result2 176} 177 178func (fake *ConfigStoreCache) CreateCallCount() int { 179 fake.createMutex.RLock() 180 defer fake.createMutex.RUnlock() 181 return len(fake.createArgsForCall) 182} 183 184func (fake *ConfigStoreCache) CreateCalls(stub func(model.Config) (string, error)) { 185 fake.createMutex.Lock() 186 defer fake.createMutex.Unlock() 187 fake.CreateStub = stub 188} 189 190func (fake *ConfigStoreCache) CreateArgsForCall(i int) model.Config { 191 fake.createMutex.RLock() 192 defer fake.createMutex.RUnlock() 193 argsForCall := fake.createArgsForCall[i] 194 return argsForCall.arg1 195} 196 197func (fake *ConfigStoreCache) CreateReturns(result1 string, result2 error) { 198 fake.createMutex.Lock() 199 defer fake.createMutex.Unlock() 200 fake.CreateStub = nil 201 fake.createReturns = struct { 202 result1 string 203 result2 error 204 }{result1, result2} 205} 206 207func (fake *ConfigStoreCache) CreateReturnsOnCall(i int, result1 string, result2 error) { 208 fake.createMutex.Lock() 209 defer fake.createMutex.Unlock() 210 fake.CreateStub = nil 211 if fake.createReturnsOnCall == nil { 212 fake.createReturnsOnCall = make(map[int]struct { 213 result1 string 214 result2 error 215 }) 216 } 217 fake.createReturnsOnCall[i] = struct { 218 result1 string 219 result2 error 220 }{result1, result2} 221} 222 223func (fake *ConfigStoreCache) Delete(arg1 resource.GroupVersionKind, arg2 string, arg3 string) error { 224 fake.deleteMutex.Lock() 225 ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)] 226 fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct { 227 arg1 resource.GroupVersionKind 228 arg2 string 229 arg3 string 230 }{arg1, arg2, arg3}) 231 fake.recordInvocation("Delete", []interface{}{arg1, arg2, arg3}) 232 fake.deleteMutex.Unlock() 233 if fake.DeleteStub != nil { 234 return fake.DeleteStub(arg1, arg2, arg3) 235 } 236 if specificReturn { 237 return ret.result1 238 } 239 fakeReturns := fake.deleteReturns 240 return fakeReturns.result1 241} 242 243func (fake *ConfigStoreCache) DeleteCallCount() int { 244 fake.deleteMutex.RLock() 245 defer fake.deleteMutex.RUnlock() 246 return len(fake.deleteArgsForCall) 247} 248 249func (fake *ConfigStoreCache) DeleteCalls(stub func(resource.GroupVersionKind, string, string) error) { 250 fake.deleteMutex.Lock() 251 defer fake.deleteMutex.Unlock() 252 fake.DeleteStub = stub 253} 254 255func (fake *ConfigStoreCache) DeleteArgsForCall(i int) (resource.GroupVersionKind, string, string) { 256 fake.deleteMutex.RLock() 257 defer fake.deleteMutex.RUnlock() 258 argsForCall := fake.deleteArgsForCall[i] 259 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 260} 261 262func (fake *ConfigStoreCache) DeleteReturns(result1 error) { 263 fake.deleteMutex.Lock() 264 defer fake.deleteMutex.Unlock() 265 fake.DeleteStub = nil 266 fake.deleteReturns = struct { 267 result1 error 268 }{result1} 269} 270 271func (fake *ConfigStoreCache) DeleteReturnsOnCall(i int, result1 error) { 272 fake.deleteMutex.Lock() 273 defer fake.deleteMutex.Unlock() 274 fake.DeleteStub = nil 275 if fake.deleteReturnsOnCall == nil { 276 fake.deleteReturnsOnCall = make(map[int]struct { 277 result1 error 278 }) 279 } 280 fake.deleteReturnsOnCall[i] = struct { 281 result1 error 282 }{result1} 283} 284 285func (fake *ConfigStoreCache) Get(arg1 resource.GroupVersionKind, arg2 string, arg3 string) *model.Config { 286 fake.getMutex.Lock() 287 ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)] 288 fake.getArgsForCall = append(fake.getArgsForCall, struct { 289 arg1 resource.GroupVersionKind 290 arg2 string 291 arg3 string 292 }{arg1, arg2, arg3}) 293 fake.recordInvocation("Get", []interface{}{arg1, arg2, arg3}) 294 fake.getMutex.Unlock() 295 if fake.GetStub != nil { 296 return fake.GetStub(arg1, arg2, arg3) 297 } 298 if specificReturn { 299 return ret.result1 300 } 301 fakeReturns := fake.getReturns 302 return fakeReturns.result1 303} 304 305func (fake *ConfigStoreCache) GetCallCount() int { 306 fake.getMutex.RLock() 307 defer fake.getMutex.RUnlock() 308 return len(fake.getArgsForCall) 309} 310 311func (fake *ConfigStoreCache) GetCalls(stub func(resource.GroupVersionKind, string, string) *model.Config) { 312 fake.getMutex.Lock() 313 defer fake.getMutex.Unlock() 314 fake.GetStub = stub 315} 316 317func (fake *ConfigStoreCache) GetArgsForCall(i int) (resource.GroupVersionKind, string, string) { 318 fake.getMutex.RLock() 319 defer fake.getMutex.RUnlock() 320 argsForCall := fake.getArgsForCall[i] 321 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 322} 323 324func (fake *ConfigStoreCache) GetReturns(result1 *model.Config) { 325 fake.getMutex.Lock() 326 defer fake.getMutex.Unlock() 327 fake.GetStub = nil 328 fake.getReturns = struct { 329 result1 *model.Config 330 }{result1} 331} 332 333func (fake *ConfigStoreCache) GetReturnsOnCall(i int, result1 *model.Config) { 334 fake.getMutex.Lock() 335 defer fake.getMutex.Unlock() 336 fake.GetStub = nil 337 if fake.getReturnsOnCall == nil { 338 fake.getReturnsOnCall = make(map[int]struct { 339 result1 *model.Config 340 }) 341 } 342 fake.getReturnsOnCall[i] = struct { 343 result1 *model.Config 344 }{result1} 345} 346 347func (fake *ConfigStoreCache) GetLedger() ledger.Ledger { 348 fake.getLedgerMutex.Lock() 349 ret, specificReturn := fake.getLedgerReturnsOnCall[len(fake.getLedgerArgsForCall)] 350 fake.getLedgerArgsForCall = append(fake.getLedgerArgsForCall, struct { 351 }{}) 352 fake.recordInvocation("GetLedger", []interface{}{}) 353 fake.getLedgerMutex.Unlock() 354 if fake.GetLedgerStub != nil { 355 return fake.GetLedgerStub() 356 } 357 if specificReturn { 358 return ret.result1 359 } 360 fakeReturns := fake.getLedgerReturns 361 return fakeReturns.result1 362} 363 364func (fake *ConfigStoreCache) GetLedgerCallCount() int { 365 fake.getLedgerMutex.RLock() 366 defer fake.getLedgerMutex.RUnlock() 367 return len(fake.getLedgerArgsForCall) 368} 369 370func (fake *ConfigStoreCache) GetLedgerCalls(stub func() ledger.Ledger) { 371 fake.getLedgerMutex.Lock() 372 defer fake.getLedgerMutex.Unlock() 373 fake.GetLedgerStub = stub 374} 375 376func (fake *ConfigStoreCache) GetLedgerReturns(result1 ledger.Ledger) { 377 fake.getLedgerMutex.Lock() 378 defer fake.getLedgerMutex.Unlock() 379 fake.GetLedgerStub = nil 380 fake.getLedgerReturns = struct { 381 result1 ledger.Ledger 382 }{result1} 383} 384 385func (fake *ConfigStoreCache) GetLedgerReturnsOnCall(i int, result1 ledger.Ledger) { 386 fake.getLedgerMutex.Lock() 387 defer fake.getLedgerMutex.Unlock() 388 fake.GetLedgerStub = nil 389 if fake.getLedgerReturnsOnCall == nil { 390 fake.getLedgerReturnsOnCall = make(map[int]struct { 391 result1 ledger.Ledger 392 }) 393 } 394 fake.getLedgerReturnsOnCall[i] = struct { 395 result1 ledger.Ledger 396 }{result1} 397} 398 399func (fake *ConfigStoreCache) GetResourceAtVersion(arg1 string, arg2 string) (string, error) { 400 fake.getResourceAtVersionMutex.Lock() 401 ret, specificReturn := fake.getResourceAtVersionReturnsOnCall[len(fake.getResourceAtVersionArgsForCall)] 402 fake.getResourceAtVersionArgsForCall = append(fake.getResourceAtVersionArgsForCall, struct { 403 arg1 string 404 arg2 string 405 }{arg1, arg2}) 406 fake.recordInvocation("GetResourceAtVersion", []interface{}{arg1, arg2}) 407 fake.getResourceAtVersionMutex.Unlock() 408 if fake.GetResourceAtVersionStub != nil { 409 return fake.GetResourceAtVersionStub(arg1, arg2) 410 } 411 if specificReturn { 412 return ret.result1, ret.result2 413 } 414 fakeReturns := fake.getResourceAtVersionReturns 415 return fakeReturns.result1, fakeReturns.result2 416} 417 418func (fake *ConfigStoreCache) GetResourceAtVersionCallCount() int { 419 fake.getResourceAtVersionMutex.RLock() 420 defer fake.getResourceAtVersionMutex.RUnlock() 421 return len(fake.getResourceAtVersionArgsForCall) 422} 423 424func (fake *ConfigStoreCache) GetResourceAtVersionCalls(stub func(string, string) (string, error)) { 425 fake.getResourceAtVersionMutex.Lock() 426 defer fake.getResourceAtVersionMutex.Unlock() 427 fake.GetResourceAtVersionStub = stub 428} 429 430func (fake *ConfigStoreCache) GetResourceAtVersionArgsForCall(i int) (string, string) { 431 fake.getResourceAtVersionMutex.RLock() 432 defer fake.getResourceAtVersionMutex.RUnlock() 433 argsForCall := fake.getResourceAtVersionArgsForCall[i] 434 return argsForCall.arg1, argsForCall.arg2 435} 436 437func (fake *ConfigStoreCache) GetResourceAtVersionReturns(result1 string, result2 error) { 438 fake.getResourceAtVersionMutex.Lock() 439 defer fake.getResourceAtVersionMutex.Unlock() 440 fake.GetResourceAtVersionStub = nil 441 fake.getResourceAtVersionReturns = struct { 442 result1 string 443 result2 error 444 }{result1, result2} 445} 446 447func (fake *ConfigStoreCache) GetResourceAtVersionReturnsOnCall(i int, result1 string, result2 error) { 448 fake.getResourceAtVersionMutex.Lock() 449 defer fake.getResourceAtVersionMutex.Unlock() 450 fake.GetResourceAtVersionStub = nil 451 if fake.getResourceAtVersionReturnsOnCall == nil { 452 fake.getResourceAtVersionReturnsOnCall = make(map[int]struct { 453 result1 string 454 result2 error 455 }) 456 } 457 fake.getResourceAtVersionReturnsOnCall[i] = struct { 458 result1 string 459 result2 error 460 }{result1, result2} 461} 462 463func (fake *ConfigStoreCache) HasSynced() bool { 464 fake.hasSyncedMutex.Lock() 465 ret, specificReturn := fake.hasSyncedReturnsOnCall[len(fake.hasSyncedArgsForCall)] 466 fake.hasSyncedArgsForCall = append(fake.hasSyncedArgsForCall, struct { 467 }{}) 468 fake.recordInvocation("HasSynced", []interface{}{}) 469 fake.hasSyncedMutex.Unlock() 470 if fake.HasSyncedStub != nil { 471 return fake.HasSyncedStub() 472 } 473 if specificReturn { 474 return ret.result1 475 } 476 fakeReturns := fake.hasSyncedReturns 477 return fakeReturns.result1 478} 479 480func (fake *ConfigStoreCache) HasSyncedCallCount() int { 481 fake.hasSyncedMutex.RLock() 482 defer fake.hasSyncedMutex.RUnlock() 483 return len(fake.hasSyncedArgsForCall) 484} 485 486func (fake *ConfigStoreCache) HasSyncedCalls(stub func() bool) { 487 fake.hasSyncedMutex.Lock() 488 defer fake.hasSyncedMutex.Unlock() 489 fake.HasSyncedStub = stub 490} 491 492func (fake *ConfigStoreCache) HasSyncedReturns(result1 bool) { 493 fake.hasSyncedMutex.Lock() 494 defer fake.hasSyncedMutex.Unlock() 495 fake.HasSyncedStub = nil 496 fake.hasSyncedReturns = struct { 497 result1 bool 498 }{result1} 499} 500 501func (fake *ConfigStoreCache) HasSyncedReturnsOnCall(i int, result1 bool) { 502 fake.hasSyncedMutex.Lock() 503 defer fake.hasSyncedMutex.Unlock() 504 fake.HasSyncedStub = nil 505 if fake.hasSyncedReturnsOnCall == nil { 506 fake.hasSyncedReturnsOnCall = make(map[int]struct { 507 result1 bool 508 }) 509 } 510 fake.hasSyncedReturnsOnCall[i] = struct { 511 result1 bool 512 }{result1} 513} 514 515func (fake *ConfigStoreCache) List(arg1 resource.GroupVersionKind, arg2 string) ([]model.Config, error) { 516 fake.listMutex.Lock() 517 ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)] 518 fake.listArgsForCall = append(fake.listArgsForCall, struct { 519 arg1 resource.GroupVersionKind 520 arg2 string 521 }{arg1, arg2}) 522 fake.recordInvocation("List", []interface{}{arg1, arg2}) 523 fake.listMutex.Unlock() 524 if fake.ListStub != nil { 525 return fake.ListStub(arg1, arg2) 526 } 527 if specificReturn { 528 return ret.result1, ret.result2 529 } 530 fakeReturns := fake.listReturns 531 return fakeReturns.result1, fakeReturns.result2 532} 533 534func (fake *ConfigStoreCache) ListCallCount() int { 535 fake.listMutex.RLock() 536 defer fake.listMutex.RUnlock() 537 return len(fake.listArgsForCall) 538} 539 540func (fake *ConfigStoreCache) ListCalls(stub func(resource.GroupVersionKind, string) ([]model.Config, error)) { 541 fake.listMutex.Lock() 542 defer fake.listMutex.Unlock() 543 fake.ListStub = stub 544} 545 546func (fake *ConfigStoreCache) ListArgsForCall(i int) (resource.GroupVersionKind, string) { 547 fake.listMutex.RLock() 548 defer fake.listMutex.RUnlock() 549 argsForCall := fake.listArgsForCall[i] 550 return argsForCall.arg1, argsForCall.arg2 551} 552 553func (fake *ConfigStoreCache) ListReturns(result1 []model.Config, result2 error) { 554 fake.listMutex.Lock() 555 defer fake.listMutex.Unlock() 556 fake.ListStub = nil 557 fake.listReturns = struct { 558 result1 []model.Config 559 result2 error 560 }{result1, result2} 561} 562 563func (fake *ConfigStoreCache) ListReturnsOnCall(i int, result1 []model.Config, result2 error) { 564 fake.listMutex.Lock() 565 defer fake.listMutex.Unlock() 566 fake.ListStub = nil 567 if fake.listReturnsOnCall == nil { 568 fake.listReturnsOnCall = make(map[int]struct { 569 result1 []model.Config 570 result2 error 571 }) 572 } 573 fake.listReturnsOnCall[i] = struct { 574 result1 []model.Config 575 result2 error 576 }{result1, result2} 577} 578 579func (fake *ConfigStoreCache) RegisterEventHandler(arg1 resource.GroupVersionKind, arg2 func(model.Config, model.Config, model.Event)) { 580 fake.registerEventHandlerMutex.Lock() 581 fake.registerEventHandlerArgsForCall = append(fake.registerEventHandlerArgsForCall, struct { 582 arg1 resource.GroupVersionKind 583 arg2 func(model.Config, model.Config, model.Event) 584 }{arg1, arg2}) 585 fake.recordInvocation("RegisterEventHandler", []interface{}{arg1, arg2}) 586 fake.registerEventHandlerMutex.Unlock() 587 if fake.RegisterEventHandlerStub != nil { 588 fake.RegisterEventHandlerStub(arg1, arg2) 589 } 590} 591 592func (fake *ConfigStoreCache) RegisterEventHandlerCallCount() int { 593 fake.registerEventHandlerMutex.RLock() 594 defer fake.registerEventHandlerMutex.RUnlock() 595 return len(fake.registerEventHandlerArgsForCall) 596} 597 598func (fake *ConfigStoreCache) RegisterEventHandlerCalls(stub func(resource.GroupVersionKind, func(model.Config, model.Config, model.Event))) { 599 fake.registerEventHandlerMutex.Lock() 600 defer fake.registerEventHandlerMutex.Unlock() 601 fake.RegisterEventHandlerStub = stub 602} 603 604func (fake *ConfigStoreCache) RegisterEventHandlerArgsForCall(i int) (resource.GroupVersionKind, func(model.Config, model.Config, model.Event)) { 605 fake.registerEventHandlerMutex.RLock() 606 defer fake.registerEventHandlerMutex.RUnlock() 607 argsForCall := fake.registerEventHandlerArgsForCall[i] 608 return argsForCall.arg1, argsForCall.arg2 609} 610 611func (fake *ConfigStoreCache) Run(arg1 <-chan struct{}) { 612 fake.runMutex.Lock() 613 fake.runArgsForCall = append(fake.runArgsForCall, struct { 614 arg1 <-chan struct{} 615 }{arg1}) 616 fake.recordInvocation("Run", []interface{}{arg1}) 617 fake.runMutex.Unlock() 618 if fake.RunStub != nil { 619 fake.RunStub(arg1) 620 } 621} 622 623func (fake *ConfigStoreCache) RunCallCount() int { 624 fake.runMutex.RLock() 625 defer fake.runMutex.RUnlock() 626 return len(fake.runArgsForCall) 627} 628 629func (fake *ConfigStoreCache) RunCalls(stub func(<-chan struct{})) { 630 fake.runMutex.Lock() 631 defer fake.runMutex.Unlock() 632 fake.RunStub = stub 633} 634 635func (fake *ConfigStoreCache) RunArgsForCall(i int) <-chan struct{} { 636 fake.runMutex.RLock() 637 defer fake.runMutex.RUnlock() 638 argsForCall := fake.runArgsForCall[i] 639 return argsForCall.arg1 640} 641 642func (fake *ConfigStoreCache) Schemas() collection.Schemas { 643 fake.schemasMutex.Lock() 644 ret, specificReturn := fake.schemasReturnsOnCall[len(fake.schemasArgsForCall)] 645 fake.schemasArgsForCall = append(fake.schemasArgsForCall, struct { 646 }{}) 647 fake.recordInvocation("Schemas", []interface{}{}) 648 fake.schemasMutex.Unlock() 649 if fake.SchemasStub != nil { 650 return fake.SchemasStub() 651 } 652 if specificReturn { 653 return ret.result1 654 } 655 fakeReturns := fake.schemasReturns 656 return fakeReturns.result1 657} 658 659func (fake *ConfigStoreCache) SchemasCallCount() int { 660 fake.schemasMutex.RLock() 661 defer fake.schemasMutex.RUnlock() 662 return len(fake.schemasArgsForCall) 663} 664 665func (fake *ConfigStoreCache) SchemasCalls(stub func() collection.Schemas) { 666 fake.schemasMutex.Lock() 667 defer fake.schemasMutex.Unlock() 668 fake.SchemasStub = stub 669} 670 671func (fake *ConfigStoreCache) SchemasReturns(result1 collection.Schemas) { 672 fake.schemasMutex.Lock() 673 defer fake.schemasMutex.Unlock() 674 fake.SchemasStub = nil 675 fake.schemasReturns = struct { 676 result1 collection.Schemas 677 }{result1} 678} 679 680func (fake *ConfigStoreCache) SchemasReturnsOnCall(i int, result1 collection.Schemas) { 681 fake.schemasMutex.Lock() 682 defer fake.schemasMutex.Unlock() 683 fake.SchemasStub = nil 684 if fake.schemasReturnsOnCall == nil { 685 fake.schemasReturnsOnCall = make(map[int]struct { 686 result1 collection.Schemas 687 }) 688 } 689 fake.schemasReturnsOnCall[i] = struct { 690 result1 collection.Schemas 691 }{result1} 692} 693 694func (fake *ConfigStoreCache) SetLedger(arg1 ledger.Ledger) error { 695 fake.setLedgerMutex.Lock() 696 ret, specificReturn := fake.setLedgerReturnsOnCall[len(fake.setLedgerArgsForCall)] 697 fake.setLedgerArgsForCall = append(fake.setLedgerArgsForCall, struct { 698 arg1 ledger.Ledger 699 }{arg1}) 700 fake.recordInvocation("SetLedger", []interface{}{arg1}) 701 fake.setLedgerMutex.Unlock() 702 if fake.SetLedgerStub != nil { 703 return fake.SetLedgerStub(arg1) 704 } 705 if specificReturn { 706 return ret.result1 707 } 708 fakeReturns := fake.setLedgerReturns 709 return fakeReturns.result1 710} 711 712func (fake *ConfigStoreCache) SetLedgerCallCount() int { 713 fake.setLedgerMutex.RLock() 714 defer fake.setLedgerMutex.RUnlock() 715 return len(fake.setLedgerArgsForCall) 716} 717 718func (fake *ConfigStoreCache) SetLedgerCalls(stub func(ledger.Ledger) error) { 719 fake.setLedgerMutex.Lock() 720 defer fake.setLedgerMutex.Unlock() 721 fake.SetLedgerStub = stub 722} 723 724func (fake *ConfigStoreCache) SetLedgerArgsForCall(i int) ledger.Ledger { 725 fake.setLedgerMutex.RLock() 726 defer fake.setLedgerMutex.RUnlock() 727 argsForCall := fake.setLedgerArgsForCall[i] 728 return argsForCall.arg1 729} 730 731func (fake *ConfigStoreCache) SetLedgerReturns(result1 error) { 732 fake.setLedgerMutex.Lock() 733 defer fake.setLedgerMutex.Unlock() 734 fake.SetLedgerStub = nil 735 fake.setLedgerReturns = struct { 736 result1 error 737 }{result1} 738} 739 740func (fake *ConfigStoreCache) SetLedgerReturnsOnCall(i int, result1 error) { 741 fake.setLedgerMutex.Lock() 742 defer fake.setLedgerMutex.Unlock() 743 fake.SetLedgerStub = nil 744 if fake.setLedgerReturnsOnCall == nil { 745 fake.setLedgerReturnsOnCall = make(map[int]struct { 746 result1 error 747 }) 748 } 749 fake.setLedgerReturnsOnCall[i] = struct { 750 result1 error 751 }{result1} 752} 753 754func (fake *ConfigStoreCache) Update(arg1 model.Config) (string, error) { 755 fake.updateMutex.Lock() 756 ret, specificReturn := fake.updateReturnsOnCall[len(fake.updateArgsForCall)] 757 fake.updateArgsForCall = append(fake.updateArgsForCall, struct { 758 arg1 model.Config 759 }{arg1}) 760 fake.recordInvocation("Update", []interface{}{arg1}) 761 fake.updateMutex.Unlock() 762 if fake.UpdateStub != nil { 763 return fake.UpdateStub(arg1) 764 } 765 if specificReturn { 766 return ret.result1, ret.result2 767 } 768 fakeReturns := fake.updateReturns 769 return fakeReturns.result1, fakeReturns.result2 770} 771 772func (fake *ConfigStoreCache) UpdateCallCount() int { 773 fake.updateMutex.RLock() 774 defer fake.updateMutex.RUnlock() 775 return len(fake.updateArgsForCall) 776} 777 778func (fake *ConfigStoreCache) UpdateCalls(stub func(model.Config) (string, error)) { 779 fake.updateMutex.Lock() 780 defer fake.updateMutex.Unlock() 781 fake.UpdateStub = stub 782} 783 784func (fake *ConfigStoreCache) UpdateArgsForCall(i int) model.Config { 785 fake.updateMutex.RLock() 786 defer fake.updateMutex.RUnlock() 787 argsForCall := fake.updateArgsForCall[i] 788 return argsForCall.arg1 789} 790 791func (fake *ConfigStoreCache) UpdateReturns(result1 string, result2 error) { 792 fake.updateMutex.Lock() 793 defer fake.updateMutex.Unlock() 794 fake.UpdateStub = nil 795 fake.updateReturns = struct { 796 result1 string 797 result2 error 798 }{result1, result2} 799} 800 801func (fake *ConfigStoreCache) UpdateReturnsOnCall(i int, result1 string, result2 error) { 802 fake.updateMutex.Lock() 803 defer fake.updateMutex.Unlock() 804 fake.UpdateStub = nil 805 if fake.updateReturnsOnCall == nil { 806 fake.updateReturnsOnCall = make(map[int]struct { 807 result1 string 808 result2 error 809 }) 810 } 811 fake.updateReturnsOnCall[i] = struct { 812 result1 string 813 result2 error 814 }{result1, result2} 815} 816 817func (fake *ConfigStoreCache) Version() string { 818 fake.versionMutex.Lock() 819 ret, specificReturn := fake.versionReturnsOnCall[len(fake.versionArgsForCall)] 820 fake.versionArgsForCall = append(fake.versionArgsForCall, struct { 821 }{}) 822 fake.recordInvocation("Version", []interface{}{}) 823 fake.versionMutex.Unlock() 824 if fake.VersionStub != nil { 825 return fake.VersionStub() 826 } 827 if specificReturn { 828 return ret.result1 829 } 830 fakeReturns := fake.versionReturns 831 return fakeReturns.result1 832} 833 834func (fake *ConfigStoreCache) VersionCallCount() int { 835 fake.versionMutex.RLock() 836 defer fake.versionMutex.RUnlock() 837 return len(fake.versionArgsForCall) 838} 839 840func (fake *ConfigStoreCache) VersionCalls(stub func() string) { 841 fake.versionMutex.Lock() 842 defer fake.versionMutex.Unlock() 843 fake.VersionStub = stub 844} 845 846func (fake *ConfigStoreCache) VersionReturns(result1 string) { 847 fake.versionMutex.Lock() 848 defer fake.versionMutex.Unlock() 849 fake.VersionStub = nil 850 fake.versionReturns = struct { 851 result1 string 852 }{result1} 853} 854 855func (fake *ConfigStoreCache) VersionReturnsOnCall(i int, result1 string) { 856 fake.versionMutex.Lock() 857 defer fake.versionMutex.Unlock() 858 fake.VersionStub = nil 859 if fake.versionReturnsOnCall == nil { 860 fake.versionReturnsOnCall = make(map[int]struct { 861 result1 string 862 }) 863 } 864 fake.versionReturnsOnCall[i] = struct { 865 result1 string 866 }{result1} 867} 868 869func (fake *ConfigStoreCache) Invocations() map[string][][]interface{} { 870 fake.invocationsMutex.RLock() 871 defer fake.invocationsMutex.RUnlock() 872 fake.createMutex.RLock() 873 defer fake.createMutex.RUnlock() 874 fake.deleteMutex.RLock() 875 defer fake.deleteMutex.RUnlock() 876 fake.getMutex.RLock() 877 defer fake.getMutex.RUnlock() 878 fake.getLedgerMutex.RLock() 879 defer fake.getLedgerMutex.RUnlock() 880 fake.getResourceAtVersionMutex.RLock() 881 defer fake.getResourceAtVersionMutex.RUnlock() 882 fake.hasSyncedMutex.RLock() 883 defer fake.hasSyncedMutex.RUnlock() 884 fake.listMutex.RLock() 885 defer fake.listMutex.RUnlock() 886 fake.registerEventHandlerMutex.RLock() 887 defer fake.registerEventHandlerMutex.RUnlock() 888 fake.runMutex.RLock() 889 defer fake.runMutex.RUnlock() 890 fake.schemasMutex.RLock() 891 defer fake.schemasMutex.RUnlock() 892 fake.setLedgerMutex.RLock() 893 defer fake.setLedgerMutex.RUnlock() 894 fake.updateMutex.RLock() 895 defer fake.updateMutex.RUnlock() 896 fake.versionMutex.RLock() 897 defer fake.versionMutex.RUnlock() 898 copiedInvocations := map[string][][]interface{}{} 899 for key, value := range fake.invocations { 900 copiedInvocations[key] = value 901 } 902 return copiedInvocations 903} 904 905func (fake *ConfigStoreCache) recordInvocation(key string, args []interface{}) { 906 fake.invocationsMutex.Lock() 907 defer fake.invocationsMutex.Unlock() 908 if fake.invocations == nil { 909 fake.invocations = map[string][][]interface{}{} 910 } 911 if fake.invocations[key] == nil { 912 fake.invocations[key] = [][]interface{}{} 913 } 914 fake.invocations[key] = append(fake.invocations[key], args) 915} 916 917var _ model.ConfigStoreCache = new(ConfigStoreCache) 918