1// Code generated by counterfeiter. DO NOT EDIT. 2package gclientfakes 3 4import ( 5 "sync" 6 7 "code.cloudfoundry.org/garden" 8 "github.com/concourse/concourse/atc/worker/gclient" 9) 10 11type FakeClient struct { 12 BulkInfoStub func([]string) (map[string]garden.ContainerInfoEntry, error) 13 bulkInfoMutex sync.RWMutex 14 bulkInfoArgsForCall []struct { 15 arg1 []string 16 } 17 bulkInfoReturns struct { 18 result1 map[string]garden.ContainerInfoEntry 19 result2 error 20 } 21 bulkInfoReturnsOnCall map[int]struct { 22 result1 map[string]garden.ContainerInfoEntry 23 result2 error 24 } 25 BulkMetricsStub func([]string) (map[string]garden.ContainerMetricsEntry, error) 26 bulkMetricsMutex sync.RWMutex 27 bulkMetricsArgsForCall []struct { 28 arg1 []string 29 } 30 bulkMetricsReturns struct { 31 result1 map[string]garden.ContainerMetricsEntry 32 result2 error 33 } 34 bulkMetricsReturnsOnCall map[int]struct { 35 result1 map[string]garden.ContainerMetricsEntry 36 result2 error 37 } 38 CapacityStub func() (garden.Capacity, error) 39 capacityMutex sync.RWMutex 40 capacityArgsForCall []struct { 41 } 42 capacityReturns struct { 43 result1 garden.Capacity 44 result2 error 45 } 46 capacityReturnsOnCall map[int]struct { 47 result1 garden.Capacity 48 result2 error 49 } 50 ContainersStub func(garden.Properties) ([]gclient.Container, error) 51 containersMutex sync.RWMutex 52 containersArgsForCall []struct { 53 arg1 garden.Properties 54 } 55 containersReturns struct { 56 result1 []gclient.Container 57 result2 error 58 } 59 containersReturnsOnCall map[int]struct { 60 result1 []gclient.Container 61 result2 error 62 } 63 CreateStub func(garden.ContainerSpec) (gclient.Container, error) 64 createMutex sync.RWMutex 65 createArgsForCall []struct { 66 arg1 garden.ContainerSpec 67 } 68 createReturns struct { 69 result1 gclient.Container 70 result2 error 71 } 72 createReturnsOnCall map[int]struct { 73 result1 gclient.Container 74 result2 error 75 } 76 DestroyStub func(string) error 77 destroyMutex sync.RWMutex 78 destroyArgsForCall []struct { 79 arg1 string 80 } 81 destroyReturns struct { 82 result1 error 83 } 84 destroyReturnsOnCall map[int]struct { 85 result1 error 86 } 87 LookupStub func(string) (gclient.Container, error) 88 lookupMutex sync.RWMutex 89 lookupArgsForCall []struct { 90 arg1 string 91 } 92 lookupReturns struct { 93 result1 gclient.Container 94 result2 error 95 } 96 lookupReturnsOnCall map[int]struct { 97 result1 gclient.Container 98 result2 error 99 } 100 PingStub func() error 101 pingMutex sync.RWMutex 102 pingArgsForCall []struct { 103 } 104 pingReturns struct { 105 result1 error 106 } 107 pingReturnsOnCall map[int]struct { 108 result1 error 109 } 110 invocations map[string][][]interface{} 111 invocationsMutex sync.RWMutex 112} 113 114func (fake *FakeClient) BulkInfo(arg1 []string) (map[string]garden.ContainerInfoEntry, error) { 115 var arg1Copy []string 116 if arg1 != nil { 117 arg1Copy = make([]string, len(arg1)) 118 copy(arg1Copy, arg1) 119 } 120 fake.bulkInfoMutex.Lock() 121 ret, specificReturn := fake.bulkInfoReturnsOnCall[len(fake.bulkInfoArgsForCall)] 122 fake.bulkInfoArgsForCall = append(fake.bulkInfoArgsForCall, struct { 123 arg1 []string 124 }{arg1Copy}) 125 fake.recordInvocation("BulkInfo", []interface{}{arg1Copy}) 126 fake.bulkInfoMutex.Unlock() 127 if fake.BulkInfoStub != nil { 128 return fake.BulkInfoStub(arg1) 129 } 130 if specificReturn { 131 return ret.result1, ret.result2 132 } 133 fakeReturns := fake.bulkInfoReturns 134 return fakeReturns.result1, fakeReturns.result2 135} 136 137func (fake *FakeClient) BulkInfoCallCount() int { 138 fake.bulkInfoMutex.RLock() 139 defer fake.bulkInfoMutex.RUnlock() 140 return len(fake.bulkInfoArgsForCall) 141} 142 143func (fake *FakeClient) BulkInfoCalls(stub func([]string) (map[string]garden.ContainerInfoEntry, error)) { 144 fake.bulkInfoMutex.Lock() 145 defer fake.bulkInfoMutex.Unlock() 146 fake.BulkInfoStub = stub 147} 148 149func (fake *FakeClient) BulkInfoArgsForCall(i int) []string { 150 fake.bulkInfoMutex.RLock() 151 defer fake.bulkInfoMutex.RUnlock() 152 argsForCall := fake.bulkInfoArgsForCall[i] 153 return argsForCall.arg1 154} 155 156func (fake *FakeClient) BulkInfoReturns(result1 map[string]garden.ContainerInfoEntry, result2 error) { 157 fake.bulkInfoMutex.Lock() 158 defer fake.bulkInfoMutex.Unlock() 159 fake.BulkInfoStub = nil 160 fake.bulkInfoReturns = struct { 161 result1 map[string]garden.ContainerInfoEntry 162 result2 error 163 }{result1, result2} 164} 165 166func (fake *FakeClient) BulkInfoReturnsOnCall(i int, result1 map[string]garden.ContainerInfoEntry, result2 error) { 167 fake.bulkInfoMutex.Lock() 168 defer fake.bulkInfoMutex.Unlock() 169 fake.BulkInfoStub = nil 170 if fake.bulkInfoReturnsOnCall == nil { 171 fake.bulkInfoReturnsOnCall = make(map[int]struct { 172 result1 map[string]garden.ContainerInfoEntry 173 result2 error 174 }) 175 } 176 fake.bulkInfoReturnsOnCall[i] = struct { 177 result1 map[string]garden.ContainerInfoEntry 178 result2 error 179 }{result1, result2} 180} 181 182func (fake *FakeClient) BulkMetrics(arg1 []string) (map[string]garden.ContainerMetricsEntry, error) { 183 var arg1Copy []string 184 if arg1 != nil { 185 arg1Copy = make([]string, len(arg1)) 186 copy(arg1Copy, arg1) 187 } 188 fake.bulkMetricsMutex.Lock() 189 ret, specificReturn := fake.bulkMetricsReturnsOnCall[len(fake.bulkMetricsArgsForCall)] 190 fake.bulkMetricsArgsForCall = append(fake.bulkMetricsArgsForCall, struct { 191 arg1 []string 192 }{arg1Copy}) 193 fake.recordInvocation("BulkMetrics", []interface{}{arg1Copy}) 194 fake.bulkMetricsMutex.Unlock() 195 if fake.BulkMetricsStub != nil { 196 return fake.BulkMetricsStub(arg1) 197 } 198 if specificReturn { 199 return ret.result1, ret.result2 200 } 201 fakeReturns := fake.bulkMetricsReturns 202 return fakeReturns.result1, fakeReturns.result2 203} 204 205func (fake *FakeClient) BulkMetricsCallCount() int { 206 fake.bulkMetricsMutex.RLock() 207 defer fake.bulkMetricsMutex.RUnlock() 208 return len(fake.bulkMetricsArgsForCall) 209} 210 211func (fake *FakeClient) BulkMetricsCalls(stub func([]string) (map[string]garden.ContainerMetricsEntry, error)) { 212 fake.bulkMetricsMutex.Lock() 213 defer fake.bulkMetricsMutex.Unlock() 214 fake.BulkMetricsStub = stub 215} 216 217func (fake *FakeClient) BulkMetricsArgsForCall(i int) []string { 218 fake.bulkMetricsMutex.RLock() 219 defer fake.bulkMetricsMutex.RUnlock() 220 argsForCall := fake.bulkMetricsArgsForCall[i] 221 return argsForCall.arg1 222} 223 224func (fake *FakeClient) BulkMetricsReturns(result1 map[string]garden.ContainerMetricsEntry, result2 error) { 225 fake.bulkMetricsMutex.Lock() 226 defer fake.bulkMetricsMutex.Unlock() 227 fake.BulkMetricsStub = nil 228 fake.bulkMetricsReturns = struct { 229 result1 map[string]garden.ContainerMetricsEntry 230 result2 error 231 }{result1, result2} 232} 233 234func (fake *FakeClient) BulkMetricsReturnsOnCall(i int, result1 map[string]garden.ContainerMetricsEntry, result2 error) { 235 fake.bulkMetricsMutex.Lock() 236 defer fake.bulkMetricsMutex.Unlock() 237 fake.BulkMetricsStub = nil 238 if fake.bulkMetricsReturnsOnCall == nil { 239 fake.bulkMetricsReturnsOnCall = make(map[int]struct { 240 result1 map[string]garden.ContainerMetricsEntry 241 result2 error 242 }) 243 } 244 fake.bulkMetricsReturnsOnCall[i] = struct { 245 result1 map[string]garden.ContainerMetricsEntry 246 result2 error 247 }{result1, result2} 248} 249 250func (fake *FakeClient) Capacity() (garden.Capacity, error) { 251 fake.capacityMutex.Lock() 252 ret, specificReturn := fake.capacityReturnsOnCall[len(fake.capacityArgsForCall)] 253 fake.capacityArgsForCall = append(fake.capacityArgsForCall, struct { 254 }{}) 255 fake.recordInvocation("Capacity", []interface{}{}) 256 fake.capacityMutex.Unlock() 257 if fake.CapacityStub != nil { 258 return fake.CapacityStub() 259 } 260 if specificReturn { 261 return ret.result1, ret.result2 262 } 263 fakeReturns := fake.capacityReturns 264 return fakeReturns.result1, fakeReturns.result2 265} 266 267func (fake *FakeClient) CapacityCallCount() int { 268 fake.capacityMutex.RLock() 269 defer fake.capacityMutex.RUnlock() 270 return len(fake.capacityArgsForCall) 271} 272 273func (fake *FakeClient) CapacityCalls(stub func() (garden.Capacity, error)) { 274 fake.capacityMutex.Lock() 275 defer fake.capacityMutex.Unlock() 276 fake.CapacityStub = stub 277} 278 279func (fake *FakeClient) CapacityReturns(result1 garden.Capacity, result2 error) { 280 fake.capacityMutex.Lock() 281 defer fake.capacityMutex.Unlock() 282 fake.CapacityStub = nil 283 fake.capacityReturns = struct { 284 result1 garden.Capacity 285 result2 error 286 }{result1, result2} 287} 288 289func (fake *FakeClient) CapacityReturnsOnCall(i int, result1 garden.Capacity, result2 error) { 290 fake.capacityMutex.Lock() 291 defer fake.capacityMutex.Unlock() 292 fake.CapacityStub = nil 293 if fake.capacityReturnsOnCall == nil { 294 fake.capacityReturnsOnCall = make(map[int]struct { 295 result1 garden.Capacity 296 result2 error 297 }) 298 } 299 fake.capacityReturnsOnCall[i] = struct { 300 result1 garden.Capacity 301 result2 error 302 }{result1, result2} 303} 304 305func (fake *FakeClient) Containers(arg1 garden.Properties) ([]gclient.Container, error) { 306 fake.containersMutex.Lock() 307 ret, specificReturn := fake.containersReturnsOnCall[len(fake.containersArgsForCall)] 308 fake.containersArgsForCall = append(fake.containersArgsForCall, struct { 309 arg1 garden.Properties 310 }{arg1}) 311 fake.recordInvocation("Containers", []interface{}{arg1}) 312 fake.containersMutex.Unlock() 313 if fake.ContainersStub != nil { 314 return fake.ContainersStub(arg1) 315 } 316 if specificReturn { 317 return ret.result1, ret.result2 318 } 319 fakeReturns := fake.containersReturns 320 return fakeReturns.result1, fakeReturns.result2 321} 322 323func (fake *FakeClient) ContainersCallCount() int { 324 fake.containersMutex.RLock() 325 defer fake.containersMutex.RUnlock() 326 return len(fake.containersArgsForCall) 327} 328 329func (fake *FakeClient) ContainersCalls(stub func(garden.Properties) ([]gclient.Container, error)) { 330 fake.containersMutex.Lock() 331 defer fake.containersMutex.Unlock() 332 fake.ContainersStub = stub 333} 334 335func (fake *FakeClient) ContainersArgsForCall(i int) garden.Properties { 336 fake.containersMutex.RLock() 337 defer fake.containersMutex.RUnlock() 338 argsForCall := fake.containersArgsForCall[i] 339 return argsForCall.arg1 340} 341 342func (fake *FakeClient) ContainersReturns(result1 []gclient.Container, result2 error) { 343 fake.containersMutex.Lock() 344 defer fake.containersMutex.Unlock() 345 fake.ContainersStub = nil 346 fake.containersReturns = struct { 347 result1 []gclient.Container 348 result2 error 349 }{result1, result2} 350} 351 352func (fake *FakeClient) ContainersReturnsOnCall(i int, result1 []gclient.Container, result2 error) { 353 fake.containersMutex.Lock() 354 defer fake.containersMutex.Unlock() 355 fake.ContainersStub = nil 356 if fake.containersReturnsOnCall == nil { 357 fake.containersReturnsOnCall = make(map[int]struct { 358 result1 []gclient.Container 359 result2 error 360 }) 361 } 362 fake.containersReturnsOnCall[i] = struct { 363 result1 []gclient.Container 364 result2 error 365 }{result1, result2} 366} 367 368func (fake *FakeClient) Create(arg1 garden.ContainerSpec) (gclient.Container, error) { 369 fake.createMutex.Lock() 370 ret, specificReturn := fake.createReturnsOnCall[len(fake.createArgsForCall)] 371 fake.createArgsForCall = append(fake.createArgsForCall, struct { 372 arg1 garden.ContainerSpec 373 }{arg1}) 374 fake.recordInvocation("Create", []interface{}{arg1}) 375 fake.createMutex.Unlock() 376 if fake.CreateStub != nil { 377 return fake.CreateStub(arg1) 378 } 379 if specificReturn { 380 return ret.result1, ret.result2 381 } 382 fakeReturns := fake.createReturns 383 return fakeReturns.result1, fakeReturns.result2 384} 385 386func (fake *FakeClient) CreateCallCount() int { 387 fake.createMutex.RLock() 388 defer fake.createMutex.RUnlock() 389 return len(fake.createArgsForCall) 390} 391 392func (fake *FakeClient) CreateCalls(stub func(garden.ContainerSpec) (gclient.Container, error)) { 393 fake.createMutex.Lock() 394 defer fake.createMutex.Unlock() 395 fake.CreateStub = stub 396} 397 398func (fake *FakeClient) CreateArgsForCall(i int) garden.ContainerSpec { 399 fake.createMutex.RLock() 400 defer fake.createMutex.RUnlock() 401 argsForCall := fake.createArgsForCall[i] 402 return argsForCall.arg1 403} 404 405func (fake *FakeClient) CreateReturns(result1 gclient.Container, result2 error) { 406 fake.createMutex.Lock() 407 defer fake.createMutex.Unlock() 408 fake.CreateStub = nil 409 fake.createReturns = struct { 410 result1 gclient.Container 411 result2 error 412 }{result1, result2} 413} 414 415func (fake *FakeClient) CreateReturnsOnCall(i int, result1 gclient.Container, result2 error) { 416 fake.createMutex.Lock() 417 defer fake.createMutex.Unlock() 418 fake.CreateStub = nil 419 if fake.createReturnsOnCall == nil { 420 fake.createReturnsOnCall = make(map[int]struct { 421 result1 gclient.Container 422 result2 error 423 }) 424 } 425 fake.createReturnsOnCall[i] = struct { 426 result1 gclient.Container 427 result2 error 428 }{result1, result2} 429} 430 431func (fake *FakeClient) Destroy(arg1 string) error { 432 fake.destroyMutex.Lock() 433 ret, specificReturn := fake.destroyReturnsOnCall[len(fake.destroyArgsForCall)] 434 fake.destroyArgsForCall = append(fake.destroyArgsForCall, struct { 435 arg1 string 436 }{arg1}) 437 fake.recordInvocation("Destroy", []interface{}{arg1}) 438 fake.destroyMutex.Unlock() 439 if fake.DestroyStub != nil { 440 return fake.DestroyStub(arg1) 441 } 442 if specificReturn { 443 return ret.result1 444 } 445 fakeReturns := fake.destroyReturns 446 return fakeReturns.result1 447} 448 449func (fake *FakeClient) DestroyCallCount() int { 450 fake.destroyMutex.RLock() 451 defer fake.destroyMutex.RUnlock() 452 return len(fake.destroyArgsForCall) 453} 454 455func (fake *FakeClient) DestroyCalls(stub func(string) error) { 456 fake.destroyMutex.Lock() 457 defer fake.destroyMutex.Unlock() 458 fake.DestroyStub = stub 459} 460 461func (fake *FakeClient) DestroyArgsForCall(i int) string { 462 fake.destroyMutex.RLock() 463 defer fake.destroyMutex.RUnlock() 464 argsForCall := fake.destroyArgsForCall[i] 465 return argsForCall.arg1 466} 467 468func (fake *FakeClient) DestroyReturns(result1 error) { 469 fake.destroyMutex.Lock() 470 defer fake.destroyMutex.Unlock() 471 fake.DestroyStub = nil 472 fake.destroyReturns = struct { 473 result1 error 474 }{result1} 475} 476 477func (fake *FakeClient) DestroyReturnsOnCall(i int, result1 error) { 478 fake.destroyMutex.Lock() 479 defer fake.destroyMutex.Unlock() 480 fake.DestroyStub = nil 481 if fake.destroyReturnsOnCall == nil { 482 fake.destroyReturnsOnCall = make(map[int]struct { 483 result1 error 484 }) 485 } 486 fake.destroyReturnsOnCall[i] = struct { 487 result1 error 488 }{result1} 489} 490 491func (fake *FakeClient) Lookup(arg1 string) (gclient.Container, error) { 492 fake.lookupMutex.Lock() 493 ret, specificReturn := fake.lookupReturnsOnCall[len(fake.lookupArgsForCall)] 494 fake.lookupArgsForCall = append(fake.lookupArgsForCall, struct { 495 arg1 string 496 }{arg1}) 497 fake.recordInvocation("Lookup", []interface{}{arg1}) 498 fake.lookupMutex.Unlock() 499 if fake.LookupStub != nil { 500 return fake.LookupStub(arg1) 501 } 502 if specificReturn { 503 return ret.result1, ret.result2 504 } 505 fakeReturns := fake.lookupReturns 506 return fakeReturns.result1, fakeReturns.result2 507} 508 509func (fake *FakeClient) LookupCallCount() int { 510 fake.lookupMutex.RLock() 511 defer fake.lookupMutex.RUnlock() 512 return len(fake.lookupArgsForCall) 513} 514 515func (fake *FakeClient) LookupCalls(stub func(string) (gclient.Container, error)) { 516 fake.lookupMutex.Lock() 517 defer fake.lookupMutex.Unlock() 518 fake.LookupStub = stub 519} 520 521func (fake *FakeClient) LookupArgsForCall(i int) string { 522 fake.lookupMutex.RLock() 523 defer fake.lookupMutex.RUnlock() 524 argsForCall := fake.lookupArgsForCall[i] 525 return argsForCall.arg1 526} 527 528func (fake *FakeClient) LookupReturns(result1 gclient.Container, result2 error) { 529 fake.lookupMutex.Lock() 530 defer fake.lookupMutex.Unlock() 531 fake.LookupStub = nil 532 fake.lookupReturns = struct { 533 result1 gclient.Container 534 result2 error 535 }{result1, result2} 536} 537 538func (fake *FakeClient) LookupReturnsOnCall(i int, result1 gclient.Container, result2 error) { 539 fake.lookupMutex.Lock() 540 defer fake.lookupMutex.Unlock() 541 fake.LookupStub = nil 542 if fake.lookupReturnsOnCall == nil { 543 fake.lookupReturnsOnCall = make(map[int]struct { 544 result1 gclient.Container 545 result2 error 546 }) 547 } 548 fake.lookupReturnsOnCall[i] = struct { 549 result1 gclient.Container 550 result2 error 551 }{result1, result2} 552} 553 554func (fake *FakeClient) Ping() error { 555 fake.pingMutex.Lock() 556 ret, specificReturn := fake.pingReturnsOnCall[len(fake.pingArgsForCall)] 557 fake.pingArgsForCall = append(fake.pingArgsForCall, struct { 558 }{}) 559 fake.recordInvocation("Ping", []interface{}{}) 560 fake.pingMutex.Unlock() 561 if fake.PingStub != nil { 562 return fake.PingStub() 563 } 564 if specificReturn { 565 return ret.result1 566 } 567 fakeReturns := fake.pingReturns 568 return fakeReturns.result1 569} 570 571func (fake *FakeClient) PingCallCount() int { 572 fake.pingMutex.RLock() 573 defer fake.pingMutex.RUnlock() 574 return len(fake.pingArgsForCall) 575} 576 577func (fake *FakeClient) PingCalls(stub func() error) { 578 fake.pingMutex.Lock() 579 defer fake.pingMutex.Unlock() 580 fake.PingStub = stub 581} 582 583func (fake *FakeClient) PingReturns(result1 error) { 584 fake.pingMutex.Lock() 585 defer fake.pingMutex.Unlock() 586 fake.PingStub = nil 587 fake.pingReturns = struct { 588 result1 error 589 }{result1} 590} 591 592func (fake *FakeClient) PingReturnsOnCall(i int, result1 error) { 593 fake.pingMutex.Lock() 594 defer fake.pingMutex.Unlock() 595 fake.PingStub = nil 596 if fake.pingReturnsOnCall == nil { 597 fake.pingReturnsOnCall = make(map[int]struct { 598 result1 error 599 }) 600 } 601 fake.pingReturnsOnCall[i] = struct { 602 result1 error 603 }{result1} 604} 605 606func (fake *FakeClient) Invocations() map[string][][]interface{} { 607 fake.invocationsMutex.RLock() 608 defer fake.invocationsMutex.RUnlock() 609 fake.bulkInfoMutex.RLock() 610 defer fake.bulkInfoMutex.RUnlock() 611 fake.bulkMetricsMutex.RLock() 612 defer fake.bulkMetricsMutex.RUnlock() 613 fake.capacityMutex.RLock() 614 defer fake.capacityMutex.RUnlock() 615 fake.containersMutex.RLock() 616 defer fake.containersMutex.RUnlock() 617 fake.createMutex.RLock() 618 defer fake.createMutex.RUnlock() 619 fake.destroyMutex.RLock() 620 defer fake.destroyMutex.RUnlock() 621 fake.lookupMutex.RLock() 622 defer fake.lookupMutex.RUnlock() 623 fake.pingMutex.RLock() 624 defer fake.pingMutex.RUnlock() 625 copiedInvocations := map[string][][]interface{}{} 626 for key, value := range fake.invocations { 627 copiedInvocations[key] = value 628 } 629 return copiedInvocations 630} 631 632func (fake *FakeClient) recordInvocation(key string, args []interface{}) { 633 fake.invocationsMutex.Lock() 634 defer fake.invocationsMutex.Unlock() 635 if fake.invocations == nil { 636 fake.invocations = map[string][][]interface{}{} 637 } 638 if fake.invocations[key] == nil { 639 fake.invocations[key] = [][]interface{}{} 640 } 641 fake.invocations[key] = append(fake.invocations[key], args) 642} 643 644var _ gclient.Client = new(FakeClient) 645