diff --git a/pkg/cloudprovider/providers/gce/cloud/gen.go b/pkg/cloudprovider/providers/gce/cloud/gen.go new file mode 100644 index 00000000000..ef7a2c62eaf --- /dev/null +++ b/pkg/cloudprovider/providers/gce/cloud/gen.go @@ -0,0 +1,10351 @@ +/* +Copyright 2018 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// This file was generated by "go run gen/main.go > gen.go". Do not edit +// directly. + +package cloud + +import ( + "context" + "fmt" + "net/http" + "sync" + + "github.com/golang/glog" + "google.golang.org/api/googleapi" + + "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/filter" + "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta" + + alpha "google.golang.org/api/compute/v0.alpha" + beta "google.golang.org/api/compute/v0.beta" + ga "google.golang.org/api/compute/v1" +) + +// Cloud is an interface for the GCE compute API. +type Cloud interface { + Addresses() Addresses + AlphaAddresses() AlphaAddresses + BetaAddresses() BetaAddresses + GlobalAddresses() GlobalAddresses + BackendServices() BackendServices + AlphaBackendServices() AlphaBackendServices + AlphaRegionBackendServices() AlphaRegionBackendServices + Disks() Disks + AlphaDisks() AlphaDisks + AlphaRegionDisks() AlphaRegionDisks + Firewalls() Firewalls + ForwardingRules() ForwardingRules + AlphaForwardingRules() AlphaForwardingRules + GlobalForwardingRules() GlobalForwardingRules + HealthChecks() HealthChecks + AlphaHealthChecks() AlphaHealthChecks + HttpHealthChecks() HttpHealthChecks + HttpsHealthChecks() HttpsHealthChecks + InstanceGroups() InstanceGroups + Instances() Instances + BetaInstances() BetaInstances + AlphaInstances() AlphaInstances + AlphaNetworkEndpointGroups() AlphaNetworkEndpointGroups + Projects() Projects + Regions() Regions + Routes() Routes + SslCertificates() SslCertificates + TargetHttpProxies() TargetHttpProxies + TargetHttpsProxies() TargetHttpsProxies + TargetPools() TargetPools + UrlMaps() UrlMaps + Zones() Zones +} + +// NewGCE returns a GCE. +func NewGCE(s *Service) *GCE { + g := &GCE{ + gceAddresses: &GCEAddresses{s}, + gceAlphaAddresses: &GCEAlphaAddresses{s}, + gceBetaAddresses: &GCEBetaAddresses{s}, + gceGlobalAddresses: &GCEGlobalAddresses{s}, + gceBackendServices: &GCEBackendServices{s}, + gceAlphaBackendServices: &GCEAlphaBackendServices{s}, + gceAlphaRegionBackendServices: &GCEAlphaRegionBackendServices{s}, + gceDisks: &GCEDisks{s}, + gceAlphaDisks: &GCEAlphaDisks{s}, + gceAlphaRegionDisks: &GCEAlphaRegionDisks{s}, + gceFirewalls: &GCEFirewalls{s}, + gceForwardingRules: &GCEForwardingRules{s}, + gceAlphaForwardingRules: &GCEAlphaForwardingRules{s}, + gceGlobalForwardingRules: &GCEGlobalForwardingRules{s}, + gceHealthChecks: &GCEHealthChecks{s}, + gceAlphaHealthChecks: &GCEAlphaHealthChecks{s}, + gceHttpHealthChecks: &GCEHttpHealthChecks{s}, + gceHttpsHealthChecks: &GCEHttpsHealthChecks{s}, + gceInstanceGroups: &GCEInstanceGroups{s}, + gceInstances: &GCEInstances{s}, + gceBetaInstances: &GCEBetaInstances{s}, + gceAlphaInstances: &GCEAlphaInstances{s}, + gceAlphaNetworkEndpointGroups: &GCEAlphaNetworkEndpointGroups{s}, + gceProjects: &GCEProjects{s}, + gceRegions: &GCERegions{s}, + gceRoutes: &GCERoutes{s}, + gceSslCertificates: &GCESslCertificates{s}, + gceTargetHttpProxies: &GCETargetHttpProxies{s}, + gceTargetHttpsProxies: &GCETargetHttpsProxies{s}, + gceTargetPools: &GCETargetPools{s}, + gceUrlMaps: &GCEUrlMaps{s}, + gceZones: &GCEZones{s}, + } + return g +} + +// GCE implements Cloud. +var _ Cloud = (*GCE)(nil) + +// GCE is the golang adapter for the compute APIs. +type GCE struct { + gceAddresses *GCEAddresses + gceAlphaAddresses *GCEAlphaAddresses + gceBetaAddresses *GCEBetaAddresses + gceGlobalAddresses *GCEGlobalAddresses + gceBackendServices *GCEBackendServices + gceAlphaBackendServices *GCEAlphaBackendServices + gceAlphaRegionBackendServices *GCEAlphaRegionBackendServices + gceDisks *GCEDisks + gceAlphaDisks *GCEAlphaDisks + gceAlphaRegionDisks *GCEAlphaRegionDisks + gceFirewalls *GCEFirewalls + gceForwardingRules *GCEForwardingRules + gceAlphaForwardingRules *GCEAlphaForwardingRules + gceGlobalForwardingRules *GCEGlobalForwardingRules + gceHealthChecks *GCEHealthChecks + gceAlphaHealthChecks *GCEAlphaHealthChecks + gceHttpHealthChecks *GCEHttpHealthChecks + gceHttpsHealthChecks *GCEHttpsHealthChecks + gceInstanceGroups *GCEInstanceGroups + gceInstances *GCEInstances + gceBetaInstances *GCEBetaInstances + gceAlphaInstances *GCEAlphaInstances + gceAlphaNetworkEndpointGroups *GCEAlphaNetworkEndpointGroups + gceProjects *GCEProjects + gceRegions *GCERegions + gceRoutes *GCERoutes + gceSslCertificates *GCESslCertificates + gceTargetHttpProxies *GCETargetHttpProxies + gceTargetHttpsProxies *GCETargetHttpsProxies + gceTargetPools *GCETargetPools + gceUrlMaps *GCEUrlMaps + gceZones *GCEZones +} + +func (gce *GCE) Addresses() Addresses { + return gce.gceAddresses +} +func (gce *GCE) AlphaAddresses() AlphaAddresses { + return gce.gceAlphaAddresses +} +func (gce *GCE) BetaAddresses() BetaAddresses { + return gce.gceBetaAddresses +} +func (gce *GCE) GlobalAddresses() GlobalAddresses { + return gce.gceGlobalAddresses +} +func (gce *GCE) BackendServices() BackendServices { + return gce.gceBackendServices +} +func (gce *GCE) AlphaBackendServices() AlphaBackendServices { + return gce.gceAlphaBackendServices +} +func (gce *GCE) AlphaRegionBackendServices() AlphaRegionBackendServices { + return gce.gceAlphaRegionBackendServices +} +func (gce *GCE) Disks() Disks { + return gce.gceDisks +} +func (gce *GCE) AlphaDisks() AlphaDisks { + return gce.gceAlphaDisks +} +func (gce *GCE) AlphaRegionDisks() AlphaRegionDisks { + return gce.gceAlphaRegionDisks +} +func (gce *GCE) Firewalls() Firewalls { + return gce.gceFirewalls +} +func (gce *GCE) ForwardingRules() ForwardingRules { + return gce.gceForwardingRules +} +func (gce *GCE) AlphaForwardingRules() AlphaForwardingRules { + return gce.gceAlphaForwardingRules +} +func (gce *GCE) GlobalForwardingRules() GlobalForwardingRules { + return gce.gceGlobalForwardingRules +} +func (gce *GCE) HealthChecks() HealthChecks { + return gce.gceHealthChecks +} +func (gce *GCE) AlphaHealthChecks() AlphaHealthChecks { + return gce.gceAlphaHealthChecks +} +func (gce *GCE) HttpHealthChecks() HttpHealthChecks { + return gce.gceHttpHealthChecks +} +func (gce *GCE) HttpsHealthChecks() HttpsHealthChecks { + return gce.gceHttpsHealthChecks +} +func (gce *GCE) InstanceGroups() InstanceGroups { + return gce.gceInstanceGroups +} +func (gce *GCE) Instances() Instances { + return gce.gceInstances +} +func (gce *GCE) BetaInstances() BetaInstances { + return gce.gceBetaInstances +} +func (gce *GCE) AlphaInstances() AlphaInstances { + return gce.gceAlphaInstances +} +func (gce *GCE) AlphaNetworkEndpointGroups() AlphaNetworkEndpointGroups { + return gce.gceAlphaNetworkEndpointGroups +} +func (gce *GCE) Projects() Projects { + return gce.gceProjects +} +func (gce *GCE) Regions() Regions { + return gce.gceRegions +} +func (gce *GCE) Routes() Routes { + return gce.gceRoutes +} +func (gce *GCE) SslCertificates() SslCertificates { + return gce.gceSslCertificates +} +func (gce *GCE) TargetHttpProxies() TargetHttpProxies { + return gce.gceTargetHttpProxies +} +func (gce *GCE) TargetHttpsProxies() TargetHttpsProxies { + return gce.gceTargetHttpsProxies +} +func (gce *GCE) TargetPools() TargetPools { + return gce.gceTargetPools +} +func (gce *GCE) UrlMaps() UrlMaps { + return gce.gceUrlMaps +} +func (gce *GCE) Zones() Zones { + return gce.gceZones +} + +// NewMockGCE returns a new mock for GCE. +func NewMockGCE() *MockGCE { + mockAddressesObjs := map[meta.Key]*MockAddressesObj{} + mockBackendServicesObjs := map[meta.Key]*MockBackendServicesObj{} + mockDisksObjs := map[meta.Key]*MockDisksObj{} + mockFirewallsObjs := map[meta.Key]*MockFirewallsObj{} + mockForwardingRulesObjs := map[meta.Key]*MockForwardingRulesObj{} + mockGlobalAddressesObjs := map[meta.Key]*MockGlobalAddressesObj{} + mockGlobalForwardingRulesObjs := map[meta.Key]*MockGlobalForwardingRulesObj{} + mockHealthChecksObjs := map[meta.Key]*MockHealthChecksObj{} + mockHttpHealthChecksObjs := map[meta.Key]*MockHttpHealthChecksObj{} + mockHttpsHealthChecksObjs := map[meta.Key]*MockHttpsHealthChecksObj{} + mockInstanceGroupsObjs := map[meta.Key]*MockInstanceGroupsObj{} + mockInstancesObjs := map[meta.Key]*MockInstancesObj{} + mockNetworkEndpointGroupsObjs := map[meta.Key]*MockNetworkEndpointGroupsObj{} + mockProjectsObjs := map[meta.Key]*MockProjectsObj{} + mockRegionBackendServicesObjs := map[meta.Key]*MockRegionBackendServicesObj{} + mockRegionDisksObjs := map[meta.Key]*MockRegionDisksObj{} + mockRegionsObjs := map[meta.Key]*MockRegionsObj{} + mockRoutesObjs := map[meta.Key]*MockRoutesObj{} + mockSslCertificatesObjs := map[meta.Key]*MockSslCertificatesObj{} + mockTargetHttpProxiesObjs := map[meta.Key]*MockTargetHttpProxiesObj{} + mockTargetHttpsProxiesObjs := map[meta.Key]*MockTargetHttpsProxiesObj{} + mockTargetPoolsObjs := map[meta.Key]*MockTargetPoolsObj{} + mockUrlMapsObjs := map[meta.Key]*MockUrlMapsObj{} + mockZonesObjs := map[meta.Key]*MockZonesObj{} + + mock := &MockGCE{ + MockAddresses: NewMockAddresses(mockAddressesObjs), + MockAlphaAddresses: NewMockAlphaAddresses(mockAddressesObjs), + MockBetaAddresses: NewMockBetaAddresses(mockAddressesObjs), + MockGlobalAddresses: NewMockGlobalAddresses(mockGlobalAddressesObjs), + MockBackendServices: NewMockBackendServices(mockBackendServicesObjs), + MockAlphaBackendServices: NewMockAlphaBackendServices(mockBackendServicesObjs), + MockAlphaRegionBackendServices: NewMockAlphaRegionBackendServices(mockRegionBackendServicesObjs), + MockDisks: NewMockDisks(mockDisksObjs), + MockAlphaDisks: NewMockAlphaDisks(mockDisksObjs), + MockAlphaRegionDisks: NewMockAlphaRegionDisks(mockRegionDisksObjs), + MockFirewalls: NewMockFirewalls(mockFirewallsObjs), + MockForwardingRules: NewMockForwardingRules(mockForwardingRulesObjs), + MockAlphaForwardingRules: NewMockAlphaForwardingRules(mockForwardingRulesObjs), + MockGlobalForwardingRules: NewMockGlobalForwardingRules(mockGlobalForwardingRulesObjs), + MockHealthChecks: NewMockHealthChecks(mockHealthChecksObjs), + MockAlphaHealthChecks: NewMockAlphaHealthChecks(mockHealthChecksObjs), + MockHttpHealthChecks: NewMockHttpHealthChecks(mockHttpHealthChecksObjs), + MockHttpsHealthChecks: NewMockHttpsHealthChecks(mockHttpsHealthChecksObjs), + MockInstanceGroups: NewMockInstanceGroups(mockInstanceGroupsObjs), + MockInstances: NewMockInstances(mockInstancesObjs), + MockBetaInstances: NewMockBetaInstances(mockInstancesObjs), + MockAlphaInstances: NewMockAlphaInstances(mockInstancesObjs), + MockAlphaNetworkEndpointGroups: NewMockAlphaNetworkEndpointGroups(mockNetworkEndpointGroupsObjs), + MockProjects: NewMockProjects(mockProjectsObjs), + MockRegions: NewMockRegions(mockRegionsObjs), + MockRoutes: NewMockRoutes(mockRoutesObjs), + MockSslCertificates: NewMockSslCertificates(mockSslCertificatesObjs), + MockTargetHttpProxies: NewMockTargetHttpProxies(mockTargetHttpProxiesObjs), + MockTargetHttpsProxies: NewMockTargetHttpsProxies(mockTargetHttpsProxiesObjs), + MockTargetPools: NewMockTargetPools(mockTargetPoolsObjs), + MockUrlMaps: NewMockUrlMaps(mockUrlMapsObjs), + MockZones: NewMockZones(mockZonesObjs), + } + return mock +} + +// MockGCE implements Cloud. +var _ Cloud = (*MockGCE)(nil) + +// MockGCE is the mock for the compute API. +type MockGCE struct { + MockAddresses *MockAddresses + MockAlphaAddresses *MockAlphaAddresses + MockBetaAddresses *MockBetaAddresses + MockGlobalAddresses *MockGlobalAddresses + MockBackendServices *MockBackendServices + MockAlphaBackendServices *MockAlphaBackendServices + MockAlphaRegionBackendServices *MockAlphaRegionBackendServices + MockDisks *MockDisks + MockAlphaDisks *MockAlphaDisks + MockAlphaRegionDisks *MockAlphaRegionDisks + MockFirewalls *MockFirewalls + MockForwardingRules *MockForwardingRules + MockAlphaForwardingRules *MockAlphaForwardingRules + MockGlobalForwardingRules *MockGlobalForwardingRules + MockHealthChecks *MockHealthChecks + MockAlphaHealthChecks *MockAlphaHealthChecks + MockHttpHealthChecks *MockHttpHealthChecks + MockHttpsHealthChecks *MockHttpsHealthChecks + MockInstanceGroups *MockInstanceGroups + MockInstances *MockInstances + MockBetaInstances *MockBetaInstances + MockAlphaInstances *MockAlphaInstances + MockAlphaNetworkEndpointGroups *MockAlphaNetworkEndpointGroups + MockProjects *MockProjects + MockRegions *MockRegions + MockRoutes *MockRoutes + MockSslCertificates *MockSslCertificates + MockTargetHttpProxies *MockTargetHttpProxies + MockTargetHttpsProxies *MockTargetHttpsProxies + MockTargetPools *MockTargetPools + MockUrlMaps *MockUrlMaps + MockZones *MockZones +} + +func (mock *MockGCE) Addresses() Addresses { + return mock.MockAddresses +} + +func (mock *MockGCE) AlphaAddresses() AlphaAddresses { + return mock.MockAlphaAddresses +} + +func (mock *MockGCE) BetaAddresses() BetaAddresses { + return mock.MockBetaAddresses +} + +func (mock *MockGCE) GlobalAddresses() GlobalAddresses { + return mock.MockGlobalAddresses +} + +func (mock *MockGCE) BackendServices() BackendServices { + return mock.MockBackendServices +} + +func (mock *MockGCE) AlphaBackendServices() AlphaBackendServices { + return mock.MockAlphaBackendServices +} + +func (mock *MockGCE) AlphaRegionBackendServices() AlphaRegionBackendServices { + return mock.MockAlphaRegionBackendServices +} + +func (mock *MockGCE) Disks() Disks { + return mock.MockDisks +} + +func (mock *MockGCE) AlphaDisks() AlphaDisks { + return mock.MockAlphaDisks +} + +func (mock *MockGCE) AlphaRegionDisks() AlphaRegionDisks { + return mock.MockAlphaRegionDisks +} + +func (mock *MockGCE) Firewalls() Firewalls { + return mock.MockFirewalls +} + +func (mock *MockGCE) ForwardingRules() ForwardingRules { + return mock.MockForwardingRules +} + +func (mock *MockGCE) AlphaForwardingRules() AlphaForwardingRules { + return mock.MockAlphaForwardingRules +} + +func (mock *MockGCE) GlobalForwardingRules() GlobalForwardingRules { + return mock.MockGlobalForwardingRules +} + +func (mock *MockGCE) HealthChecks() HealthChecks { + return mock.MockHealthChecks +} + +func (mock *MockGCE) AlphaHealthChecks() AlphaHealthChecks { + return mock.MockAlphaHealthChecks +} + +func (mock *MockGCE) HttpHealthChecks() HttpHealthChecks { + return mock.MockHttpHealthChecks +} + +func (mock *MockGCE) HttpsHealthChecks() HttpsHealthChecks { + return mock.MockHttpsHealthChecks +} + +func (mock *MockGCE) InstanceGroups() InstanceGroups { + return mock.MockInstanceGroups +} + +func (mock *MockGCE) Instances() Instances { + return mock.MockInstances +} + +func (mock *MockGCE) BetaInstances() BetaInstances { + return mock.MockBetaInstances +} + +func (mock *MockGCE) AlphaInstances() AlphaInstances { + return mock.MockAlphaInstances +} + +func (mock *MockGCE) AlphaNetworkEndpointGroups() AlphaNetworkEndpointGroups { + return mock.MockAlphaNetworkEndpointGroups +} + +func (mock *MockGCE) Projects() Projects { + return mock.MockProjects +} + +func (mock *MockGCE) Regions() Regions { + return mock.MockRegions +} + +func (mock *MockGCE) Routes() Routes { + return mock.MockRoutes +} + +func (mock *MockGCE) SslCertificates() SslCertificates { + return mock.MockSslCertificates +} + +func (mock *MockGCE) TargetHttpProxies() TargetHttpProxies { + return mock.MockTargetHttpProxies +} + +func (mock *MockGCE) TargetHttpsProxies() TargetHttpsProxies { + return mock.MockTargetHttpsProxies +} + +func (mock *MockGCE) TargetPools() TargetPools { + return mock.MockTargetPools +} + +func (mock *MockGCE) UrlMaps() UrlMaps { + return mock.MockUrlMaps +} + +func (mock *MockGCE) Zones() Zones { + return mock.MockZones +} + +// MockAddressesObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockAddressesObj struct { + Obj interface{} +} + +// ToAlpha retrieves the given version of the object. +func (m *MockAddressesObj) ToAlpha() *alpha.Address { + if ret, ok := m.Obj.(*alpha.Address); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &alpha.Address{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *alpha.Address via JSON: %v", m.Obj, err) + } + return ret +} + +// ToBeta retrieves the given version of the object. +func (m *MockAddressesObj) ToBeta() *beta.Address { + if ret, ok := m.Obj.(*beta.Address); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &beta.Address{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *beta.Address via JSON: %v", m.Obj, err) + } + return ret +} + +// ToGA retrieves the given version of the object. +func (m *MockAddressesObj) ToGA() *ga.Address { + if ret, ok := m.Obj.(*ga.Address); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.Address{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.Address via JSON: %v", m.Obj, err) + } + return ret +} + +// MockBackendServicesObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockBackendServicesObj struct { + Obj interface{} +} + +// ToAlpha retrieves the given version of the object. +func (m *MockBackendServicesObj) ToAlpha() *alpha.BackendService { + if ret, ok := m.Obj.(*alpha.BackendService); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &alpha.BackendService{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *alpha.BackendService via JSON: %v", m.Obj, err) + } + return ret +} + +// ToGA retrieves the given version of the object. +func (m *MockBackendServicesObj) ToGA() *ga.BackendService { + if ret, ok := m.Obj.(*ga.BackendService); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.BackendService{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.BackendService via JSON: %v", m.Obj, err) + } + return ret +} + +// MockDisksObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockDisksObj struct { + Obj interface{} +} + +// ToAlpha retrieves the given version of the object. +func (m *MockDisksObj) ToAlpha() *alpha.Disk { + if ret, ok := m.Obj.(*alpha.Disk); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &alpha.Disk{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *alpha.Disk via JSON: %v", m.Obj, err) + } + return ret +} + +// ToGA retrieves the given version of the object. +func (m *MockDisksObj) ToGA() *ga.Disk { + if ret, ok := m.Obj.(*ga.Disk); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.Disk{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.Disk via JSON: %v", m.Obj, err) + } + return ret +} + +// MockFirewallsObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockFirewallsObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockFirewallsObj) ToGA() *ga.Firewall { + if ret, ok := m.Obj.(*ga.Firewall); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.Firewall{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.Firewall via JSON: %v", m.Obj, err) + } + return ret +} + +// MockForwardingRulesObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockForwardingRulesObj struct { + Obj interface{} +} + +// ToAlpha retrieves the given version of the object. +func (m *MockForwardingRulesObj) ToAlpha() *alpha.ForwardingRule { + if ret, ok := m.Obj.(*alpha.ForwardingRule); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &alpha.ForwardingRule{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *alpha.ForwardingRule via JSON: %v", m.Obj, err) + } + return ret +} + +// ToGA retrieves the given version of the object. +func (m *MockForwardingRulesObj) ToGA() *ga.ForwardingRule { + if ret, ok := m.Obj.(*ga.ForwardingRule); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.ForwardingRule{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.ForwardingRule via JSON: %v", m.Obj, err) + } + return ret +} + +// MockGlobalAddressesObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockGlobalAddressesObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockGlobalAddressesObj) ToGA() *ga.Address { + if ret, ok := m.Obj.(*ga.Address); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.Address{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.Address via JSON: %v", m.Obj, err) + } + return ret +} + +// MockGlobalForwardingRulesObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockGlobalForwardingRulesObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockGlobalForwardingRulesObj) ToGA() *ga.ForwardingRule { + if ret, ok := m.Obj.(*ga.ForwardingRule); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.ForwardingRule{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.ForwardingRule via JSON: %v", m.Obj, err) + } + return ret +} + +// MockHealthChecksObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockHealthChecksObj struct { + Obj interface{} +} + +// ToAlpha retrieves the given version of the object. +func (m *MockHealthChecksObj) ToAlpha() *alpha.HealthCheck { + if ret, ok := m.Obj.(*alpha.HealthCheck); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &alpha.HealthCheck{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *alpha.HealthCheck via JSON: %v", m.Obj, err) + } + return ret +} + +// ToGA retrieves the given version of the object. +func (m *MockHealthChecksObj) ToGA() *ga.HealthCheck { + if ret, ok := m.Obj.(*ga.HealthCheck); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.HealthCheck{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.HealthCheck via JSON: %v", m.Obj, err) + } + return ret +} + +// MockHttpHealthChecksObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockHttpHealthChecksObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockHttpHealthChecksObj) ToGA() *ga.HttpHealthCheck { + if ret, ok := m.Obj.(*ga.HttpHealthCheck); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.HttpHealthCheck{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.HttpHealthCheck via JSON: %v", m.Obj, err) + } + return ret +} + +// MockHttpsHealthChecksObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockHttpsHealthChecksObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockHttpsHealthChecksObj) ToGA() *ga.HttpsHealthCheck { + if ret, ok := m.Obj.(*ga.HttpsHealthCheck); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.HttpsHealthCheck{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.HttpsHealthCheck via JSON: %v", m.Obj, err) + } + return ret +} + +// MockInstanceGroupsObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockInstanceGroupsObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockInstanceGroupsObj) ToGA() *ga.InstanceGroup { + if ret, ok := m.Obj.(*ga.InstanceGroup); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.InstanceGroup{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.InstanceGroup via JSON: %v", m.Obj, err) + } + return ret +} + +// MockInstancesObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockInstancesObj struct { + Obj interface{} +} + +// ToAlpha retrieves the given version of the object. +func (m *MockInstancesObj) ToAlpha() *alpha.Instance { + if ret, ok := m.Obj.(*alpha.Instance); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &alpha.Instance{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *alpha.Instance via JSON: %v", m.Obj, err) + } + return ret +} + +// ToBeta retrieves the given version of the object. +func (m *MockInstancesObj) ToBeta() *beta.Instance { + if ret, ok := m.Obj.(*beta.Instance); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &beta.Instance{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *beta.Instance via JSON: %v", m.Obj, err) + } + return ret +} + +// ToGA retrieves the given version of the object. +func (m *MockInstancesObj) ToGA() *ga.Instance { + if ret, ok := m.Obj.(*ga.Instance); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.Instance{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.Instance via JSON: %v", m.Obj, err) + } + return ret +} + +// MockNetworkEndpointGroupsObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockNetworkEndpointGroupsObj struct { + Obj interface{} +} + +// ToAlpha retrieves the given version of the object. +func (m *MockNetworkEndpointGroupsObj) ToAlpha() *alpha.NetworkEndpointGroup { + if ret, ok := m.Obj.(*alpha.NetworkEndpointGroup); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &alpha.NetworkEndpointGroup{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *alpha.NetworkEndpointGroup via JSON: %v", m.Obj, err) + } + return ret +} + +// MockProjectsObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockProjectsObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockProjectsObj) ToGA() *ga.Project { + if ret, ok := m.Obj.(*ga.Project); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.Project{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.Project via JSON: %v", m.Obj, err) + } + return ret +} + +// MockRegionBackendServicesObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockRegionBackendServicesObj struct { + Obj interface{} +} + +// ToAlpha retrieves the given version of the object. +func (m *MockRegionBackendServicesObj) ToAlpha() *alpha.BackendService { + if ret, ok := m.Obj.(*alpha.BackendService); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &alpha.BackendService{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *alpha.BackendService via JSON: %v", m.Obj, err) + } + return ret +} + +// MockRegionDisksObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockRegionDisksObj struct { + Obj interface{} +} + +// ToAlpha retrieves the given version of the object. +func (m *MockRegionDisksObj) ToAlpha() *alpha.Disk { + if ret, ok := m.Obj.(*alpha.Disk); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &alpha.Disk{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *alpha.Disk via JSON: %v", m.Obj, err) + } + return ret +} + +// MockRegionsObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockRegionsObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockRegionsObj) ToGA() *ga.Region { + if ret, ok := m.Obj.(*ga.Region); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.Region{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.Region via JSON: %v", m.Obj, err) + } + return ret +} + +// MockRoutesObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockRoutesObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockRoutesObj) ToGA() *ga.Route { + if ret, ok := m.Obj.(*ga.Route); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.Route{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.Route via JSON: %v", m.Obj, err) + } + return ret +} + +// MockSslCertificatesObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockSslCertificatesObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockSslCertificatesObj) ToGA() *ga.SslCertificate { + if ret, ok := m.Obj.(*ga.SslCertificate); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.SslCertificate{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.SslCertificate via JSON: %v", m.Obj, err) + } + return ret +} + +// MockTargetHttpProxiesObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockTargetHttpProxiesObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockTargetHttpProxiesObj) ToGA() *ga.TargetHttpProxy { + if ret, ok := m.Obj.(*ga.TargetHttpProxy); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.TargetHttpProxy{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.TargetHttpProxy via JSON: %v", m.Obj, err) + } + return ret +} + +// MockTargetHttpsProxiesObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockTargetHttpsProxiesObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockTargetHttpsProxiesObj) ToGA() *ga.TargetHttpsProxy { + if ret, ok := m.Obj.(*ga.TargetHttpsProxy); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.TargetHttpsProxy{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.TargetHttpsProxy via JSON: %v", m.Obj, err) + } + return ret +} + +// MockTargetPoolsObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockTargetPoolsObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockTargetPoolsObj) ToGA() *ga.TargetPool { + if ret, ok := m.Obj.(*ga.TargetPool); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.TargetPool{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.TargetPool via JSON: %v", m.Obj, err) + } + return ret +} + +// MockUrlMapsObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockUrlMapsObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockUrlMapsObj) ToGA() *ga.UrlMap { + if ret, ok := m.Obj.(*ga.UrlMap); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.UrlMap{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.UrlMap via JSON: %v", m.Obj, err) + } + return ret +} + +// MockZonesObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockZonesObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockZonesObj) ToGA() *ga.Zone { + if ret, ok := m.Obj.(*ga.Zone); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.Zone{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.Zone via JSON: %v", m.Obj, err) + } + return ret +} + +// Addresses is an interface that allows for mocking of Addresses. +type Addresses interface { + Get(ctx context.Context, key meta.Key) (*ga.Address, error) + List(ctx context.Context, region string, fl *filter.F) ([]*ga.Address, error) + Insert(ctx context.Context, key meta.Key, obj *ga.Address) error + Delete(ctx context.Context, key meta.Key) error +} + +// NewMockAddresses returns a new mock for Addresses. +func NewMockAddresses(objs map[meta.Key]*MockAddressesObj) *MockAddresses { + mock := &MockAddresses{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockAddresses is the mock for Addresses. +type MockAddresses struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockAddressesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockAddresses, ctx context.Context, key meta.Key) (bool, *ga.Address, error) + ListHook func(m *MockAddresses, ctx context.Context, region string, fl *filter.F) (bool, []*ga.Address, error) + InsertHook func(m *MockAddresses, ctx context.Context, key meta.Key, obj *ga.Address) (bool, error) + DeleteHook func(m *MockAddresses, ctx context.Context, key meta.Key) (bool, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockAddresses) Get(ctx context.Context, key meta.Key) (*ga.Address, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAddresses.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockAddresses.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockAddresses.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAddresses %v not found", key), + } + glog.V(5).Infof("MockAddresses.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given region. +func (m *MockAddresses) List(ctx context.Context, region string, fl *filter.F) ([]*ga.Address, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, region, fl); intercept { + glog.V(5).Infof("MockAddresses.List(%v, %q, %v) = [%v items], %v", ctx, region, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockAddresses.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.Address + for key, obj := range m.Objects { + if key.Region != region { + continue + } + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockAddresses.List(%v, %q, %v) = [%v items], nil", ctx, region, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockAddresses) Insert(ctx context.Context, key meta.Key, obj *ga.Address) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockAddresses.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockAddresses.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockAddresses %v exists", key), + } + glog.V(5).Infof("MockAddresses.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "addresses", key) + } + + m.Objects[key] = &MockAddressesObj{obj} + glog.V(5).Infof("MockAddresses.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockAddresses) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAddresses.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockAddresses.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAddresses %v not found", key), + } + glog.V(5).Infof("MockAddresses.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockAddresses.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockAddresses) Obj(o *ga.Address) *MockAddressesObj { + return &MockAddressesObj{o} +} + +// GCEAddresses is a simplifying adapter for the GCE Addresses. +type GCEAddresses struct { + s *Service +} + +// Get the Address named by key. +func (g *GCEAddresses) Get(ctx context.Context, key meta.Key) (*ga.Address, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Addresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "Addresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Addresses.Get(projectID, key.Region, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Address objects. +func (g *GCEAddresses) List(ctx context.Context, region string, fl *filter.F) ([]*ga.Address, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Addresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "Addresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Addresses.List(projectID, region) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.Address + f := func(l *ga.AddressList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert Address with key of value obj. +func (g *GCEAddresses) Insert(ctx context.Context, key meta.Key, obj *ga.Address) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Addresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "Addresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.Addresses.Insert(projectID, key.Region, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the Address referenced by key. +func (g *GCEAddresses) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Addresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "Addresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.Addresses.Delete(projectID, key.Region, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AlphaAddresses is an interface that allows for mocking of Addresses. +type AlphaAddresses interface { + Get(ctx context.Context, key meta.Key) (*alpha.Address, error) + List(ctx context.Context, region string, fl *filter.F) ([]*alpha.Address, error) + Insert(ctx context.Context, key meta.Key, obj *alpha.Address) error + Delete(ctx context.Context, key meta.Key) error +} + +// NewMockAlphaAddresses returns a new mock for Addresses. +func NewMockAlphaAddresses(objs map[meta.Key]*MockAddressesObj) *MockAlphaAddresses { + mock := &MockAlphaAddresses{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockAlphaAddresses is the mock for Addresses. +type MockAlphaAddresses struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockAddressesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockAlphaAddresses, ctx context.Context, key meta.Key) (bool, *alpha.Address, error) + ListHook func(m *MockAlphaAddresses, ctx context.Context, region string, fl *filter.F) (bool, []*alpha.Address, error) + InsertHook func(m *MockAlphaAddresses, ctx context.Context, key meta.Key, obj *alpha.Address) (bool, error) + DeleteHook func(m *MockAlphaAddresses, ctx context.Context, key meta.Key) (bool, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockAlphaAddresses) Get(ctx context.Context, key meta.Key) (*alpha.Address, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaAddresses.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockAlphaAddresses.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToAlpha() + glog.V(5).Infof("MockAlphaAddresses.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaAddresses %v not found", key), + } + glog.V(5).Infof("MockAlphaAddresses.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given region. +func (m *MockAlphaAddresses) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.Address, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, region, fl); intercept { + glog.V(5).Infof("MockAlphaAddresses.List(%v, %q, %v) = [%v items], %v", ctx, region, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockAlphaAddresses.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + + return nil, *m.ListError + } + + var objs []*alpha.Address + for key, obj := range m.Objects { + if key.Region != region { + continue + } + if !fl.Match(obj.ToAlpha()) { + continue + } + objs = append(objs, obj.ToAlpha()) + } + + glog.V(5).Infof("MockAlphaAddresses.List(%v, %q, %v) = [%v items], nil", ctx, region, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockAlphaAddresses) Insert(ctx context.Context, key meta.Key, obj *alpha.Address) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockAlphaAddresses.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockAlphaAddresses.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockAlphaAddresses %v exists", key), + } + glog.V(5).Infof("MockAlphaAddresses.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionAlpha, "mock-project", "addresses", key) + } + + m.Objects[key] = &MockAddressesObj{obj} + glog.V(5).Infof("MockAlphaAddresses.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockAlphaAddresses) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaAddresses.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockAlphaAddresses.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaAddresses %v not found", key), + } + glog.V(5).Infof("MockAlphaAddresses.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockAlphaAddresses.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockAlphaAddresses) Obj(o *alpha.Address) *MockAddressesObj { + return &MockAddressesObj{o} +} + +// GCEAlphaAddresses is a simplifying adapter for the GCE Addresses. +type GCEAlphaAddresses struct { + s *Service +} + +// Get the Address named by key. +func (g *GCEAlphaAddresses) Get(ctx context.Context, key meta.Key) (*alpha.Address, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Addresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("alpha"), + Service: "Addresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.Addresses.Get(projectID, key.Region, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Address objects. +func (g *GCEAlphaAddresses) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.Address, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Addresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("alpha"), + Service: "Addresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.Addresses.List(projectID, region) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*alpha.Address + f := func(l *alpha.AddressList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert Address with key of value obj. +func (g *GCEAlphaAddresses) Insert(ctx context.Context, key meta.Key, obj *alpha.Address) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Addresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("alpha"), + Service: "Addresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.Alpha.Addresses.Insert(projectID, key.Region, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the Address referenced by key. +func (g *GCEAlphaAddresses) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Addresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("alpha"), + Service: "Addresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.Addresses.Delete(projectID, key.Region, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// BetaAddresses is an interface that allows for mocking of Addresses. +type BetaAddresses interface { + Get(ctx context.Context, key meta.Key) (*beta.Address, error) + List(ctx context.Context, region string, fl *filter.F) ([]*beta.Address, error) + Insert(ctx context.Context, key meta.Key, obj *beta.Address) error + Delete(ctx context.Context, key meta.Key) error +} + +// NewMockBetaAddresses returns a new mock for Addresses. +func NewMockBetaAddresses(objs map[meta.Key]*MockAddressesObj) *MockBetaAddresses { + mock := &MockBetaAddresses{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockBetaAddresses is the mock for Addresses. +type MockBetaAddresses struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockAddressesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockBetaAddresses, ctx context.Context, key meta.Key) (bool, *beta.Address, error) + ListHook func(m *MockBetaAddresses, ctx context.Context, region string, fl *filter.F) (bool, []*beta.Address, error) + InsertHook func(m *MockBetaAddresses, ctx context.Context, key meta.Key, obj *beta.Address) (bool, error) + DeleteHook func(m *MockBetaAddresses, ctx context.Context, key meta.Key) (bool, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockBetaAddresses) Get(ctx context.Context, key meta.Key) (*beta.Address, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockBetaAddresses.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockBetaAddresses.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToBeta() + glog.V(5).Infof("MockBetaAddresses.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockBetaAddresses %v not found", key), + } + glog.V(5).Infof("MockBetaAddresses.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given region. +func (m *MockBetaAddresses) List(ctx context.Context, region string, fl *filter.F) ([]*beta.Address, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, region, fl); intercept { + glog.V(5).Infof("MockBetaAddresses.List(%v, %q, %v) = [%v items], %v", ctx, region, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockBetaAddresses.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + + return nil, *m.ListError + } + + var objs []*beta.Address + for key, obj := range m.Objects { + if key.Region != region { + continue + } + if !fl.Match(obj.ToBeta()) { + continue + } + objs = append(objs, obj.ToBeta()) + } + + glog.V(5).Infof("MockBetaAddresses.List(%v, %q, %v) = [%v items], nil", ctx, region, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockBetaAddresses) Insert(ctx context.Context, key meta.Key, obj *beta.Address) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockBetaAddresses.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockBetaAddresses.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockBetaAddresses %v exists", key), + } + glog.V(5).Infof("MockBetaAddresses.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionBeta, "mock-project", "addresses", key) + } + + m.Objects[key] = &MockAddressesObj{obj} + glog.V(5).Infof("MockBetaAddresses.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockBetaAddresses) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockBetaAddresses.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockBetaAddresses.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockBetaAddresses %v not found", key), + } + glog.V(5).Infof("MockBetaAddresses.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockBetaAddresses.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockBetaAddresses) Obj(o *beta.Address) *MockAddressesObj { + return &MockAddressesObj{o} +} + +// GCEBetaAddresses is a simplifying adapter for the GCE Addresses. +type GCEBetaAddresses struct { + s *Service +} + +// Get the Address named by key. +func (g *GCEBetaAddresses) Get(ctx context.Context, key meta.Key) (*beta.Address, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "Addresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("beta"), + Service: "Addresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Beta.Addresses.Get(projectID, key.Region, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Address objects. +func (g *GCEBetaAddresses) List(ctx context.Context, region string, fl *filter.F) ([]*beta.Address, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "Addresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("beta"), + Service: "Addresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Beta.Addresses.List(projectID, region) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*beta.Address + f := func(l *beta.AddressList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert Address with key of value obj. +func (g *GCEBetaAddresses) Insert(ctx context.Context, key meta.Key, obj *beta.Address) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "Addresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("beta"), + Service: "Addresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.Beta.Addresses.Insert(projectID, key.Region, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the Address referenced by key. +func (g *GCEBetaAddresses) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "Addresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("beta"), + Service: "Addresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Beta.Addresses.Delete(projectID, key.Region, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// GlobalAddresses is an interface that allows for mocking of GlobalAddresses. +type GlobalAddresses interface { + Get(ctx context.Context, key meta.Key) (*ga.Address, error) + List(ctx context.Context, fl *filter.F) ([]*ga.Address, error) + Insert(ctx context.Context, key meta.Key, obj *ga.Address) error + Delete(ctx context.Context, key meta.Key) error +} + +// NewMockGlobalAddresses returns a new mock for GlobalAddresses. +func NewMockGlobalAddresses(objs map[meta.Key]*MockGlobalAddressesObj) *MockGlobalAddresses { + mock := &MockGlobalAddresses{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockGlobalAddresses is the mock for GlobalAddresses. +type MockGlobalAddresses struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockGlobalAddressesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockGlobalAddresses, ctx context.Context, key meta.Key) (bool, *ga.Address, error) + ListHook func(m *MockGlobalAddresses, ctx context.Context, fl *filter.F) (bool, []*ga.Address, error) + InsertHook func(m *MockGlobalAddresses, ctx context.Context, key meta.Key, obj *ga.Address) (bool, error) + DeleteHook func(m *MockGlobalAddresses, ctx context.Context, key meta.Key) (bool, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockGlobalAddresses) Get(ctx context.Context, key meta.Key) (*ga.Address, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockGlobalAddresses.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockGlobalAddresses.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockGlobalAddresses.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockGlobalAddresses %v not found", key), + } + glog.V(5).Infof("MockGlobalAddresses.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockGlobalAddresses) List(ctx context.Context, fl *filter.F) ([]*ga.Address, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockGlobalAddresses.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockGlobalAddresses.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.Address + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockGlobalAddresses.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockGlobalAddresses) Insert(ctx context.Context, key meta.Key, obj *ga.Address) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockGlobalAddresses.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockGlobalAddresses.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockGlobalAddresses %v exists", key), + } + glog.V(5).Infof("MockGlobalAddresses.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "addresses", key) + } + + m.Objects[key] = &MockGlobalAddressesObj{obj} + glog.V(5).Infof("MockGlobalAddresses.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockGlobalAddresses) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockGlobalAddresses.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockGlobalAddresses.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockGlobalAddresses %v not found", key), + } + glog.V(5).Infof("MockGlobalAddresses.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockGlobalAddresses.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockGlobalAddresses) Obj(o *ga.Address) *MockGlobalAddressesObj { + return &MockGlobalAddressesObj{o} +} + +// GCEGlobalAddresses is a simplifying adapter for the GCE GlobalAddresses. +type GCEGlobalAddresses struct { + s *Service +} + +// Get the Address named by key. +func (g *GCEGlobalAddresses) Get(ctx context.Context, key meta.Key) (*ga.Address, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "GlobalAddresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "GlobalAddresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.GlobalAddresses.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Address objects. +func (g *GCEGlobalAddresses) List(ctx context.Context, fl *filter.F) ([]*ga.Address, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "GlobalAddresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "GlobalAddresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.GlobalAddresses.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.Address + f := func(l *ga.AddressList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert Address with key of value obj. +func (g *GCEGlobalAddresses) Insert(ctx context.Context, key meta.Key, obj *ga.Address) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "GlobalAddresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "GlobalAddresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.GlobalAddresses.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the Address referenced by key. +func (g *GCEGlobalAddresses) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "GlobalAddresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "GlobalAddresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.GlobalAddresses.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// BackendServices is an interface that allows for mocking of BackendServices. +type BackendServices interface { + Get(ctx context.Context, key meta.Key) (*ga.BackendService, error) + List(ctx context.Context, fl *filter.F) ([]*ga.BackendService, error) + Insert(ctx context.Context, key meta.Key, obj *ga.BackendService) error + Delete(ctx context.Context, key meta.Key) error + GetHealth(context.Context, meta.Key, *ga.ResourceGroupReference) (*ga.BackendServiceGroupHealth, error) + Update(context.Context, meta.Key, *ga.BackendService) error +} + +// NewMockBackendServices returns a new mock for BackendServices. +func NewMockBackendServices(objs map[meta.Key]*MockBackendServicesObj) *MockBackendServices { + mock := &MockBackendServices{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockBackendServices is the mock for BackendServices. +type MockBackendServices struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockBackendServicesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockBackendServices, ctx context.Context, key meta.Key) (bool, *ga.BackendService, error) + ListHook func(m *MockBackendServices, ctx context.Context, fl *filter.F) (bool, []*ga.BackendService, error) + InsertHook func(m *MockBackendServices, ctx context.Context, key meta.Key, obj *ga.BackendService) (bool, error) + DeleteHook func(m *MockBackendServices, ctx context.Context, key meta.Key) (bool, error) + GetHealthHook func(*MockBackendServices, context.Context, meta.Key, *ga.ResourceGroupReference) (*ga.BackendServiceGroupHealth, error) + UpdateHook func(*MockBackendServices, context.Context, meta.Key, *ga.BackendService) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockBackendServices) Get(ctx context.Context, key meta.Key) (*ga.BackendService, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockBackendServices.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockBackendServices.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockBackendServices.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockBackendServices %v not found", key), + } + glog.V(5).Infof("MockBackendServices.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockBackendServices) List(ctx context.Context, fl *filter.F) ([]*ga.BackendService, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockBackendServices.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockBackendServices.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.BackendService + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockBackendServices.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockBackendServices) Insert(ctx context.Context, key meta.Key, obj *ga.BackendService) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockBackendServices.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockBackendServices.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockBackendServices %v exists", key), + } + glog.V(5).Infof("MockBackendServices.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "backendServices", key) + } + + m.Objects[key] = &MockBackendServicesObj{obj} + glog.V(5).Infof("MockBackendServices.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockBackendServices) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockBackendServices.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockBackendServices.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockBackendServices %v not found", key), + } + glog.V(5).Infof("MockBackendServices.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockBackendServices.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockBackendServices) Obj(o *ga.BackendService) *MockBackendServicesObj { + return &MockBackendServicesObj{o} +} + +// GetHealth is a mock for the corresponding method. +func (m *MockBackendServices) GetHealth(ctx context.Context, key meta.Key, arg0 *ga.ResourceGroupReference) (*ga.BackendServiceGroupHealth, error) { + if m.GetHealthHook != nil { + return m.GetHealthHook(m, ctx, key, arg0) + } + return nil, fmt.Errorf("GetHealthHook must be set") +} + +// Update is a mock for the corresponding method. +func (m *MockBackendServices) Update(ctx context.Context, key meta.Key, arg0 *ga.BackendService) error { + if m.UpdateHook != nil { + return m.UpdateHook(m, ctx, key, arg0) + } + return nil +} + +// GCEBackendServices is a simplifying adapter for the GCE BackendServices. +type GCEBackendServices struct { + s *Service +} + +// Get the BackendService named by key. +func (g *GCEBackendServices) Get(ctx context.Context, key meta.Key) (*ga.BackendService, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "BackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "BackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.BackendServices.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all BackendService objects. +func (g *GCEBackendServices) List(ctx context.Context, fl *filter.F) ([]*ga.BackendService, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "BackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "BackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.BackendServices.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.BackendService + f := func(l *ga.BackendServiceList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert BackendService with key of value obj. +func (g *GCEBackendServices) Insert(ctx context.Context, key meta.Key, obj *ga.BackendService) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "BackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "BackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.BackendServices.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the BackendService referenced by key. +func (g *GCEBackendServices) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "BackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "BackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.BackendServices.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// GetHealth is a method on GCEBackendServices. +func (g *GCEBackendServices) GetHealth(ctx context.Context, key meta.Key, arg0 *ga.ResourceGroupReference) (*ga.BackendServiceGroupHealth, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "BackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "GetHealth", + Version: meta.Version("ga"), + Service: "BackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.BackendServices.GetHealth(projectID, key.Name, arg0) + call.Context(ctx) + return call.Do() +} + +// Update is a method on GCEBackendServices. +func (g *GCEBackendServices) Update(ctx context.Context, key meta.Key, arg0 *ga.BackendService) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "BackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Update", + Version: meta.Version("ga"), + Service: "BackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.BackendServices.Update(projectID, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AlphaBackendServices is an interface that allows for mocking of BackendServices. +type AlphaBackendServices interface { + Get(ctx context.Context, key meta.Key) (*alpha.BackendService, error) + List(ctx context.Context, fl *filter.F) ([]*alpha.BackendService, error) + Insert(ctx context.Context, key meta.Key, obj *alpha.BackendService) error + Delete(ctx context.Context, key meta.Key) error + Update(context.Context, meta.Key, *alpha.BackendService) error +} + +// NewMockAlphaBackendServices returns a new mock for BackendServices. +func NewMockAlphaBackendServices(objs map[meta.Key]*MockBackendServicesObj) *MockAlphaBackendServices { + mock := &MockAlphaBackendServices{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockAlphaBackendServices is the mock for BackendServices. +type MockAlphaBackendServices struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockBackendServicesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockAlphaBackendServices, ctx context.Context, key meta.Key) (bool, *alpha.BackendService, error) + ListHook func(m *MockAlphaBackendServices, ctx context.Context, fl *filter.F) (bool, []*alpha.BackendService, error) + InsertHook func(m *MockAlphaBackendServices, ctx context.Context, key meta.Key, obj *alpha.BackendService) (bool, error) + DeleteHook func(m *MockAlphaBackendServices, ctx context.Context, key meta.Key) (bool, error) + UpdateHook func(*MockAlphaBackendServices, context.Context, meta.Key, *alpha.BackendService) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockAlphaBackendServices) Get(ctx context.Context, key meta.Key) (*alpha.BackendService, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaBackendServices.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockAlphaBackendServices.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToAlpha() + glog.V(5).Infof("MockAlphaBackendServices.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaBackendServices %v not found", key), + } + glog.V(5).Infof("MockAlphaBackendServices.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockAlphaBackendServices) List(ctx context.Context, fl *filter.F) ([]*alpha.BackendService, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockAlphaBackendServices.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockAlphaBackendServices.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*alpha.BackendService + for _, obj := range m.Objects { + if !fl.Match(obj.ToAlpha()) { + continue + } + objs = append(objs, obj.ToAlpha()) + } + + glog.V(5).Infof("MockAlphaBackendServices.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockAlphaBackendServices) Insert(ctx context.Context, key meta.Key, obj *alpha.BackendService) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockAlphaBackendServices.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockAlphaBackendServices.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockAlphaBackendServices %v exists", key), + } + glog.V(5).Infof("MockAlphaBackendServices.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionAlpha, "mock-project", "backendServices", key) + } + + m.Objects[key] = &MockBackendServicesObj{obj} + glog.V(5).Infof("MockAlphaBackendServices.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockAlphaBackendServices) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaBackendServices.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockAlphaBackendServices.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaBackendServices %v not found", key), + } + glog.V(5).Infof("MockAlphaBackendServices.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockAlphaBackendServices.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockAlphaBackendServices) Obj(o *alpha.BackendService) *MockBackendServicesObj { + return &MockBackendServicesObj{o} +} + +// Update is a mock for the corresponding method. +func (m *MockAlphaBackendServices) Update(ctx context.Context, key meta.Key, arg0 *alpha.BackendService) error { + if m.UpdateHook != nil { + return m.UpdateHook(m, ctx, key, arg0) + } + return nil +} + +// GCEAlphaBackendServices is a simplifying adapter for the GCE BackendServices. +type GCEAlphaBackendServices struct { + s *Service +} + +// Get the BackendService named by key. +func (g *GCEAlphaBackendServices) Get(ctx context.Context, key meta.Key) (*alpha.BackendService, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "BackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("alpha"), + Service: "BackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.BackendServices.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all BackendService objects. +func (g *GCEAlphaBackendServices) List(ctx context.Context, fl *filter.F) ([]*alpha.BackendService, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "BackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("alpha"), + Service: "BackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.BackendServices.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*alpha.BackendService + f := func(l *alpha.BackendServiceList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert BackendService with key of value obj. +func (g *GCEAlphaBackendServices) Insert(ctx context.Context, key meta.Key, obj *alpha.BackendService) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "BackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("alpha"), + Service: "BackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.Alpha.BackendServices.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the BackendService referenced by key. +func (g *GCEAlphaBackendServices) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "BackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("alpha"), + Service: "BackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.BackendServices.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Update is a method on GCEAlphaBackendServices. +func (g *GCEAlphaBackendServices) Update(ctx context.Context, key meta.Key, arg0 *alpha.BackendService) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "BackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Update", + Version: meta.Version("alpha"), + Service: "BackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.BackendServices.Update(projectID, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AlphaRegionBackendServices is an interface that allows for mocking of RegionBackendServices. +type AlphaRegionBackendServices interface { + Get(ctx context.Context, key meta.Key) (*alpha.BackendService, error) + List(ctx context.Context, region string, fl *filter.F) ([]*alpha.BackendService, error) + Insert(ctx context.Context, key meta.Key, obj *alpha.BackendService) error + Delete(ctx context.Context, key meta.Key) error + GetHealth(context.Context, meta.Key, *alpha.ResourceGroupReference) (*alpha.BackendServiceGroupHealth, error) + Update(context.Context, meta.Key, *alpha.BackendService) error +} + +// NewMockAlphaRegionBackendServices returns a new mock for RegionBackendServices. +func NewMockAlphaRegionBackendServices(objs map[meta.Key]*MockRegionBackendServicesObj) *MockAlphaRegionBackendServices { + mock := &MockAlphaRegionBackendServices{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockAlphaRegionBackendServices is the mock for RegionBackendServices. +type MockAlphaRegionBackendServices struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockRegionBackendServicesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockAlphaRegionBackendServices, ctx context.Context, key meta.Key) (bool, *alpha.BackendService, error) + ListHook func(m *MockAlphaRegionBackendServices, ctx context.Context, region string, fl *filter.F) (bool, []*alpha.BackendService, error) + InsertHook func(m *MockAlphaRegionBackendServices, ctx context.Context, key meta.Key, obj *alpha.BackendService) (bool, error) + DeleteHook func(m *MockAlphaRegionBackendServices, ctx context.Context, key meta.Key) (bool, error) + GetHealthHook func(*MockAlphaRegionBackendServices, context.Context, meta.Key, *alpha.ResourceGroupReference) (*alpha.BackendServiceGroupHealth, error) + UpdateHook func(*MockAlphaRegionBackendServices, context.Context, meta.Key, *alpha.BackendService) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockAlphaRegionBackendServices) Get(ctx context.Context, key meta.Key) (*alpha.BackendService, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaRegionBackendServices.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockAlphaRegionBackendServices.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToAlpha() + glog.V(5).Infof("MockAlphaRegionBackendServices.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaRegionBackendServices %v not found", key), + } + glog.V(5).Infof("MockAlphaRegionBackendServices.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given region. +func (m *MockAlphaRegionBackendServices) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.BackendService, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, region, fl); intercept { + glog.V(5).Infof("MockAlphaRegionBackendServices.List(%v, %q, %v) = [%v items], %v", ctx, region, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockAlphaRegionBackendServices.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + + return nil, *m.ListError + } + + var objs []*alpha.BackendService + for key, obj := range m.Objects { + if key.Region != region { + continue + } + if !fl.Match(obj.ToAlpha()) { + continue + } + objs = append(objs, obj.ToAlpha()) + } + + glog.V(5).Infof("MockAlphaRegionBackendServices.List(%v, %q, %v) = [%v items], nil", ctx, region, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockAlphaRegionBackendServices) Insert(ctx context.Context, key meta.Key, obj *alpha.BackendService) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockAlphaRegionBackendServices.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockAlphaRegionBackendServices.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockAlphaRegionBackendServices %v exists", key), + } + glog.V(5).Infof("MockAlphaRegionBackendServices.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionAlpha, "mock-project", "backendServices", key) + } + + m.Objects[key] = &MockRegionBackendServicesObj{obj} + glog.V(5).Infof("MockAlphaRegionBackendServices.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockAlphaRegionBackendServices) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaRegionBackendServices.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockAlphaRegionBackendServices.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaRegionBackendServices %v not found", key), + } + glog.V(5).Infof("MockAlphaRegionBackendServices.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockAlphaRegionBackendServices.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockAlphaRegionBackendServices) Obj(o *alpha.BackendService) *MockRegionBackendServicesObj { + return &MockRegionBackendServicesObj{o} +} + +// GetHealth is a mock for the corresponding method. +func (m *MockAlphaRegionBackendServices) GetHealth(ctx context.Context, key meta.Key, arg0 *alpha.ResourceGroupReference) (*alpha.BackendServiceGroupHealth, error) { + if m.GetHealthHook != nil { + return m.GetHealthHook(m, ctx, key, arg0) + } + return nil, fmt.Errorf("GetHealthHook must be set") +} + +// Update is a mock for the corresponding method. +func (m *MockAlphaRegionBackendServices) Update(ctx context.Context, key meta.Key, arg0 *alpha.BackendService) error { + if m.UpdateHook != nil { + return m.UpdateHook(m, ctx, key, arg0) + } + return nil +} + +// GCEAlphaRegionBackendServices is a simplifying adapter for the GCE RegionBackendServices. +type GCEAlphaRegionBackendServices struct { + s *Service +} + +// Get the BackendService named by key. +func (g *GCEAlphaRegionBackendServices) Get(ctx context.Context, key meta.Key) (*alpha.BackendService, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "RegionBackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("alpha"), + Service: "RegionBackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.RegionBackendServices.Get(projectID, key.Region, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all BackendService objects. +func (g *GCEAlphaRegionBackendServices) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.BackendService, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "RegionBackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("alpha"), + Service: "RegionBackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.RegionBackendServices.List(projectID, region) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*alpha.BackendService + f := func(l *alpha.BackendServiceList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert BackendService with key of value obj. +func (g *GCEAlphaRegionBackendServices) Insert(ctx context.Context, key meta.Key, obj *alpha.BackendService) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "RegionBackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("alpha"), + Service: "RegionBackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.Alpha.RegionBackendServices.Insert(projectID, key.Region, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the BackendService referenced by key. +func (g *GCEAlphaRegionBackendServices) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "RegionBackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("alpha"), + Service: "RegionBackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.RegionBackendServices.Delete(projectID, key.Region, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// GetHealth is a method on GCEAlphaRegionBackendServices. +func (g *GCEAlphaRegionBackendServices) GetHealth(ctx context.Context, key meta.Key, arg0 *alpha.ResourceGroupReference) (*alpha.BackendServiceGroupHealth, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "RegionBackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "GetHealth", + Version: meta.Version("alpha"), + Service: "RegionBackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.RegionBackendServices.GetHealth(projectID, key.Region, key.Name, arg0) + call.Context(ctx) + return call.Do() +} + +// Update is a method on GCEAlphaRegionBackendServices. +func (g *GCEAlphaRegionBackendServices) Update(ctx context.Context, key meta.Key, arg0 *alpha.BackendService) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "RegionBackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Update", + Version: meta.Version("alpha"), + Service: "RegionBackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.RegionBackendServices.Update(projectID, key.Region, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Disks is an interface that allows for mocking of Disks. +type Disks interface { + Get(ctx context.Context, key meta.Key) (*ga.Disk, error) + List(ctx context.Context, zone string, fl *filter.F) ([]*ga.Disk, error) + Insert(ctx context.Context, key meta.Key, obj *ga.Disk) error + Delete(ctx context.Context, key meta.Key) error +} + +// NewMockDisks returns a new mock for Disks. +func NewMockDisks(objs map[meta.Key]*MockDisksObj) *MockDisks { + mock := &MockDisks{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockDisks is the mock for Disks. +type MockDisks struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockDisksObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockDisks, ctx context.Context, key meta.Key) (bool, *ga.Disk, error) + ListHook func(m *MockDisks, ctx context.Context, zone string, fl *filter.F) (bool, []*ga.Disk, error) + InsertHook func(m *MockDisks, ctx context.Context, key meta.Key, obj *ga.Disk) (bool, error) + DeleteHook func(m *MockDisks, ctx context.Context, key meta.Key) (bool, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockDisks) Get(ctx context.Context, key meta.Key) (*ga.Disk, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockDisks.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockDisks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockDisks.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockDisks %v not found", key), + } + glog.V(5).Infof("MockDisks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given zone. +func (m *MockDisks) List(ctx context.Context, zone string, fl *filter.F) ([]*ga.Disk, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, zone, fl); intercept { + glog.V(5).Infof("MockDisks.List(%v, %q, %v) = [%v items], %v", ctx, zone, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockDisks.List(%v, %q, %v) = nil, %v", ctx, zone, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.Disk + for key, obj := range m.Objects { + if key.Zone != zone { + continue + } + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockDisks.List(%v, %q, %v) = [%v items], nil", ctx, zone, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockDisks) Insert(ctx context.Context, key meta.Key, obj *ga.Disk) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockDisks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockDisks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockDisks %v exists", key), + } + glog.V(5).Infof("MockDisks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "disks", key) + } + + m.Objects[key] = &MockDisksObj{obj} + glog.V(5).Infof("MockDisks.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockDisks) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockDisks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockDisks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockDisks %v not found", key), + } + glog.V(5).Infof("MockDisks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockDisks.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockDisks) Obj(o *ga.Disk) *MockDisksObj { + return &MockDisksObj{o} +} + +// GCEDisks is a simplifying adapter for the GCE Disks. +type GCEDisks struct { + s *Service +} + +// Get the Disk named by key. +func (g *GCEDisks) Get(ctx context.Context, key meta.Key) (*ga.Disk, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Disks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "Disks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Disks.Get(projectID, key.Zone, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Disk objects. +func (g *GCEDisks) List(ctx context.Context, zone string, fl *filter.F) ([]*ga.Disk, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Disks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "Disks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Disks.List(projectID, zone) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.Disk + f := func(l *ga.DiskList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert Disk with key of value obj. +func (g *GCEDisks) Insert(ctx context.Context, key meta.Key, obj *ga.Disk) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Disks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "Disks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.Disks.Insert(projectID, key.Zone, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the Disk referenced by key. +func (g *GCEDisks) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Disks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "Disks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.Disks.Delete(projectID, key.Zone, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AlphaDisks is an interface that allows for mocking of Disks. +type AlphaDisks interface { + Get(ctx context.Context, key meta.Key) (*alpha.Disk, error) + List(ctx context.Context, zone string, fl *filter.F) ([]*alpha.Disk, error) + Insert(ctx context.Context, key meta.Key, obj *alpha.Disk) error + Delete(ctx context.Context, key meta.Key) error +} + +// NewMockAlphaDisks returns a new mock for Disks. +func NewMockAlphaDisks(objs map[meta.Key]*MockDisksObj) *MockAlphaDisks { + mock := &MockAlphaDisks{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockAlphaDisks is the mock for Disks. +type MockAlphaDisks struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockDisksObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockAlphaDisks, ctx context.Context, key meta.Key) (bool, *alpha.Disk, error) + ListHook func(m *MockAlphaDisks, ctx context.Context, zone string, fl *filter.F) (bool, []*alpha.Disk, error) + InsertHook func(m *MockAlphaDisks, ctx context.Context, key meta.Key, obj *alpha.Disk) (bool, error) + DeleteHook func(m *MockAlphaDisks, ctx context.Context, key meta.Key) (bool, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockAlphaDisks) Get(ctx context.Context, key meta.Key) (*alpha.Disk, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaDisks.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockAlphaDisks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToAlpha() + glog.V(5).Infof("MockAlphaDisks.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaDisks %v not found", key), + } + glog.V(5).Infof("MockAlphaDisks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given zone. +func (m *MockAlphaDisks) List(ctx context.Context, zone string, fl *filter.F) ([]*alpha.Disk, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, zone, fl); intercept { + glog.V(5).Infof("MockAlphaDisks.List(%v, %q, %v) = [%v items], %v", ctx, zone, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockAlphaDisks.List(%v, %q, %v) = nil, %v", ctx, zone, fl, err) + + return nil, *m.ListError + } + + var objs []*alpha.Disk + for key, obj := range m.Objects { + if key.Zone != zone { + continue + } + if !fl.Match(obj.ToAlpha()) { + continue + } + objs = append(objs, obj.ToAlpha()) + } + + glog.V(5).Infof("MockAlphaDisks.List(%v, %q, %v) = [%v items], nil", ctx, zone, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockAlphaDisks) Insert(ctx context.Context, key meta.Key, obj *alpha.Disk) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockAlphaDisks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockAlphaDisks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockAlphaDisks %v exists", key), + } + glog.V(5).Infof("MockAlphaDisks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionAlpha, "mock-project", "disks", key) + } + + m.Objects[key] = &MockDisksObj{obj} + glog.V(5).Infof("MockAlphaDisks.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockAlphaDisks) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaDisks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockAlphaDisks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaDisks %v not found", key), + } + glog.V(5).Infof("MockAlphaDisks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockAlphaDisks.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockAlphaDisks) Obj(o *alpha.Disk) *MockDisksObj { + return &MockDisksObj{o} +} + +// GCEAlphaDisks is a simplifying adapter for the GCE Disks. +type GCEAlphaDisks struct { + s *Service +} + +// Get the Disk named by key. +func (g *GCEAlphaDisks) Get(ctx context.Context, key meta.Key) (*alpha.Disk, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Disks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("alpha"), + Service: "Disks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.Disks.Get(projectID, key.Zone, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Disk objects. +func (g *GCEAlphaDisks) List(ctx context.Context, zone string, fl *filter.F) ([]*alpha.Disk, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Disks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("alpha"), + Service: "Disks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.Disks.List(projectID, zone) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*alpha.Disk + f := func(l *alpha.DiskList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert Disk with key of value obj. +func (g *GCEAlphaDisks) Insert(ctx context.Context, key meta.Key, obj *alpha.Disk) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Disks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("alpha"), + Service: "Disks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.Alpha.Disks.Insert(projectID, key.Zone, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the Disk referenced by key. +func (g *GCEAlphaDisks) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Disks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("alpha"), + Service: "Disks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.Disks.Delete(projectID, key.Zone, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AlphaRegionDisks is an interface that allows for mocking of RegionDisks. +type AlphaRegionDisks interface { + Get(ctx context.Context, key meta.Key) (*alpha.Disk, error) + List(ctx context.Context, region string, fl *filter.F) ([]*alpha.Disk, error) + Insert(ctx context.Context, key meta.Key, obj *alpha.Disk) error + Delete(ctx context.Context, key meta.Key) error +} + +// NewMockAlphaRegionDisks returns a new mock for RegionDisks. +func NewMockAlphaRegionDisks(objs map[meta.Key]*MockRegionDisksObj) *MockAlphaRegionDisks { + mock := &MockAlphaRegionDisks{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockAlphaRegionDisks is the mock for RegionDisks. +type MockAlphaRegionDisks struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockRegionDisksObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockAlphaRegionDisks, ctx context.Context, key meta.Key) (bool, *alpha.Disk, error) + ListHook func(m *MockAlphaRegionDisks, ctx context.Context, region string, fl *filter.F) (bool, []*alpha.Disk, error) + InsertHook func(m *MockAlphaRegionDisks, ctx context.Context, key meta.Key, obj *alpha.Disk) (bool, error) + DeleteHook func(m *MockAlphaRegionDisks, ctx context.Context, key meta.Key) (bool, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockAlphaRegionDisks) Get(ctx context.Context, key meta.Key) (*alpha.Disk, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaRegionDisks.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockAlphaRegionDisks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToAlpha() + glog.V(5).Infof("MockAlphaRegionDisks.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaRegionDisks %v not found", key), + } + glog.V(5).Infof("MockAlphaRegionDisks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given region. +func (m *MockAlphaRegionDisks) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.Disk, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, region, fl); intercept { + glog.V(5).Infof("MockAlphaRegionDisks.List(%v, %q, %v) = [%v items], %v", ctx, region, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockAlphaRegionDisks.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + + return nil, *m.ListError + } + + var objs []*alpha.Disk + for key, obj := range m.Objects { + if key.Region != region { + continue + } + if !fl.Match(obj.ToAlpha()) { + continue + } + objs = append(objs, obj.ToAlpha()) + } + + glog.V(5).Infof("MockAlphaRegionDisks.List(%v, %q, %v) = [%v items], nil", ctx, region, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockAlphaRegionDisks) Insert(ctx context.Context, key meta.Key, obj *alpha.Disk) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockAlphaRegionDisks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockAlphaRegionDisks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockAlphaRegionDisks %v exists", key), + } + glog.V(5).Infof("MockAlphaRegionDisks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionAlpha, "mock-project", "disks", key) + } + + m.Objects[key] = &MockRegionDisksObj{obj} + glog.V(5).Infof("MockAlphaRegionDisks.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockAlphaRegionDisks) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaRegionDisks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockAlphaRegionDisks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaRegionDisks %v not found", key), + } + glog.V(5).Infof("MockAlphaRegionDisks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockAlphaRegionDisks.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockAlphaRegionDisks) Obj(o *alpha.Disk) *MockRegionDisksObj { + return &MockRegionDisksObj{o} +} + +// GCEAlphaRegionDisks is a simplifying adapter for the GCE RegionDisks. +type GCEAlphaRegionDisks struct { + s *Service +} + +// Get the Disk named by key. +func (g *GCEAlphaRegionDisks) Get(ctx context.Context, key meta.Key) (*alpha.Disk, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "RegionDisks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("alpha"), + Service: "RegionDisks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.RegionDisks.Get(projectID, key.Region, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Disk objects. +func (g *GCEAlphaRegionDisks) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.Disk, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "RegionDisks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("alpha"), + Service: "RegionDisks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.RegionDisks.List(projectID, region) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*alpha.Disk + f := func(l *alpha.DiskList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert Disk with key of value obj. +func (g *GCEAlphaRegionDisks) Insert(ctx context.Context, key meta.Key, obj *alpha.Disk) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "RegionDisks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("alpha"), + Service: "RegionDisks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.Alpha.RegionDisks.Insert(projectID, key.Region, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the Disk referenced by key. +func (g *GCEAlphaRegionDisks) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "RegionDisks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("alpha"), + Service: "RegionDisks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.RegionDisks.Delete(projectID, key.Region, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Firewalls is an interface that allows for mocking of Firewalls. +type Firewalls interface { + Get(ctx context.Context, key meta.Key) (*ga.Firewall, error) + List(ctx context.Context, fl *filter.F) ([]*ga.Firewall, error) + Insert(ctx context.Context, key meta.Key, obj *ga.Firewall) error + Delete(ctx context.Context, key meta.Key) error + Update(context.Context, meta.Key, *ga.Firewall) error +} + +// NewMockFirewalls returns a new mock for Firewalls. +func NewMockFirewalls(objs map[meta.Key]*MockFirewallsObj) *MockFirewalls { + mock := &MockFirewalls{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockFirewalls is the mock for Firewalls. +type MockFirewalls struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockFirewallsObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockFirewalls, ctx context.Context, key meta.Key) (bool, *ga.Firewall, error) + ListHook func(m *MockFirewalls, ctx context.Context, fl *filter.F) (bool, []*ga.Firewall, error) + InsertHook func(m *MockFirewalls, ctx context.Context, key meta.Key, obj *ga.Firewall) (bool, error) + DeleteHook func(m *MockFirewalls, ctx context.Context, key meta.Key) (bool, error) + UpdateHook func(*MockFirewalls, context.Context, meta.Key, *ga.Firewall) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockFirewalls) Get(ctx context.Context, key meta.Key) (*ga.Firewall, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockFirewalls.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockFirewalls.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockFirewalls.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockFirewalls %v not found", key), + } + glog.V(5).Infof("MockFirewalls.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockFirewalls) List(ctx context.Context, fl *filter.F) ([]*ga.Firewall, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockFirewalls.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockFirewalls.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.Firewall + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockFirewalls.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockFirewalls) Insert(ctx context.Context, key meta.Key, obj *ga.Firewall) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockFirewalls.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockFirewalls.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockFirewalls %v exists", key), + } + glog.V(5).Infof("MockFirewalls.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "firewalls", key) + } + + m.Objects[key] = &MockFirewallsObj{obj} + glog.V(5).Infof("MockFirewalls.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockFirewalls) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockFirewalls.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockFirewalls.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockFirewalls %v not found", key), + } + glog.V(5).Infof("MockFirewalls.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockFirewalls.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockFirewalls) Obj(o *ga.Firewall) *MockFirewallsObj { + return &MockFirewallsObj{o} +} + +// Update is a mock for the corresponding method. +func (m *MockFirewalls) Update(ctx context.Context, key meta.Key, arg0 *ga.Firewall) error { + if m.UpdateHook != nil { + return m.UpdateHook(m, ctx, key, arg0) + } + return nil +} + +// GCEFirewalls is a simplifying adapter for the GCE Firewalls. +type GCEFirewalls struct { + s *Service +} + +// Get the Firewall named by key. +func (g *GCEFirewalls) Get(ctx context.Context, key meta.Key) (*ga.Firewall, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Firewalls") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "Firewalls", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Firewalls.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Firewall objects. +func (g *GCEFirewalls) List(ctx context.Context, fl *filter.F) ([]*ga.Firewall, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Firewalls") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "Firewalls", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Firewalls.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.Firewall + f := func(l *ga.FirewallList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert Firewall with key of value obj. +func (g *GCEFirewalls) Insert(ctx context.Context, key meta.Key, obj *ga.Firewall) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Firewalls") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "Firewalls", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.Firewalls.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the Firewall referenced by key. +func (g *GCEFirewalls) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Firewalls") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "Firewalls", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.Firewalls.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Update is a method on GCEFirewalls. +func (g *GCEFirewalls) Update(ctx context.Context, key meta.Key, arg0 *ga.Firewall) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Firewalls") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Update", + Version: meta.Version("ga"), + Service: "Firewalls", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.Firewalls.Update(projectID, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// ForwardingRules is an interface that allows for mocking of ForwardingRules. +type ForwardingRules interface { + Get(ctx context.Context, key meta.Key) (*ga.ForwardingRule, error) + List(ctx context.Context, region string, fl *filter.F) ([]*ga.ForwardingRule, error) + Insert(ctx context.Context, key meta.Key, obj *ga.ForwardingRule) error + Delete(ctx context.Context, key meta.Key) error +} + +// NewMockForwardingRules returns a new mock for ForwardingRules. +func NewMockForwardingRules(objs map[meta.Key]*MockForwardingRulesObj) *MockForwardingRules { + mock := &MockForwardingRules{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockForwardingRules is the mock for ForwardingRules. +type MockForwardingRules struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockForwardingRulesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockForwardingRules, ctx context.Context, key meta.Key) (bool, *ga.ForwardingRule, error) + ListHook func(m *MockForwardingRules, ctx context.Context, region string, fl *filter.F) (bool, []*ga.ForwardingRule, error) + InsertHook func(m *MockForwardingRules, ctx context.Context, key meta.Key, obj *ga.ForwardingRule) (bool, error) + DeleteHook func(m *MockForwardingRules, ctx context.Context, key meta.Key) (bool, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockForwardingRules) Get(ctx context.Context, key meta.Key) (*ga.ForwardingRule, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockForwardingRules.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockForwardingRules.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockForwardingRules.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockForwardingRules %v not found", key), + } + glog.V(5).Infof("MockForwardingRules.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given region. +func (m *MockForwardingRules) List(ctx context.Context, region string, fl *filter.F) ([]*ga.ForwardingRule, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, region, fl); intercept { + glog.V(5).Infof("MockForwardingRules.List(%v, %q, %v) = [%v items], %v", ctx, region, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockForwardingRules.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.ForwardingRule + for key, obj := range m.Objects { + if key.Region != region { + continue + } + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockForwardingRules.List(%v, %q, %v) = [%v items], nil", ctx, region, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockForwardingRules) Insert(ctx context.Context, key meta.Key, obj *ga.ForwardingRule) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockForwardingRules.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockForwardingRules.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockForwardingRules %v exists", key), + } + glog.V(5).Infof("MockForwardingRules.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "forwardingRules", key) + } + + m.Objects[key] = &MockForwardingRulesObj{obj} + glog.V(5).Infof("MockForwardingRules.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockForwardingRules) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockForwardingRules.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockForwardingRules.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockForwardingRules %v not found", key), + } + glog.V(5).Infof("MockForwardingRules.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockForwardingRules.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockForwardingRules) Obj(o *ga.ForwardingRule) *MockForwardingRulesObj { + return &MockForwardingRulesObj{o} +} + +// GCEForwardingRules is a simplifying adapter for the GCE ForwardingRules. +type GCEForwardingRules struct { + s *Service +} + +// Get the ForwardingRule named by key. +func (g *GCEForwardingRules) Get(ctx context.Context, key meta.Key) (*ga.ForwardingRule, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "ForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "ForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.ForwardingRules.Get(projectID, key.Region, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all ForwardingRule objects. +func (g *GCEForwardingRules) List(ctx context.Context, region string, fl *filter.F) ([]*ga.ForwardingRule, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "ForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "ForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.ForwardingRules.List(projectID, region) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.ForwardingRule + f := func(l *ga.ForwardingRuleList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert ForwardingRule with key of value obj. +func (g *GCEForwardingRules) Insert(ctx context.Context, key meta.Key, obj *ga.ForwardingRule) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "ForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "ForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.ForwardingRules.Insert(projectID, key.Region, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the ForwardingRule referenced by key. +func (g *GCEForwardingRules) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "ForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "ForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.ForwardingRules.Delete(projectID, key.Region, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AlphaForwardingRules is an interface that allows for mocking of ForwardingRules. +type AlphaForwardingRules interface { + Get(ctx context.Context, key meta.Key) (*alpha.ForwardingRule, error) + List(ctx context.Context, region string, fl *filter.F) ([]*alpha.ForwardingRule, error) + Insert(ctx context.Context, key meta.Key, obj *alpha.ForwardingRule) error + Delete(ctx context.Context, key meta.Key) error +} + +// NewMockAlphaForwardingRules returns a new mock for ForwardingRules. +func NewMockAlphaForwardingRules(objs map[meta.Key]*MockForwardingRulesObj) *MockAlphaForwardingRules { + mock := &MockAlphaForwardingRules{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockAlphaForwardingRules is the mock for ForwardingRules. +type MockAlphaForwardingRules struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockForwardingRulesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockAlphaForwardingRules, ctx context.Context, key meta.Key) (bool, *alpha.ForwardingRule, error) + ListHook func(m *MockAlphaForwardingRules, ctx context.Context, region string, fl *filter.F) (bool, []*alpha.ForwardingRule, error) + InsertHook func(m *MockAlphaForwardingRules, ctx context.Context, key meta.Key, obj *alpha.ForwardingRule) (bool, error) + DeleteHook func(m *MockAlphaForwardingRules, ctx context.Context, key meta.Key) (bool, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockAlphaForwardingRules) Get(ctx context.Context, key meta.Key) (*alpha.ForwardingRule, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaForwardingRules.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockAlphaForwardingRules.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToAlpha() + glog.V(5).Infof("MockAlphaForwardingRules.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaForwardingRules %v not found", key), + } + glog.V(5).Infof("MockAlphaForwardingRules.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given region. +func (m *MockAlphaForwardingRules) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.ForwardingRule, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, region, fl); intercept { + glog.V(5).Infof("MockAlphaForwardingRules.List(%v, %q, %v) = [%v items], %v", ctx, region, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockAlphaForwardingRules.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + + return nil, *m.ListError + } + + var objs []*alpha.ForwardingRule + for key, obj := range m.Objects { + if key.Region != region { + continue + } + if !fl.Match(obj.ToAlpha()) { + continue + } + objs = append(objs, obj.ToAlpha()) + } + + glog.V(5).Infof("MockAlphaForwardingRules.List(%v, %q, %v) = [%v items], nil", ctx, region, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockAlphaForwardingRules) Insert(ctx context.Context, key meta.Key, obj *alpha.ForwardingRule) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockAlphaForwardingRules.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockAlphaForwardingRules.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockAlphaForwardingRules %v exists", key), + } + glog.V(5).Infof("MockAlphaForwardingRules.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionAlpha, "mock-project", "forwardingRules", key) + } + + m.Objects[key] = &MockForwardingRulesObj{obj} + glog.V(5).Infof("MockAlphaForwardingRules.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockAlphaForwardingRules) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaForwardingRules.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockAlphaForwardingRules.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaForwardingRules %v not found", key), + } + glog.V(5).Infof("MockAlphaForwardingRules.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockAlphaForwardingRules.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockAlphaForwardingRules) Obj(o *alpha.ForwardingRule) *MockForwardingRulesObj { + return &MockForwardingRulesObj{o} +} + +// GCEAlphaForwardingRules is a simplifying adapter for the GCE ForwardingRules. +type GCEAlphaForwardingRules struct { + s *Service +} + +// Get the ForwardingRule named by key. +func (g *GCEAlphaForwardingRules) Get(ctx context.Context, key meta.Key) (*alpha.ForwardingRule, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "ForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("alpha"), + Service: "ForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.ForwardingRules.Get(projectID, key.Region, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all ForwardingRule objects. +func (g *GCEAlphaForwardingRules) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.ForwardingRule, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "ForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("alpha"), + Service: "ForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.ForwardingRules.List(projectID, region) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*alpha.ForwardingRule + f := func(l *alpha.ForwardingRuleList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert ForwardingRule with key of value obj. +func (g *GCEAlphaForwardingRules) Insert(ctx context.Context, key meta.Key, obj *alpha.ForwardingRule) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "ForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("alpha"), + Service: "ForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.Alpha.ForwardingRules.Insert(projectID, key.Region, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the ForwardingRule referenced by key. +func (g *GCEAlphaForwardingRules) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "ForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("alpha"), + Service: "ForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.ForwardingRules.Delete(projectID, key.Region, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// GlobalForwardingRules is an interface that allows for mocking of GlobalForwardingRules. +type GlobalForwardingRules interface { + Get(ctx context.Context, key meta.Key) (*ga.ForwardingRule, error) + List(ctx context.Context, fl *filter.F) ([]*ga.ForwardingRule, error) + Insert(ctx context.Context, key meta.Key, obj *ga.ForwardingRule) error + Delete(ctx context.Context, key meta.Key) error + SetTarget(context.Context, meta.Key, *ga.TargetReference) error +} + +// NewMockGlobalForwardingRules returns a new mock for GlobalForwardingRules. +func NewMockGlobalForwardingRules(objs map[meta.Key]*MockGlobalForwardingRulesObj) *MockGlobalForwardingRules { + mock := &MockGlobalForwardingRules{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockGlobalForwardingRules is the mock for GlobalForwardingRules. +type MockGlobalForwardingRules struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockGlobalForwardingRulesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockGlobalForwardingRules, ctx context.Context, key meta.Key) (bool, *ga.ForwardingRule, error) + ListHook func(m *MockGlobalForwardingRules, ctx context.Context, fl *filter.F) (bool, []*ga.ForwardingRule, error) + InsertHook func(m *MockGlobalForwardingRules, ctx context.Context, key meta.Key, obj *ga.ForwardingRule) (bool, error) + DeleteHook func(m *MockGlobalForwardingRules, ctx context.Context, key meta.Key) (bool, error) + SetTargetHook func(*MockGlobalForwardingRules, context.Context, meta.Key, *ga.TargetReference) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockGlobalForwardingRules) Get(ctx context.Context, key meta.Key) (*ga.ForwardingRule, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockGlobalForwardingRules.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockGlobalForwardingRules.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockGlobalForwardingRules.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockGlobalForwardingRules %v not found", key), + } + glog.V(5).Infof("MockGlobalForwardingRules.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockGlobalForwardingRules) List(ctx context.Context, fl *filter.F) ([]*ga.ForwardingRule, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockGlobalForwardingRules.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockGlobalForwardingRules.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.ForwardingRule + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockGlobalForwardingRules.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockGlobalForwardingRules) Insert(ctx context.Context, key meta.Key, obj *ga.ForwardingRule) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockGlobalForwardingRules.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockGlobalForwardingRules.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockGlobalForwardingRules %v exists", key), + } + glog.V(5).Infof("MockGlobalForwardingRules.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "forwardingRules", key) + } + + m.Objects[key] = &MockGlobalForwardingRulesObj{obj} + glog.V(5).Infof("MockGlobalForwardingRules.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockGlobalForwardingRules) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockGlobalForwardingRules.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockGlobalForwardingRules.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockGlobalForwardingRules %v not found", key), + } + glog.V(5).Infof("MockGlobalForwardingRules.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockGlobalForwardingRules.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockGlobalForwardingRules) Obj(o *ga.ForwardingRule) *MockGlobalForwardingRulesObj { + return &MockGlobalForwardingRulesObj{o} +} + +// SetTarget is a mock for the corresponding method. +func (m *MockGlobalForwardingRules) SetTarget(ctx context.Context, key meta.Key, arg0 *ga.TargetReference) error { + if m.SetTargetHook != nil { + return m.SetTargetHook(m, ctx, key, arg0) + } + return nil +} + +// GCEGlobalForwardingRules is a simplifying adapter for the GCE GlobalForwardingRules. +type GCEGlobalForwardingRules struct { + s *Service +} + +// Get the ForwardingRule named by key. +func (g *GCEGlobalForwardingRules) Get(ctx context.Context, key meta.Key) (*ga.ForwardingRule, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "GlobalForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "GlobalForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.GlobalForwardingRules.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all ForwardingRule objects. +func (g *GCEGlobalForwardingRules) List(ctx context.Context, fl *filter.F) ([]*ga.ForwardingRule, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "GlobalForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "GlobalForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.GlobalForwardingRules.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.ForwardingRule + f := func(l *ga.ForwardingRuleList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert ForwardingRule with key of value obj. +func (g *GCEGlobalForwardingRules) Insert(ctx context.Context, key meta.Key, obj *ga.ForwardingRule) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "GlobalForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "GlobalForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.GlobalForwardingRules.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the ForwardingRule referenced by key. +func (g *GCEGlobalForwardingRules) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "GlobalForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "GlobalForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.GlobalForwardingRules.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// SetTarget is a method on GCEGlobalForwardingRules. +func (g *GCEGlobalForwardingRules) SetTarget(ctx context.Context, key meta.Key, arg0 *ga.TargetReference) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "GlobalForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "SetTarget", + Version: meta.Version("ga"), + Service: "GlobalForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.GlobalForwardingRules.SetTarget(projectID, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// HealthChecks is an interface that allows for mocking of HealthChecks. +type HealthChecks interface { + Get(ctx context.Context, key meta.Key) (*ga.HealthCheck, error) + List(ctx context.Context, fl *filter.F) ([]*ga.HealthCheck, error) + Insert(ctx context.Context, key meta.Key, obj *ga.HealthCheck) error + Delete(ctx context.Context, key meta.Key) error + Update(context.Context, meta.Key, *ga.HealthCheck) error +} + +// NewMockHealthChecks returns a new mock for HealthChecks. +func NewMockHealthChecks(objs map[meta.Key]*MockHealthChecksObj) *MockHealthChecks { + mock := &MockHealthChecks{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockHealthChecks is the mock for HealthChecks. +type MockHealthChecks struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockHealthChecksObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockHealthChecks, ctx context.Context, key meta.Key) (bool, *ga.HealthCheck, error) + ListHook func(m *MockHealthChecks, ctx context.Context, fl *filter.F) (bool, []*ga.HealthCheck, error) + InsertHook func(m *MockHealthChecks, ctx context.Context, key meta.Key, obj *ga.HealthCheck) (bool, error) + DeleteHook func(m *MockHealthChecks, ctx context.Context, key meta.Key) (bool, error) + UpdateHook func(*MockHealthChecks, context.Context, meta.Key, *ga.HealthCheck) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockHealthChecks) Get(ctx context.Context, key meta.Key) (*ga.HealthCheck, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockHealthChecks.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockHealthChecks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockHealthChecks.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockHealthChecks %v not found", key), + } + glog.V(5).Infof("MockHealthChecks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockHealthChecks) List(ctx context.Context, fl *filter.F) ([]*ga.HealthCheck, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockHealthChecks.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockHealthChecks.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.HealthCheck + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockHealthChecks.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockHealthChecks) Insert(ctx context.Context, key meta.Key, obj *ga.HealthCheck) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockHealthChecks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockHealthChecks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockHealthChecks %v exists", key), + } + glog.V(5).Infof("MockHealthChecks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "healthChecks", key) + } + + m.Objects[key] = &MockHealthChecksObj{obj} + glog.V(5).Infof("MockHealthChecks.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockHealthChecks) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockHealthChecks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockHealthChecks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockHealthChecks %v not found", key), + } + glog.V(5).Infof("MockHealthChecks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockHealthChecks.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockHealthChecks) Obj(o *ga.HealthCheck) *MockHealthChecksObj { + return &MockHealthChecksObj{o} +} + +// Update is a mock for the corresponding method. +func (m *MockHealthChecks) Update(ctx context.Context, key meta.Key, arg0 *ga.HealthCheck) error { + if m.UpdateHook != nil { + return m.UpdateHook(m, ctx, key, arg0) + } + return nil +} + +// GCEHealthChecks is a simplifying adapter for the GCE HealthChecks. +type GCEHealthChecks struct { + s *Service +} + +// Get the HealthCheck named by key. +func (g *GCEHealthChecks) Get(ctx context.Context, key meta.Key) (*ga.HealthCheck, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "HealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.HealthChecks.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all HealthCheck objects. +func (g *GCEHealthChecks) List(ctx context.Context, fl *filter.F) ([]*ga.HealthCheck, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "HealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.HealthChecks.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.HealthCheck + f := func(l *ga.HealthCheckList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert HealthCheck with key of value obj. +func (g *GCEHealthChecks) Insert(ctx context.Context, key meta.Key, obj *ga.HealthCheck) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "HealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.HealthChecks.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the HealthCheck referenced by key. +func (g *GCEHealthChecks) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "HealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.HealthChecks.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Update is a method on GCEHealthChecks. +func (g *GCEHealthChecks) Update(ctx context.Context, key meta.Key, arg0 *ga.HealthCheck) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Update", + Version: meta.Version("ga"), + Service: "HealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.HealthChecks.Update(projectID, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AlphaHealthChecks is an interface that allows for mocking of HealthChecks. +type AlphaHealthChecks interface { + Get(ctx context.Context, key meta.Key) (*alpha.HealthCheck, error) + List(ctx context.Context, fl *filter.F) ([]*alpha.HealthCheck, error) + Insert(ctx context.Context, key meta.Key, obj *alpha.HealthCheck) error + Delete(ctx context.Context, key meta.Key) error + Update(context.Context, meta.Key, *alpha.HealthCheck) error +} + +// NewMockAlphaHealthChecks returns a new mock for HealthChecks. +func NewMockAlphaHealthChecks(objs map[meta.Key]*MockHealthChecksObj) *MockAlphaHealthChecks { + mock := &MockAlphaHealthChecks{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockAlphaHealthChecks is the mock for HealthChecks. +type MockAlphaHealthChecks struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockHealthChecksObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockAlphaHealthChecks, ctx context.Context, key meta.Key) (bool, *alpha.HealthCheck, error) + ListHook func(m *MockAlphaHealthChecks, ctx context.Context, fl *filter.F) (bool, []*alpha.HealthCheck, error) + InsertHook func(m *MockAlphaHealthChecks, ctx context.Context, key meta.Key, obj *alpha.HealthCheck) (bool, error) + DeleteHook func(m *MockAlphaHealthChecks, ctx context.Context, key meta.Key) (bool, error) + UpdateHook func(*MockAlphaHealthChecks, context.Context, meta.Key, *alpha.HealthCheck) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockAlphaHealthChecks) Get(ctx context.Context, key meta.Key) (*alpha.HealthCheck, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaHealthChecks.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockAlphaHealthChecks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToAlpha() + glog.V(5).Infof("MockAlphaHealthChecks.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaHealthChecks %v not found", key), + } + glog.V(5).Infof("MockAlphaHealthChecks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockAlphaHealthChecks) List(ctx context.Context, fl *filter.F) ([]*alpha.HealthCheck, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockAlphaHealthChecks.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockAlphaHealthChecks.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*alpha.HealthCheck + for _, obj := range m.Objects { + if !fl.Match(obj.ToAlpha()) { + continue + } + objs = append(objs, obj.ToAlpha()) + } + + glog.V(5).Infof("MockAlphaHealthChecks.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockAlphaHealthChecks) Insert(ctx context.Context, key meta.Key, obj *alpha.HealthCheck) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockAlphaHealthChecks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockAlphaHealthChecks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockAlphaHealthChecks %v exists", key), + } + glog.V(5).Infof("MockAlphaHealthChecks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionAlpha, "mock-project", "healthChecks", key) + } + + m.Objects[key] = &MockHealthChecksObj{obj} + glog.V(5).Infof("MockAlphaHealthChecks.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockAlphaHealthChecks) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaHealthChecks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockAlphaHealthChecks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaHealthChecks %v not found", key), + } + glog.V(5).Infof("MockAlphaHealthChecks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockAlphaHealthChecks.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockAlphaHealthChecks) Obj(o *alpha.HealthCheck) *MockHealthChecksObj { + return &MockHealthChecksObj{o} +} + +// Update is a mock for the corresponding method. +func (m *MockAlphaHealthChecks) Update(ctx context.Context, key meta.Key, arg0 *alpha.HealthCheck) error { + if m.UpdateHook != nil { + return m.UpdateHook(m, ctx, key, arg0) + } + return nil +} + +// GCEAlphaHealthChecks is a simplifying adapter for the GCE HealthChecks. +type GCEAlphaHealthChecks struct { + s *Service +} + +// Get the HealthCheck named by key. +func (g *GCEAlphaHealthChecks) Get(ctx context.Context, key meta.Key) (*alpha.HealthCheck, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "HealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("alpha"), + Service: "HealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.HealthChecks.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all HealthCheck objects. +func (g *GCEAlphaHealthChecks) List(ctx context.Context, fl *filter.F) ([]*alpha.HealthCheck, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "HealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("alpha"), + Service: "HealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.HealthChecks.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*alpha.HealthCheck + f := func(l *alpha.HealthCheckList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert HealthCheck with key of value obj. +func (g *GCEAlphaHealthChecks) Insert(ctx context.Context, key meta.Key, obj *alpha.HealthCheck) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "HealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("alpha"), + Service: "HealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.Alpha.HealthChecks.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the HealthCheck referenced by key. +func (g *GCEAlphaHealthChecks) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "HealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("alpha"), + Service: "HealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.HealthChecks.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Update is a method on GCEAlphaHealthChecks. +func (g *GCEAlphaHealthChecks) Update(ctx context.Context, key meta.Key, arg0 *alpha.HealthCheck) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "HealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Update", + Version: meta.Version("alpha"), + Service: "HealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.HealthChecks.Update(projectID, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// HttpHealthChecks is an interface that allows for mocking of HttpHealthChecks. +type HttpHealthChecks interface { + Get(ctx context.Context, key meta.Key) (*ga.HttpHealthCheck, error) + List(ctx context.Context, fl *filter.F) ([]*ga.HttpHealthCheck, error) + Insert(ctx context.Context, key meta.Key, obj *ga.HttpHealthCheck) error + Delete(ctx context.Context, key meta.Key) error + Update(context.Context, meta.Key, *ga.HttpHealthCheck) error +} + +// NewMockHttpHealthChecks returns a new mock for HttpHealthChecks. +func NewMockHttpHealthChecks(objs map[meta.Key]*MockHttpHealthChecksObj) *MockHttpHealthChecks { + mock := &MockHttpHealthChecks{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockHttpHealthChecks is the mock for HttpHealthChecks. +type MockHttpHealthChecks struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockHttpHealthChecksObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockHttpHealthChecks, ctx context.Context, key meta.Key) (bool, *ga.HttpHealthCheck, error) + ListHook func(m *MockHttpHealthChecks, ctx context.Context, fl *filter.F) (bool, []*ga.HttpHealthCheck, error) + InsertHook func(m *MockHttpHealthChecks, ctx context.Context, key meta.Key, obj *ga.HttpHealthCheck) (bool, error) + DeleteHook func(m *MockHttpHealthChecks, ctx context.Context, key meta.Key) (bool, error) + UpdateHook func(*MockHttpHealthChecks, context.Context, meta.Key, *ga.HttpHealthCheck) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockHttpHealthChecks) Get(ctx context.Context, key meta.Key) (*ga.HttpHealthCheck, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockHttpHealthChecks.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockHttpHealthChecks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockHttpHealthChecks.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockHttpHealthChecks %v not found", key), + } + glog.V(5).Infof("MockHttpHealthChecks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockHttpHealthChecks) List(ctx context.Context, fl *filter.F) ([]*ga.HttpHealthCheck, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockHttpHealthChecks.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockHttpHealthChecks.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.HttpHealthCheck + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockHttpHealthChecks.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockHttpHealthChecks) Insert(ctx context.Context, key meta.Key, obj *ga.HttpHealthCheck) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockHttpHealthChecks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockHttpHealthChecks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockHttpHealthChecks %v exists", key), + } + glog.V(5).Infof("MockHttpHealthChecks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "httpHealthChecks", key) + } + + m.Objects[key] = &MockHttpHealthChecksObj{obj} + glog.V(5).Infof("MockHttpHealthChecks.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockHttpHealthChecks) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockHttpHealthChecks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockHttpHealthChecks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockHttpHealthChecks %v not found", key), + } + glog.V(5).Infof("MockHttpHealthChecks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockHttpHealthChecks.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockHttpHealthChecks) Obj(o *ga.HttpHealthCheck) *MockHttpHealthChecksObj { + return &MockHttpHealthChecksObj{o} +} + +// Update is a mock for the corresponding method. +func (m *MockHttpHealthChecks) Update(ctx context.Context, key meta.Key, arg0 *ga.HttpHealthCheck) error { + if m.UpdateHook != nil { + return m.UpdateHook(m, ctx, key, arg0) + } + return nil +} + +// GCEHttpHealthChecks is a simplifying adapter for the GCE HttpHealthChecks. +type GCEHttpHealthChecks struct { + s *Service +} + +// Get the HttpHealthCheck named by key. +func (g *GCEHttpHealthChecks) Get(ctx context.Context, key meta.Key) (*ga.HttpHealthCheck, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HttpHealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "HttpHealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.HttpHealthChecks.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all HttpHealthCheck objects. +func (g *GCEHttpHealthChecks) List(ctx context.Context, fl *filter.F) ([]*ga.HttpHealthCheck, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HttpHealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "HttpHealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.HttpHealthChecks.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.HttpHealthCheck + f := func(l *ga.HttpHealthCheckList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert HttpHealthCheck with key of value obj. +func (g *GCEHttpHealthChecks) Insert(ctx context.Context, key meta.Key, obj *ga.HttpHealthCheck) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HttpHealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "HttpHealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.HttpHealthChecks.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the HttpHealthCheck referenced by key. +func (g *GCEHttpHealthChecks) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HttpHealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "HttpHealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.HttpHealthChecks.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Update is a method on GCEHttpHealthChecks. +func (g *GCEHttpHealthChecks) Update(ctx context.Context, key meta.Key, arg0 *ga.HttpHealthCheck) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HttpHealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Update", + Version: meta.Version("ga"), + Service: "HttpHealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.HttpHealthChecks.Update(projectID, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// HttpsHealthChecks is an interface that allows for mocking of HttpsHealthChecks. +type HttpsHealthChecks interface { + Get(ctx context.Context, key meta.Key) (*ga.HttpsHealthCheck, error) + List(ctx context.Context, fl *filter.F) ([]*ga.HttpsHealthCheck, error) + Insert(ctx context.Context, key meta.Key, obj *ga.HttpsHealthCheck) error + Delete(ctx context.Context, key meta.Key) error + Update(context.Context, meta.Key, *ga.HttpsHealthCheck) error +} + +// NewMockHttpsHealthChecks returns a new mock for HttpsHealthChecks. +func NewMockHttpsHealthChecks(objs map[meta.Key]*MockHttpsHealthChecksObj) *MockHttpsHealthChecks { + mock := &MockHttpsHealthChecks{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockHttpsHealthChecks is the mock for HttpsHealthChecks. +type MockHttpsHealthChecks struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockHttpsHealthChecksObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockHttpsHealthChecks, ctx context.Context, key meta.Key) (bool, *ga.HttpsHealthCheck, error) + ListHook func(m *MockHttpsHealthChecks, ctx context.Context, fl *filter.F) (bool, []*ga.HttpsHealthCheck, error) + InsertHook func(m *MockHttpsHealthChecks, ctx context.Context, key meta.Key, obj *ga.HttpsHealthCheck) (bool, error) + DeleteHook func(m *MockHttpsHealthChecks, ctx context.Context, key meta.Key) (bool, error) + UpdateHook func(*MockHttpsHealthChecks, context.Context, meta.Key, *ga.HttpsHealthCheck) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockHttpsHealthChecks) Get(ctx context.Context, key meta.Key) (*ga.HttpsHealthCheck, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockHttpsHealthChecks.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockHttpsHealthChecks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockHttpsHealthChecks.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockHttpsHealthChecks %v not found", key), + } + glog.V(5).Infof("MockHttpsHealthChecks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockHttpsHealthChecks) List(ctx context.Context, fl *filter.F) ([]*ga.HttpsHealthCheck, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockHttpsHealthChecks.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockHttpsHealthChecks.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.HttpsHealthCheck + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockHttpsHealthChecks.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockHttpsHealthChecks) Insert(ctx context.Context, key meta.Key, obj *ga.HttpsHealthCheck) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockHttpsHealthChecks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockHttpsHealthChecks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockHttpsHealthChecks %v exists", key), + } + glog.V(5).Infof("MockHttpsHealthChecks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "httpsHealthChecks", key) + } + + m.Objects[key] = &MockHttpsHealthChecksObj{obj} + glog.V(5).Infof("MockHttpsHealthChecks.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockHttpsHealthChecks) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockHttpsHealthChecks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockHttpsHealthChecks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockHttpsHealthChecks %v not found", key), + } + glog.V(5).Infof("MockHttpsHealthChecks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockHttpsHealthChecks.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockHttpsHealthChecks) Obj(o *ga.HttpsHealthCheck) *MockHttpsHealthChecksObj { + return &MockHttpsHealthChecksObj{o} +} + +// Update is a mock for the corresponding method. +func (m *MockHttpsHealthChecks) Update(ctx context.Context, key meta.Key, arg0 *ga.HttpsHealthCheck) error { + if m.UpdateHook != nil { + return m.UpdateHook(m, ctx, key, arg0) + } + return nil +} + +// GCEHttpsHealthChecks is a simplifying adapter for the GCE HttpsHealthChecks. +type GCEHttpsHealthChecks struct { + s *Service +} + +// Get the HttpsHealthCheck named by key. +func (g *GCEHttpsHealthChecks) Get(ctx context.Context, key meta.Key) (*ga.HttpsHealthCheck, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HttpsHealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "HttpsHealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.HttpsHealthChecks.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all HttpsHealthCheck objects. +func (g *GCEHttpsHealthChecks) List(ctx context.Context, fl *filter.F) ([]*ga.HttpsHealthCheck, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HttpsHealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "HttpsHealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.HttpsHealthChecks.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.HttpsHealthCheck + f := func(l *ga.HttpsHealthCheckList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert HttpsHealthCheck with key of value obj. +func (g *GCEHttpsHealthChecks) Insert(ctx context.Context, key meta.Key, obj *ga.HttpsHealthCheck) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HttpsHealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "HttpsHealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.HttpsHealthChecks.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the HttpsHealthCheck referenced by key. +func (g *GCEHttpsHealthChecks) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HttpsHealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "HttpsHealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.HttpsHealthChecks.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Update is a method on GCEHttpsHealthChecks. +func (g *GCEHttpsHealthChecks) Update(ctx context.Context, key meta.Key, arg0 *ga.HttpsHealthCheck) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HttpsHealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Update", + Version: meta.Version("ga"), + Service: "HttpsHealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.HttpsHealthChecks.Update(projectID, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// InstanceGroups is an interface that allows for mocking of InstanceGroups. +type InstanceGroups interface { + Get(ctx context.Context, key meta.Key) (*ga.InstanceGroup, error) + List(ctx context.Context, zone string, fl *filter.F) ([]*ga.InstanceGroup, error) + Insert(ctx context.Context, key meta.Key, obj *ga.InstanceGroup) error + Delete(ctx context.Context, key meta.Key) error + AddInstances(context.Context, meta.Key, *ga.InstanceGroupsAddInstancesRequest) error + ListInstances(context.Context, meta.Key, *ga.InstanceGroupsListInstancesRequest) (*ga.InstanceGroupsListInstances, error) + RemoveInstances(context.Context, meta.Key, *ga.InstanceGroupsRemoveInstancesRequest) error + SetNamedPorts(context.Context, meta.Key, *ga.InstanceGroupsSetNamedPortsRequest) error +} + +// NewMockInstanceGroups returns a new mock for InstanceGroups. +func NewMockInstanceGroups(objs map[meta.Key]*MockInstanceGroupsObj) *MockInstanceGroups { + mock := &MockInstanceGroups{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockInstanceGroups is the mock for InstanceGroups. +type MockInstanceGroups struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockInstanceGroupsObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockInstanceGroups, ctx context.Context, key meta.Key) (bool, *ga.InstanceGroup, error) + ListHook func(m *MockInstanceGroups, ctx context.Context, zone string, fl *filter.F) (bool, []*ga.InstanceGroup, error) + InsertHook func(m *MockInstanceGroups, ctx context.Context, key meta.Key, obj *ga.InstanceGroup) (bool, error) + DeleteHook func(m *MockInstanceGroups, ctx context.Context, key meta.Key) (bool, error) + AddInstancesHook func(*MockInstanceGroups, context.Context, meta.Key, *ga.InstanceGroupsAddInstancesRequest) error + ListInstancesHook func(*MockInstanceGroups, context.Context, meta.Key, *ga.InstanceGroupsListInstancesRequest) (*ga.InstanceGroupsListInstances, error) + RemoveInstancesHook func(*MockInstanceGroups, context.Context, meta.Key, *ga.InstanceGroupsRemoveInstancesRequest) error + SetNamedPortsHook func(*MockInstanceGroups, context.Context, meta.Key, *ga.InstanceGroupsSetNamedPortsRequest) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockInstanceGroups) Get(ctx context.Context, key meta.Key) (*ga.InstanceGroup, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockInstanceGroups.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockInstanceGroups.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockInstanceGroups.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockInstanceGroups %v not found", key), + } + glog.V(5).Infof("MockInstanceGroups.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given zone. +func (m *MockInstanceGroups) List(ctx context.Context, zone string, fl *filter.F) ([]*ga.InstanceGroup, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, zone, fl); intercept { + glog.V(5).Infof("MockInstanceGroups.List(%v, %q, %v) = [%v items], %v", ctx, zone, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockInstanceGroups.List(%v, %q, %v) = nil, %v", ctx, zone, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.InstanceGroup + for key, obj := range m.Objects { + if key.Zone != zone { + continue + } + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockInstanceGroups.List(%v, %q, %v) = [%v items], nil", ctx, zone, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockInstanceGroups) Insert(ctx context.Context, key meta.Key, obj *ga.InstanceGroup) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockInstanceGroups.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockInstanceGroups.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockInstanceGroups %v exists", key), + } + glog.V(5).Infof("MockInstanceGroups.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "instanceGroups", key) + } + + m.Objects[key] = &MockInstanceGroupsObj{obj} + glog.V(5).Infof("MockInstanceGroups.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockInstanceGroups) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockInstanceGroups.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockInstanceGroups.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockInstanceGroups %v not found", key), + } + glog.V(5).Infof("MockInstanceGroups.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockInstanceGroups.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockInstanceGroups) Obj(o *ga.InstanceGroup) *MockInstanceGroupsObj { + return &MockInstanceGroupsObj{o} +} + +// AddInstances is a mock for the corresponding method. +func (m *MockInstanceGroups) AddInstances(ctx context.Context, key meta.Key, arg0 *ga.InstanceGroupsAddInstancesRequest) error { + if m.AddInstancesHook != nil { + return m.AddInstancesHook(m, ctx, key, arg0) + } + return nil +} + +// ListInstances is a mock for the corresponding method. +func (m *MockInstanceGroups) ListInstances(ctx context.Context, key meta.Key, arg0 *ga.InstanceGroupsListInstancesRequest) (*ga.InstanceGroupsListInstances, error) { + if m.ListInstancesHook != nil { + return m.ListInstancesHook(m, ctx, key, arg0) + } + return nil, fmt.Errorf("ListInstancesHook must be set") +} + +// RemoveInstances is a mock for the corresponding method. +func (m *MockInstanceGroups) RemoveInstances(ctx context.Context, key meta.Key, arg0 *ga.InstanceGroupsRemoveInstancesRequest) error { + if m.RemoveInstancesHook != nil { + return m.RemoveInstancesHook(m, ctx, key, arg0) + } + return nil +} + +// SetNamedPorts is a mock for the corresponding method. +func (m *MockInstanceGroups) SetNamedPorts(ctx context.Context, key meta.Key, arg0 *ga.InstanceGroupsSetNamedPortsRequest) error { + if m.SetNamedPortsHook != nil { + return m.SetNamedPortsHook(m, ctx, key, arg0) + } + return nil +} + +// GCEInstanceGroups is a simplifying adapter for the GCE InstanceGroups. +type GCEInstanceGroups struct { + s *Service +} + +// Get the InstanceGroup named by key. +func (g *GCEInstanceGroups) Get(ctx context.Context, key meta.Key) (*ga.InstanceGroup, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "InstanceGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "InstanceGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.InstanceGroups.Get(projectID, key.Zone, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all InstanceGroup objects. +func (g *GCEInstanceGroups) List(ctx context.Context, zone string, fl *filter.F) ([]*ga.InstanceGroup, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "InstanceGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "InstanceGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.InstanceGroups.List(projectID, zone) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.InstanceGroup + f := func(l *ga.InstanceGroupList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert InstanceGroup with key of value obj. +func (g *GCEInstanceGroups) Insert(ctx context.Context, key meta.Key, obj *ga.InstanceGroup) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "InstanceGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "InstanceGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.InstanceGroups.Insert(projectID, key.Zone, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the InstanceGroup referenced by key. +func (g *GCEInstanceGroups) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "InstanceGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "InstanceGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.InstanceGroups.Delete(projectID, key.Zone, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AddInstances is a method on GCEInstanceGroups. +func (g *GCEInstanceGroups) AddInstances(ctx context.Context, key meta.Key, arg0 *ga.InstanceGroupsAddInstancesRequest) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "InstanceGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "AddInstances", + Version: meta.Version("ga"), + Service: "InstanceGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.InstanceGroups.AddInstances(projectID, key.Zone, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// ListInstances is a method on GCEInstanceGroups. +func (g *GCEInstanceGroups) ListInstances(ctx context.Context, key meta.Key, arg0 *ga.InstanceGroupsListInstancesRequest) (*ga.InstanceGroupsListInstances, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "InstanceGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "ListInstances", + Version: meta.Version("ga"), + Service: "InstanceGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.InstanceGroups.ListInstances(projectID, key.Zone, key.Name, arg0) + call.Context(ctx) + return call.Do() +} + +// RemoveInstances is a method on GCEInstanceGroups. +func (g *GCEInstanceGroups) RemoveInstances(ctx context.Context, key meta.Key, arg0 *ga.InstanceGroupsRemoveInstancesRequest) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "InstanceGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "RemoveInstances", + Version: meta.Version("ga"), + Service: "InstanceGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.InstanceGroups.RemoveInstances(projectID, key.Zone, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// SetNamedPorts is a method on GCEInstanceGroups. +func (g *GCEInstanceGroups) SetNamedPorts(ctx context.Context, key meta.Key, arg0 *ga.InstanceGroupsSetNamedPortsRequest) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "InstanceGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "SetNamedPorts", + Version: meta.Version("ga"), + Service: "InstanceGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.InstanceGroups.SetNamedPorts(projectID, key.Zone, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Instances is an interface that allows for mocking of Instances. +type Instances interface { + Get(ctx context.Context, key meta.Key) (*ga.Instance, error) + List(ctx context.Context, zone string, fl *filter.F) ([]*ga.Instance, error) + Insert(ctx context.Context, key meta.Key, obj *ga.Instance) error + Delete(ctx context.Context, key meta.Key) error + AttachDisk(context.Context, meta.Key, *ga.AttachedDisk) error + DetachDisk(context.Context, meta.Key, string) error +} + +// NewMockInstances returns a new mock for Instances. +func NewMockInstances(objs map[meta.Key]*MockInstancesObj) *MockInstances { + mock := &MockInstances{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockInstances is the mock for Instances. +type MockInstances struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockInstancesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockInstances, ctx context.Context, key meta.Key) (bool, *ga.Instance, error) + ListHook func(m *MockInstances, ctx context.Context, zone string, fl *filter.F) (bool, []*ga.Instance, error) + InsertHook func(m *MockInstances, ctx context.Context, key meta.Key, obj *ga.Instance) (bool, error) + DeleteHook func(m *MockInstances, ctx context.Context, key meta.Key) (bool, error) + AttachDiskHook func(*MockInstances, context.Context, meta.Key, *ga.AttachedDisk) error + DetachDiskHook func(*MockInstances, context.Context, meta.Key, string) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockInstances) Get(ctx context.Context, key meta.Key) (*ga.Instance, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockInstances.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockInstances.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockInstances.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockInstances %v not found", key), + } + glog.V(5).Infof("MockInstances.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given zone. +func (m *MockInstances) List(ctx context.Context, zone string, fl *filter.F) ([]*ga.Instance, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, zone, fl); intercept { + glog.V(5).Infof("MockInstances.List(%v, %q, %v) = [%v items], %v", ctx, zone, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockInstances.List(%v, %q, %v) = nil, %v", ctx, zone, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.Instance + for key, obj := range m.Objects { + if key.Zone != zone { + continue + } + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockInstances.List(%v, %q, %v) = [%v items], nil", ctx, zone, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockInstances) Insert(ctx context.Context, key meta.Key, obj *ga.Instance) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockInstances.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockInstances.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockInstances %v exists", key), + } + glog.V(5).Infof("MockInstances.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "instances", key) + } + + m.Objects[key] = &MockInstancesObj{obj} + glog.V(5).Infof("MockInstances.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockInstances) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockInstances.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockInstances.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockInstances %v not found", key), + } + glog.V(5).Infof("MockInstances.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockInstances.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockInstances) Obj(o *ga.Instance) *MockInstancesObj { + return &MockInstancesObj{o} +} + +// AttachDisk is a mock for the corresponding method. +func (m *MockInstances) AttachDisk(ctx context.Context, key meta.Key, arg0 *ga.AttachedDisk) error { + if m.AttachDiskHook != nil { + return m.AttachDiskHook(m, ctx, key, arg0) + } + return nil +} + +// DetachDisk is a mock for the corresponding method. +func (m *MockInstances) DetachDisk(ctx context.Context, key meta.Key, arg0 string) error { + if m.DetachDiskHook != nil { + return m.DetachDiskHook(m, ctx, key, arg0) + } + return nil +} + +// GCEInstances is a simplifying adapter for the GCE Instances. +type GCEInstances struct { + s *Service +} + +// Get the Instance named by key. +func (g *GCEInstances) Get(ctx context.Context, key meta.Key) (*ga.Instance, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Instances.Get(projectID, key.Zone, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Instance objects. +func (g *GCEInstances) List(ctx context.Context, zone string, fl *filter.F) ([]*ga.Instance, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Instances.List(projectID, zone) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.Instance + f := func(l *ga.InstanceList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert Instance with key of value obj. +func (g *GCEInstances) Insert(ctx context.Context, key meta.Key, obj *ga.Instance) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.Instances.Insert(projectID, key.Zone, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the Instance referenced by key. +func (g *GCEInstances) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.Instances.Delete(projectID, key.Zone, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AttachDisk is a method on GCEInstances. +func (g *GCEInstances) AttachDisk(ctx context.Context, key meta.Key, arg0 *ga.AttachedDisk) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "AttachDisk", + Version: meta.Version("ga"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.Instances.AttachDisk(projectID, key.Zone, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// DetachDisk is a method on GCEInstances. +func (g *GCEInstances) DetachDisk(ctx context.Context, key meta.Key, arg0 string) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "DetachDisk", + Version: meta.Version("ga"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.Instances.DetachDisk(projectID, key.Zone, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// BetaInstances is an interface that allows for mocking of Instances. +type BetaInstances interface { + Get(ctx context.Context, key meta.Key) (*beta.Instance, error) + List(ctx context.Context, zone string, fl *filter.F) ([]*beta.Instance, error) + Insert(ctx context.Context, key meta.Key, obj *beta.Instance) error + Delete(ctx context.Context, key meta.Key) error + AttachDisk(context.Context, meta.Key, *beta.AttachedDisk) error + DetachDisk(context.Context, meta.Key, string) error +} + +// NewMockBetaInstances returns a new mock for Instances. +func NewMockBetaInstances(objs map[meta.Key]*MockInstancesObj) *MockBetaInstances { + mock := &MockBetaInstances{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockBetaInstances is the mock for Instances. +type MockBetaInstances struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockInstancesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockBetaInstances, ctx context.Context, key meta.Key) (bool, *beta.Instance, error) + ListHook func(m *MockBetaInstances, ctx context.Context, zone string, fl *filter.F) (bool, []*beta.Instance, error) + InsertHook func(m *MockBetaInstances, ctx context.Context, key meta.Key, obj *beta.Instance) (bool, error) + DeleteHook func(m *MockBetaInstances, ctx context.Context, key meta.Key) (bool, error) + AttachDiskHook func(*MockBetaInstances, context.Context, meta.Key, *beta.AttachedDisk) error + DetachDiskHook func(*MockBetaInstances, context.Context, meta.Key, string) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockBetaInstances) Get(ctx context.Context, key meta.Key) (*beta.Instance, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockBetaInstances.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockBetaInstances.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToBeta() + glog.V(5).Infof("MockBetaInstances.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockBetaInstances %v not found", key), + } + glog.V(5).Infof("MockBetaInstances.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given zone. +func (m *MockBetaInstances) List(ctx context.Context, zone string, fl *filter.F) ([]*beta.Instance, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, zone, fl); intercept { + glog.V(5).Infof("MockBetaInstances.List(%v, %q, %v) = [%v items], %v", ctx, zone, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockBetaInstances.List(%v, %q, %v) = nil, %v", ctx, zone, fl, err) + + return nil, *m.ListError + } + + var objs []*beta.Instance + for key, obj := range m.Objects { + if key.Zone != zone { + continue + } + if !fl.Match(obj.ToBeta()) { + continue + } + objs = append(objs, obj.ToBeta()) + } + + glog.V(5).Infof("MockBetaInstances.List(%v, %q, %v) = [%v items], nil", ctx, zone, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockBetaInstances) Insert(ctx context.Context, key meta.Key, obj *beta.Instance) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockBetaInstances.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockBetaInstances.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockBetaInstances %v exists", key), + } + glog.V(5).Infof("MockBetaInstances.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionBeta, "mock-project", "instances", key) + } + + m.Objects[key] = &MockInstancesObj{obj} + glog.V(5).Infof("MockBetaInstances.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockBetaInstances) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockBetaInstances.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockBetaInstances.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockBetaInstances %v not found", key), + } + glog.V(5).Infof("MockBetaInstances.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockBetaInstances.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockBetaInstances) Obj(o *beta.Instance) *MockInstancesObj { + return &MockInstancesObj{o} +} + +// AttachDisk is a mock for the corresponding method. +func (m *MockBetaInstances) AttachDisk(ctx context.Context, key meta.Key, arg0 *beta.AttachedDisk) error { + if m.AttachDiskHook != nil { + return m.AttachDiskHook(m, ctx, key, arg0) + } + return nil +} + +// DetachDisk is a mock for the corresponding method. +func (m *MockBetaInstances) DetachDisk(ctx context.Context, key meta.Key, arg0 string) error { + if m.DetachDiskHook != nil { + return m.DetachDiskHook(m, ctx, key, arg0) + } + return nil +} + +// GCEBetaInstances is a simplifying adapter for the GCE Instances. +type GCEBetaInstances struct { + s *Service +} + +// Get the Instance named by key. +func (g *GCEBetaInstances) Get(ctx context.Context, key meta.Key) (*beta.Instance, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("beta"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Beta.Instances.Get(projectID, key.Zone, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Instance objects. +func (g *GCEBetaInstances) List(ctx context.Context, zone string, fl *filter.F) ([]*beta.Instance, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("beta"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Beta.Instances.List(projectID, zone) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*beta.Instance + f := func(l *beta.InstanceList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert Instance with key of value obj. +func (g *GCEBetaInstances) Insert(ctx context.Context, key meta.Key, obj *beta.Instance) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("beta"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.Beta.Instances.Insert(projectID, key.Zone, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the Instance referenced by key. +func (g *GCEBetaInstances) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("beta"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Beta.Instances.Delete(projectID, key.Zone, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AttachDisk is a method on GCEBetaInstances. +func (g *GCEBetaInstances) AttachDisk(ctx context.Context, key meta.Key, arg0 *beta.AttachedDisk) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "AttachDisk", + Version: meta.Version("beta"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Beta.Instances.AttachDisk(projectID, key.Zone, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// DetachDisk is a method on GCEBetaInstances. +func (g *GCEBetaInstances) DetachDisk(ctx context.Context, key meta.Key, arg0 string) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "DetachDisk", + Version: meta.Version("beta"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Beta.Instances.DetachDisk(projectID, key.Zone, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AlphaInstances is an interface that allows for mocking of Instances. +type AlphaInstances interface { + Get(ctx context.Context, key meta.Key) (*alpha.Instance, error) + List(ctx context.Context, zone string, fl *filter.F) ([]*alpha.Instance, error) + Insert(ctx context.Context, key meta.Key, obj *alpha.Instance) error + Delete(ctx context.Context, key meta.Key) error + AttachDisk(context.Context, meta.Key, *alpha.AttachedDisk) error + DetachDisk(context.Context, meta.Key, string) error + UpdateNetworkInterface(context.Context, meta.Key, string, *alpha.NetworkInterface) error +} + +// NewMockAlphaInstances returns a new mock for Instances. +func NewMockAlphaInstances(objs map[meta.Key]*MockInstancesObj) *MockAlphaInstances { + mock := &MockAlphaInstances{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockAlphaInstances is the mock for Instances. +type MockAlphaInstances struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockInstancesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockAlphaInstances, ctx context.Context, key meta.Key) (bool, *alpha.Instance, error) + ListHook func(m *MockAlphaInstances, ctx context.Context, zone string, fl *filter.F) (bool, []*alpha.Instance, error) + InsertHook func(m *MockAlphaInstances, ctx context.Context, key meta.Key, obj *alpha.Instance) (bool, error) + DeleteHook func(m *MockAlphaInstances, ctx context.Context, key meta.Key) (bool, error) + AttachDiskHook func(*MockAlphaInstances, context.Context, meta.Key, *alpha.AttachedDisk) error + DetachDiskHook func(*MockAlphaInstances, context.Context, meta.Key, string) error + UpdateNetworkInterfaceHook func(*MockAlphaInstances, context.Context, meta.Key, string, *alpha.NetworkInterface) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockAlphaInstances) Get(ctx context.Context, key meta.Key) (*alpha.Instance, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaInstances.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockAlphaInstances.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToAlpha() + glog.V(5).Infof("MockAlphaInstances.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaInstances %v not found", key), + } + glog.V(5).Infof("MockAlphaInstances.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given zone. +func (m *MockAlphaInstances) List(ctx context.Context, zone string, fl *filter.F) ([]*alpha.Instance, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, zone, fl); intercept { + glog.V(5).Infof("MockAlphaInstances.List(%v, %q, %v) = [%v items], %v", ctx, zone, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockAlphaInstances.List(%v, %q, %v) = nil, %v", ctx, zone, fl, err) + + return nil, *m.ListError + } + + var objs []*alpha.Instance + for key, obj := range m.Objects { + if key.Zone != zone { + continue + } + if !fl.Match(obj.ToAlpha()) { + continue + } + objs = append(objs, obj.ToAlpha()) + } + + glog.V(5).Infof("MockAlphaInstances.List(%v, %q, %v) = [%v items], nil", ctx, zone, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockAlphaInstances) Insert(ctx context.Context, key meta.Key, obj *alpha.Instance) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockAlphaInstances.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockAlphaInstances.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockAlphaInstances %v exists", key), + } + glog.V(5).Infof("MockAlphaInstances.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionAlpha, "mock-project", "instances", key) + } + + m.Objects[key] = &MockInstancesObj{obj} + glog.V(5).Infof("MockAlphaInstances.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockAlphaInstances) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaInstances.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockAlphaInstances.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaInstances %v not found", key), + } + glog.V(5).Infof("MockAlphaInstances.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockAlphaInstances.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockAlphaInstances) Obj(o *alpha.Instance) *MockInstancesObj { + return &MockInstancesObj{o} +} + +// AttachDisk is a mock for the corresponding method. +func (m *MockAlphaInstances) AttachDisk(ctx context.Context, key meta.Key, arg0 *alpha.AttachedDisk) error { + if m.AttachDiskHook != nil { + return m.AttachDiskHook(m, ctx, key, arg0) + } + return nil +} + +// DetachDisk is a mock for the corresponding method. +func (m *MockAlphaInstances) DetachDisk(ctx context.Context, key meta.Key, arg0 string) error { + if m.DetachDiskHook != nil { + return m.DetachDiskHook(m, ctx, key, arg0) + } + return nil +} + +// UpdateNetworkInterface is a mock for the corresponding method. +func (m *MockAlphaInstances) UpdateNetworkInterface(ctx context.Context, key meta.Key, arg0 string, arg1 *alpha.NetworkInterface) error { + if m.UpdateNetworkInterfaceHook != nil { + return m.UpdateNetworkInterfaceHook(m, ctx, key, arg0, arg1) + } + return nil +} + +// GCEAlphaInstances is a simplifying adapter for the GCE Instances. +type GCEAlphaInstances struct { + s *Service +} + +// Get the Instance named by key. +func (g *GCEAlphaInstances) Get(ctx context.Context, key meta.Key) (*alpha.Instance, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("alpha"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.Instances.Get(projectID, key.Zone, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Instance objects. +func (g *GCEAlphaInstances) List(ctx context.Context, zone string, fl *filter.F) ([]*alpha.Instance, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("alpha"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.Instances.List(projectID, zone) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*alpha.Instance + f := func(l *alpha.InstanceList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert Instance with key of value obj. +func (g *GCEAlphaInstances) Insert(ctx context.Context, key meta.Key, obj *alpha.Instance) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("alpha"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.Alpha.Instances.Insert(projectID, key.Zone, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the Instance referenced by key. +func (g *GCEAlphaInstances) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("alpha"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.Instances.Delete(projectID, key.Zone, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AttachDisk is a method on GCEAlphaInstances. +func (g *GCEAlphaInstances) AttachDisk(ctx context.Context, key meta.Key, arg0 *alpha.AttachedDisk) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "AttachDisk", + Version: meta.Version("alpha"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.Instances.AttachDisk(projectID, key.Zone, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// DetachDisk is a method on GCEAlphaInstances. +func (g *GCEAlphaInstances) DetachDisk(ctx context.Context, key meta.Key, arg0 string) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "DetachDisk", + Version: meta.Version("alpha"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.Instances.DetachDisk(projectID, key.Zone, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// UpdateNetworkInterface is a method on GCEAlphaInstances. +func (g *GCEAlphaInstances) UpdateNetworkInterface(ctx context.Context, key meta.Key, arg0 string, arg1 *alpha.NetworkInterface) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "UpdateNetworkInterface", + Version: meta.Version("alpha"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.Instances.UpdateNetworkInterface(projectID, key.Zone, key.Name, arg0, arg1) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AlphaNetworkEndpointGroups is an interface that allows for mocking of NetworkEndpointGroups. +type AlphaNetworkEndpointGroups interface { + Get(ctx context.Context, key meta.Key) (*alpha.NetworkEndpointGroup, error) + List(ctx context.Context, zone string, fl *filter.F) ([]*alpha.NetworkEndpointGroup, error) + Insert(ctx context.Context, key meta.Key, obj *alpha.NetworkEndpointGroup) error + Delete(ctx context.Context, key meta.Key) error + AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*alpha.NetworkEndpointGroup, error) + AttachNetworkEndpoints(context.Context, meta.Key, *alpha.NetworkEndpointGroupsAttachEndpointsRequest) error + DetachNetworkEndpoints(context.Context, meta.Key, *alpha.NetworkEndpointGroupsDetachEndpointsRequest) error +} + +// NewMockAlphaNetworkEndpointGroups returns a new mock for NetworkEndpointGroups. +func NewMockAlphaNetworkEndpointGroups(objs map[meta.Key]*MockNetworkEndpointGroupsObj) *MockAlphaNetworkEndpointGroups { + mock := &MockAlphaNetworkEndpointGroups{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockAlphaNetworkEndpointGroups is the mock for NetworkEndpointGroups. +type MockAlphaNetworkEndpointGroups struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockNetworkEndpointGroupsObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + AggregatedListError *error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockAlphaNetworkEndpointGroups, ctx context.Context, key meta.Key) (bool, *alpha.NetworkEndpointGroup, error) + ListHook func(m *MockAlphaNetworkEndpointGroups, ctx context.Context, zone string, fl *filter.F) (bool, []*alpha.NetworkEndpointGroup, error) + InsertHook func(m *MockAlphaNetworkEndpointGroups, ctx context.Context, key meta.Key, obj *alpha.NetworkEndpointGroup) (bool, error) + DeleteHook func(m *MockAlphaNetworkEndpointGroups, ctx context.Context, key meta.Key) (bool, error) + AggregatedListHook func(m *MockAlphaNetworkEndpointGroups, ctx context.Context, fl *filter.F) (bool, map[string][]*alpha.NetworkEndpointGroup, error) + AttachNetworkEndpointsHook func(*MockAlphaNetworkEndpointGroups, context.Context, meta.Key, *alpha.NetworkEndpointGroupsAttachEndpointsRequest) error + DetachNetworkEndpointsHook func(*MockAlphaNetworkEndpointGroups, context.Context, meta.Key, *alpha.NetworkEndpointGroupsDetachEndpointsRequest) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockAlphaNetworkEndpointGroups) Get(ctx context.Context, key meta.Key) (*alpha.NetworkEndpointGroup, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToAlpha() + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaNetworkEndpointGroups %v not found", key), + } + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given zone. +func (m *MockAlphaNetworkEndpointGroups) List(ctx context.Context, zone string, fl *filter.F) ([]*alpha.NetworkEndpointGroup, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, zone, fl); intercept { + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.List(%v, %q, %v) = [%v items], %v", ctx, zone, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.List(%v, %q, %v) = nil, %v", ctx, zone, fl, err) + + return nil, *m.ListError + } + + var objs []*alpha.NetworkEndpointGroup + for key, obj := range m.Objects { + if key.Zone != zone { + continue + } + if !fl.Match(obj.ToAlpha()) { + continue + } + objs = append(objs, obj.ToAlpha()) + } + + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.List(%v, %q, %v) = [%v items], nil", ctx, zone, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockAlphaNetworkEndpointGroups) Insert(ctx context.Context, key meta.Key, obj *alpha.NetworkEndpointGroup) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockAlphaNetworkEndpointGroups %v exists", key), + } + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionAlpha, "mock-project", "networkEndpointGroups", key) + } + + m.Objects[key] = &MockNetworkEndpointGroupsObj{obj} + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockAlphaNetworkEndpointGroups) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaNetworkEndpointGroups %v not found", key), + } + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// AggregatedList is a mock for AggregatedList. +func (m *MockAlphaNetworkEndpointGroups) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*alpha.NetworkEndpointGroup, error) { + if m.AggregatedListHook != nil { + if intercept, objs, err := m.AggregatedListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.AggregatedList(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.AggregatedListError != nil { + err := *m.AggregatedListError + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.AggregatedList(%v, %v) = nil, %v", ctx, fl, err) + return nil, err + } + + objs := map[string][]*alpha.NetworkEndpointGroup{} + for _, obj := range m.Objects { + res, err := ParseResourceURL(obj.ToAlpha().SelfLink) + location := res.Key.Zone + if err != nil { + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.AggregatedList(%v, %v) = nil, %v", ctx, fl, err) + return nil, err + } + if !fl.Match(obj.ToAlpha()) { + continue + } + objs[location] = append(objs[location], obj.ToAlpha()) + } + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.AggregatedList(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Obj wraps the object for use in the mock. +func (m *MockAlphaNetworkEndpointGroups) Obj(o *alpha.NetworkEndpointGroup) *MockNetworkEndpointGroupsObj { + return &MockNetworkEndpointGroupsObj{o} +} + +// AttachNetworkEndpoints is a mock for the corresponding method. +func (m *MockAlphaNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key meta.Key, arg0 *alpha.NetworkEndpointGroupsAttachEndpointsRequest) error { + if m.AttachNetworkEndpointsHook != nil { + return m.AttachNetworkEndpointsHook(m, ctx, key, arg0) + } + return nil +} + +// DetachNetworkEndpoints is a mock for the corresponding method. +func (m *MockAlphaNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key meta.Key, arg0 *alpha.NetworkEndpointGroupsDetachEndpointsRequest) error { + if m.DetachNetworkEndpointsHook != nil { + return m.DetachNetworkEndpointsHook(m, ctx, key, arg0) + } + return nil +} + +// GCEAlphaNetworkEndpointGroups is a simplifying adapter for the GCE NetworkEndpointGroups. +type GCEAlphaNetworkEndpointGroups struct { + s *Service +} + +// Get the NetworkEndpointGroup named by key. +func (g *GCEAlphaNetworkEndpointGroups) Get(ctx context.Context, key meta.Key) (*alpha.NetworkEndpointGroup, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "NetworkEndpointGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("alpha"), + Service: "NetworkEndpointGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.NetworkEndpointGroups.Get(projectID, key.Zone, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all NetworkEndpointGroup objects. +func (g *GCEAlphaNetworkEndpointGroups) List(ctx context.Context, zone string, fl *filter.F) ([]*alpha.NetworkEndpointGroup, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "NetworkEndpointGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("alpha"), + Service: "NetworkEndpointGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.NetworkEndpointGroups.List(projectID, zone) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*alpha.NetworkEndpointGroup + f := func(l *alpha.NetworkEndpointGroupList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert NetworkEndpointGroup with key of value obj. +func (g *GCEAlphaNetworkEndpointGroups) Insert(ctx context.Context, key meta.Key, obj *alpha.NetworkEndpointGroup) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "NetworkEndpointGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("alpha"), + Service: "NetworkEndpointGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.Alpha.NetworkEndpointGroups.Insert(projectID, key.Zone, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the NetworkEndpointGroup referenced by key. +func (g *GCEAlphaNetworkEndpointGroups) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "NetworkEndpointGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("alpha"), + Service: "NetworkEndpointGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.NetworkEndpointGroups.Delete(projectID, key.Zone, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AggregatedList lists all resources of the given type across all locations. +func (g *GCEAlphaNetworkEndpointGroups) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*alpha.NetworkEndpointGroup, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "NetworkEndpointGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "AggregatedList", + Version: meta.Version("alpha"), + Service: "NetworkEndpointGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + + call := g.s.Alpha.NetworkEndpointGroups.AggregatedList(projectID) + call.Context(ctx) + if fl != filter.None { + call.Filter(fl.String()) + } + + all := map[string][]*alpha.NetworkEndpointGroup{} + f := func(l *alpha.NetworkEndpointGroupAggregatedList) error { + for k, v := range l.Items { + all[k] = append(all[k], v.NetworkEndpointGroups...) + } + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// AttachNetworkEndpoints is a method on GCEAlphaNetworkEndpointGroups. +func (g *GCEAlphaNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key meta.Key, arg0 *alpha.NetworkEndpointGroupsAttachEndpointsRequest) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "NetworkEndpointGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "AttachNetworkEndpoints", + Version: meta.Version("alpha"), + Service: "NetworkEndpointGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.NetworkEndpointGroups.AttachNetworkEndpoints(projectID, key.Zone, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// DetachNetworkEndpoints is a method on GCEAlphaNetworkEndpointGroups. +func (g *GCEAlphaNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key meta.Key, arg0 *alpha.NetworkEndpointGroupsDetachEndpointsRequest) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "NetworkEndpointGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "DetachNetworkEndpoints", + Version: meta.Version("alpha"), + Service: "NetworkEndpointGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.NetworkEndpointGroups.DetachNetworkEndpoints(projectID, key.Zone, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Projects is an interface that allows for mocking of Projects. +type Projects interface { + // ProjectsOps is an interface with additional non-CRUD type methods. + // This interface is expected to be implemented by hand (non-autogenerated). + ProjectsOps +} + +// NewMockProjects returns a new mock for Projects. +func NewMockProjects(objs map[meta.Key]*MockProjectsObj) *MockProjects { + mock := &MockProjects{ + Objects: objs, + } + return mock +} + +// MockProjects is the mock for Projects. +type MockProjects struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockProjectsObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Obj wraps the object for use in the mock. +func (m *MockProjects) Obj(o *ga.Project) *MockProjectsObj { + return &MockProjectsObj{o} +} + +// GCEProjects is a simplifying adapter for the GCE Projects. +type GCEProjects struct { + s *Service +} + +// Regions is an interface that allows for mocking of Regions. +type Regions interface { + Get(ctx context.Context, key meta.Key) (*ga.Region, error) + List(ctx context.Context, fl *filter.F) ([]*ga.Region, error) +} + +// NewMockRegions returns a new mock for Regions. +func NewMockRegions(objs map[meta.Key]*MockRegionsObj) *MockRegions { + mock := &MockRegions{ + Objects: objs, + GetError: map[meta.Key]error{}, + } + return mock +} + +// MockRegions is the mock for Regions. +type MockRegions struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockRegionsObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockRegions, ctx context.Context, key meta.Key) (bool, *ga.Region, error) + ListHook func(m *MockRegions, ctx context.Context, fl *filter.F) (bool, []*ga.Region, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockRegions) Get(ctx context.Context, key meta.Key) (*ga.Region, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockRegions.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockRegions.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockRegions.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockRegions %v not found", key), + } + glog.V(5).Infof("MockRegions.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockRegions) List(ctx context.Context, fl *filter.F) ([]*ga.Region, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockRegions.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockRegions.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.Region + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockRegions.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Obj wraps the object for use in the mock. +func (m *MockRegions) Obj(o *ga.Region) *MockRegionsObj { + return &MockRegionsObj{o} +} + +// GCERegions is a simplifying adapter for the GCE Regions. +type GCERegions struct { + s *Service +} + +// Get the Region named by key. +func (g *GCERegions) Get(ctx context.Context, key meta.Key) (*ga.Region, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Regions") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "Regions", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Regions.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Region objects. +func (g *GCERegions) List(ctx context.Context, fl *filter.F) ([]*ga.Region, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Regions") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "Regions", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Regions.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.Region + f := func(l *ga.RegionList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Routes is an interface that allows for mocking of Routes. +type Routes interface { + Get(ctx context.Context, key meta.Key) (*ga.Route, error) + List(ctx context.Context, fl *filter.F) ([]*ga.Route, error) + Insert(ctx context.Context, key meta.Key, obj *ga.Route) error + Delete(ctx context.Context, key meta.Key) error +} + +// NewMockRoutes returns a new mock for Routes. +func NewMockRoutes(objs map[meta.Key]*MockRoutesObj) *MockRoutes { + mock := &MockRoutes{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockRoutes is the mock for Routes. +type MockRoutes struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockRoutesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockRoutes, ctx context.Context, key meta.Key) (bool, *ga.Route, error) + ListHook func(m *MockRoutes, ctx context.Context, fl *filter.F) (bool, []*ga.Route, error) + InsertHook func(m *MockRoutes, ctx context.Context, key meta.Key, obj *ga.Route) (bool, error) + DeleteHook func(m *MockRoutes, ctx context.Context, key meta.Key) (bool, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockRoutes) Get(ctx context.Context, key meta.Key) (*ga.Route, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockRoutes.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockRoutes.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockRoutes.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockRoutes %v not found", key), + } + glog.V(5).Infof("MockRoutes.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockRoutes) List(ctx context.Context, fl *filter.F) ([]*ga.Route, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockRoutes.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockRoutes.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.Route + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockRoutes.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockRoutes) Insert(ctx context.Context, key meta.Key, obj *ga.Route) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockRoutes.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockRoutes.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockRoutes %v exists", key), + } + glog.V(5).Infof("MockRoutes.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "routes", key) + } + + m.Objects[key] = &MockRoutesObj{obj} + glog.V(5).Infof("MockRoutes.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockRoutes) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockRoutes.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockRoutes.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockRoutes %v not found", key), + } + glog.V(5).Infof("MockRoutes.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockRoutes.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockRoutes) Obj(o *ga.Route) *MockRoutesObj { + return &MockRoutesObj{o} +} + +// GCERoutes is a simplifying adapter for the GCE Routes. +type GCERoutes struct { + s *Service +} + +// Get the Route named by key. +func (g *GCERoutes) Get(ctx context.Context, key meta.Key) (*ga.Route, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Routes") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "Routes", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Routes.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Route objects. +func (g *GCERoutes) List(ctx context.Context, fl *filter.F) ([]*ga.Route, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Routes") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "Routes", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Routes.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.Route + f := func(l *ga.RouteList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert Route with key of value obj. +func (g *GCERoutes) Insert(ctx context.Context, key meta.Key, obj *ga.Route) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Routes") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "Routes", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.Routes.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the Route referenced by key. +func (g *GCERoutes) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Routes") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "Routes", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.Routes.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// SslCertificates is an interface that allows for mocking of SslCertificates. +type SslCertificates interface { + Get(ctx context.Context, key meta.Key) (*ga.SslCertificate, error) + List(ctx context.Context, fl *filter.F) ([]*ga.SslCertificate, error) + Insert(ctx context.Context, key meta.Key, obj *ga.SslCertificate) error + Delete(ctx context.Context, key meta.Key) error +} + +// NewMockSslCertificates returns a new mock for SslCertificates. +func NewMockSslCertificates(objs map[meta.Key]*MockSslCertificatesObj) *MockSslCertificates { + mock := &MockSslCertificates{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockSslCertificates is the mock for SslCertificates. +type MockSslCertificates struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockSslCertificatesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockSslCertificates, ctx context.Context, key meta.Key) (bool, *ga.SslCertificate, error) + ListHook func(m *MockSslCertificates, ctx context.Context, fl *filter.F) (bool, []*ga.SslCertificate, error) + InsertHook func(m *MockSslCertificates, ctx context.Context, key meta.Key, obj *ga.SslCertificate) (bool, error) + DeleteHook func(m *MockSslCertificates, ctx context.Context, key meta.Key) (bool, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockSslCertificates) Get(ctx context.Context, key meta.Key) (*ga.SslCertificate, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockSslCertificates.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockSslCertificates.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockSslCertificates.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockSslCertificates %v not found", key), + } + glog.V(5).Infof("MockSslCertificates.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockSslCertificates) List(ctx context.Context, fl *filter.F) ([]*ga.SslCertificate, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockSslCertificates.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockSslCertificates.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.SslCertificate + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockSslCertificates.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockSslCertificates) Insert(ctx context.Context, key meta.Key, obj *ga.SslCertificate) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockSslCertificates.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockSslCertificates.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockSslCertificates %v exists", key), + } + glog.V(5).Infof("MockSslCertificates.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "sslCertificates", key) + } + + m.Objects[key] = &MockSslCertificatesObj{obj} + glog.V(5).Infof("MockSslCertificates.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockSslCertificates) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockSslCertificates.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockSslCertificates.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockSslCertificates %v not found", key), + } + glog.V(5).Infof("MockSslCertificates.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockSslCertificates.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockSslCertificates) Obj(o *ga.SslCertificate) *MockSslCertificatesObj { + return &MockSslCertificatesObj{o} +} + +// GCESslCertificates is a simplifying adapter for the GCE SslCertificates. +type GCESslCertificates struct { + s *Service +} + +// Get the SslCertificate named by key. +func (g *GCESslCertificates) Get(ctx context.Context, key meta.Key) (*ga.SslCertificate, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "SslCertificates") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "SslCertificates", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.SslCertificates.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all SslCertificate objects. +func (g *GCESslCertificates) List(ctx context.Context, fl *filter.F) ([]*ga.SslCertificate, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "SslCertificates") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "SslCertificates", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.SslCertificates.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.SslCertificate + f := func(l *ga.SslCertificateList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert SslCertificate with key of value obj. +func (g *GCESslCertificates) Insert(ctx context.Context, key meta.Key, obj *ga.SslCertificate) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "SslCertificates") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "SslCertificates", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.SslCertificates.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the SslCertificate referenced by key. +func (g *GCESslCertificates) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "SslCertificates") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "SslCertificates", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.SslCertificates.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// TargetHttpProxies is an interface that allows for mocking of TargetHttpProxies. +type TargetHttpProxies interface { + Get(ctx context.Context, key meta.Key) (*ga.TargetHttpProxy, error) + List(ctx context.Context, fl *filter.F) ([]*ga.TargetHttpProxy, error) + Insert(ctx context.Context, key meta.Key, obj *ga.TargetHttpProxy) error + Delete(ctx context.Context, key meta.Key) error + SetUrlMap(context.Context, meta.Key, *ga.UrlMapReference) error +} + +// NewMockTargetHttpProxies returns a new mock for TargetHttpProxies. +func NewMockTargetHttpProxies(objs map[meta.Key]*MockTargetHttpProxiesObj) *MockTargetHttpProxies { + mock := &MockTargetHttpProxies{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockTargetHttpProxies is the mock for TargetHttpProxies. +type MockTargetHttpProxies struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockTargetHttpProxiesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockTargetHttpProxies, ctx context.Context, key meta.Key) (bool, *ga.TargetHttpProxy, error) + ListHook func(m *MockTargetHttpProxies, ctx context.Context, fl *filter.F) (bool, []*ga.TargetHttpProxy, error) + InsertHook func(m *MockTargetHttpProxies, ctx context.Context, key meta.Key, obj *ga.TargetHttpProxy) (bool, error) + DeleteHook func(m *MockTargetHttpProxies, ctx context.Context, key meta.Key) (bool, error) + SetUrlMapHook func(*MockTargetHttpProxies, context.Context, meta.Key, *ga.UrlMapReference) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockTargetHttpProxies) Get(ctx context.Context, key meta.Key) (*ga.TargetHttpProxy, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockTargetHttpProxies.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockTargetHttpProxies.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockTargetHttpProxies.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockTargetHttpProxies %v not found", key), + } + glog.V(5).Infof("MockTargetHttpProxies.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockTargetHttpProxies) List(ctx context.Context, fl *filter.F) ([]*ga.TargetHttpProxy, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockTargetHttpProxies.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockTargetHttpProxies.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.TargetHttpProxy + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockTargetHttpProxies.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockTargetHttpProxies) Insert(ctx context.Context, key meta.Key, obj *ga.TargetHttpProxy) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockTargetHttpProxies.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockTargetHttpProxies.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockTargetHttpProxies %v exists", key), + } + glog.V(5).Infof("MockTargetHttpProxies.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "targetHttpProxies", key) + } + + m.Objects[key] = &MockTargetHttpProxiesObj{obj} + glog.V(5).Infof("MockTargetHttpProxies.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockTargetHttpProxies) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockTargetHttpProxies.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockTargetHttpProxies.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockTargetHttpProxies %v not found", key), + } + glog.V(5).Infof("MockTargetHttpProxies.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockTargetHttpProxies.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockTargetHttpProxies) Obj(o *ga.TargetHttpProxy) *MockTargetHttpProxiesObj { + return &MockTargetHttpProxiesObj{o} +} + +// SetUrlMap is a mock for the corresponding method. +func (m *MockTargetHttpProxies) SetUrlMap(ctx context.Context, key meta.Key, arg0 *ga.UrlMapReference) error { + if m.SetUrlMapHook != nil { + return m.SetUrlMapHook(m, ctx, key, arg0) + } + return nil +} + +// GCETargetHttpProxies is a simplifying adapter for the GCE TargetHttpProxies. +type GCETargetHttpProxies struct { + s *Service +} + +// Get the TargetHttpProxy named by key. +func (g *GCETargetHttpProxies) Get(ctx context.Context, key meta.Key) (*ga.TargetHttpProxy, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetHttpProxies") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "TargetHttpProxies", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.TargetHttpProxies.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all TargetHttpProxy objects. +func (g *GCETargetHttpProxies) List(ctx context.Context, fl *filter.F) ([]*ga.TargetHttpProxy, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetHttpProxies") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "TargetHttpProxies", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.TargetHttpProxies.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.TargetHttpProxy + f := func(l *ga.TargetHttpProxyList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert TargetHttpProxy with key of value obj. +func (g *GCETargetHttpProxies) Insert(ctx context.Context, key meta.Key, obj *ga.TargetHttpProxy) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetHttpProxies") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "TargetHttpProxies", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.TargetHttpProxies.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the TargetHttpProxy referenced by key. +func (g *GCETargetHttpProxies) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetHttpProxies") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "TargetHttpProxies", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.TargetHttpProxies.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// SetUrlMap is a method on GCETargetHttpProxies. +func (g *GCETargetHttpProxies) SetUrlMap(ctx context.Context, key meta.Key, arg0 *ga.UrlMapReference) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetHttpProxies") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "SetUrlMap", + Version: meta.Version("ga"), + Service: "TargetHttpProxies", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.TargetHttpProxies.SetUrlMap(projectID, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// TargetHttpsProxies is an interface that allows for mocking of TargetHttpsProxies. +type TargetHttpsProxies interface { + Get(ctx context.Context, key meta.Key) (*ga.TargetHttpsProxy, error) + List(ctx context.Context, fl *filter.F) ([]*ga.TargetHttpsProxy, error) + Insert(ctx context.Context, key meta.Key, obj *ga.TargetHttpsProxy) error + Delete(ctx context.Context, key meta.Key) error + SetSslCertificates(context.Context, meta.Key, *ga.TargetHttpsProxiesSetSslCertificatesRequest) error + SetUrlMap(context.Context, meta.Key, *ga.UrlMapReference) error +} + +// NewMockTargetHttpsProxies returns a new mock for TargetHttpsProxies. +func NewMockTargetHttpsProxies(objs map[meta.Key]*MockTargetHttpsProxiesObj) *MockTargetHttpsProxies { + mock := &MockTargetHttpsProxies{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockTargetHttpsProxies is the mock for TargetHttpsProxies. +type MockTargetHttpsProxies struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockTargetHttpsProxiesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockTargetHttpsProxies, ctx context.Context, key meta.Key) (bool, *ga.TargetHttpsProxy, error) + ListHook func(m *MockTargetHttpsProxies, ctx context.Context, fl *filter.F) (bool, []*ga.TargetHttpsProxy, error) + InsertHook func(m *MockTargetHttpsProxies, ctx context.Context, key meta.Key, obj *ga.TargetHttpsProxy) (bool, error) + DeleteHook func(m *MockTargetHttpsProxies, ctx context.Context, key meta.Key) (bool, error) + SetSslCertificatesHook func(*MockTargetHttpsProxies, context.Context, meta.Key, *ga.TargetHttpsProxiesSetSslCertificatesRequest) error + SetUrlMapHook func(*MockTargetHttpsProxies, context.Context, meta.Key, *ga.UrlMapReference) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockTargetHttpsProxies) Get(ctx context.Context, key meta.Key) (*ga.TargetHttpsProxy, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockTargetHttpsProxies.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockTargetHttpsProxies.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockTargetHttpsProxies.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockTargetHttpsProxies %v not found", key), + } + glog.V(5).Infof("MockTargetHttpsProxies.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockTargetHttpsProxies) List(ctx context.Context, fl *filter.F) ([]*ga.TargetHttpsProxy, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockTargetHttpsProxies.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockTargetHttpsProxies.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.TargetHttpsProxy + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockTargetHttpsProxies.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockTargetHttpsProxies) Insert(ctx context.Context, key meta.Key, obj *ga.TargetHttpsProxy) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockTargetHttpsProxies.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockTargetHttpsProxies.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockTargetHttpsProxies %v exists", key), + } + glog.V(5).Infof("MockTargetHttpsProxies.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "targetHttpsProxies", key) + } + + m.Objects[key] = &MockTargetHttpsProxiesObj{obj} + glog.V(5).Infof("MockTargetHttpsProxies.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockTargetHttpsProxies) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockTargetHttpsProxies.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockTargetHttpsProxies.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockTargetHttpsProxies %v not found", key), + } + glog.V(5).Infof("MockTargetHttpsProxies.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockTargetHttpsProxies.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockTargetHttpsProxies) Obj(o *ga.TargetHttpsProxy) *MockTargetHttpsProxiesObj { + return &MockTargetHttpsProxiesObj{o} +} + +// SetSslCertificates is a mock for the corresponding method. +func (m *MockTargetHttpsProxies) SetSslCertificates(ctx context.Context, key meta.Key, arg0 *ga.TargetHttpsProxiesSetSslCertificatesRequest) error { + if m.SetSslCertificatesHook != nil { + return m.SetSslCertificatesHook(m, ctx, key, arg0) + } + return nil +} + +// SetUrlMap is a mock for the corresponding method. +func (m *MockTargetHttpsProxies) SetUrlMap(ctx context.Context, key meta.Key, arg0 *ga.UrlMapReference) error { + if m.SetUrlMapHook != nil { + return m.SetUrlMapHook(m, ctx, key, arg0) + } + return nil +} + +// GCETargetHttpsProxies is a simplifying adapter for the GCE TargetHttpsProxies. +type GCETargetHttpsProxies struct { + s *Service +} + +// Get the TargetHttpsProxy named by key. +func (g *GCETargetHttpsProxies) Get(ctx context.Context, key meta.Key) (*ga.TargetHttpsProxy, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetHttpsProxies") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "TargetHttpsProxies", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.TargetHttpsProxies.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all TargetHttpsProxy objects. +func (g *GCETargetHttpsProxies) List(ctx context.Context, fl *filter.F) ([]*ga.TargetHttpsProxy, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetHttpsProxies") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "TargetHttpsProxies", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.TargetHttpsProxies.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.TargetHttpsProxy + f := func(l *ga.TargetHttpsProxyList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert TargetHttpsProxy with key of value obj. +func (g *GCETargetHttpsProxies) Insert(ctx context.Context, key meta.Key, obj *ga.TargetHttpsProxy) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetHttpsProxies") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "TargetHttpsProxies", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.TargetHttpsProxies.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the TargetHttpsProxy referenced by key. +func (g *GCETargetHttpsProxies) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetHttpsProxies") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "TargetHttpsProxies", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.TargetHttpsProxies.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// SetSslCertificates is a method on GCETargetHttpsProxies. +func (g *GCETargetHttpsProxies) SetSslCertificates(ctx context.Context, key meta.Key, arg0 *ga.TargetHttpsProxiesSetSslCertificatesRequest) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetHttpsProxies") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "SetSslCertificates", + Version: meta.Version("ga"), + Service: "TargetHttpsProxies", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.TargetHttpsProxies.SetSslCertificates(projectID, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// SetUrlMap is a method on GCETargetHttpsProxies. +func (g *GCETargetHttpsProxies) SetUrlMap(ctx context.Context, key meta.Key, arg0 *ga.UrlMapReference) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetHttpsProxies") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "SetUrlMap", + Version: meta.Version("ga"), + Service: "TargetHttpsProxies", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.TargetHttpsProxies.SetUrlMap(projectID, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// TargetPools is an interface that allows for mocking of TargetPools. +type TargetPools interface { + Get(ctx context.Context, key meta.Key) (*ga.TargetPool, error) + List(ctx context.Context, region string, fl *filter.F) ([]*ga.TargetPool, error) + Insert(ctx context.Context, key meta.Key, obj *ga.TargetPool) error + Delete(ctx context.Context, key meta.Key) error + AddInstance(context.Context, meta.Key, *ga.TargetPoolsAddInstanceRequest) error + RemoveInstance(context.Context, meta.Key, *ga.TargetPoolsRemoveInstanceRequest) error +} + +// NewMockTargetPools returns a new mock for TargetPools. +func NewMockTargetPools(objs map[meta.Key]*MockTargetPoolsObj) *MockTargetPools { + mock := &MockTargetPools{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockTargetPools is the mock for TargetPools. +type MockTargetPools struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockTargetPoolsObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockTargetPools, ctx context.Context, key meta.Key) (bool, *ga.TargetPool, error) + ListHook func(m *MockTargetPools, ctx context.Context, region string, fl *filter.F) (bool, []*ga.TargetPool, error) + InsertHook func(m *MockTargetPools, ctx context.Context, key meta.Key, obj *ga.TargetPool) (bool, error) + DeleteHook func(m *MockTargetPools, ctx context.Context, key meta.Key) (bool, error) + AddInstanceHook func(*MockTargetPools, context.Context, meta.Key, *ga.TargetPoolsAddInstanceRequest) error + RemoveInstanceHook func(*MockTargetPools, context.Context, meta.Key, *ga.TargetPoolsRemoveInstanceRequest) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockTargetPools) Get(ctx context.Context, key meta.Key) (*ga.TargetPool, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockTargetPools.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockTargetPools.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockTargetPools.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockTargetPools %v not found", key), + } + glog.V(5).Infof("MockTargetPools.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given region. +func (m *MockTargetPools) List(ctx context.Context, region string, fl *filter.F) ([]*ga.TargetPool, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, region, fl); intercept { + glog.V(5).Infof("MockTargetPools.List(%v, %q, %v) = [%v items], %v", ctx, region, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockTargetPools.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.TargetPool + for key, obj := range m.Objects { + if key.Region != region { + continue + } + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockTargetPools.List(%v, %q, %v) = [%v items], nil", ctx, region, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockTargetPools) Insert(ctx context.Context, key meta.Key, obj *ga.TargetPool) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockTargetPools.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockTargetPools.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockTargetPools %v exists", key), + } + glog.V(5).Infof("MockTargetPools.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "targetPools", key) + } + + m.Objects[key] = &MockTargetPoolsObj{obj} + glog.V(5).Infof("MockTargetPools.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockTargetPools) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockTargetPools.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockTargetPools.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockTargetPools %v not found", key), + } + glog.V(5).Infof("MockTargetPools.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockTargetPools.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockTargetPools) Obj(o *ga.TargetPool) *MockTargetPoolsObj { + return &MockTargetPoolsObj{o} +} + +// AddInstance is a mock for the corresponding method. +func (m *MockTargetPools) AddInstance(ctx context.Context, key meta.Key, arg0 *ga.TargetPoolsAddInstanceRequest) error { + if m.AddInstanceHook != nil { + return m.AddInstanceHook(m, ctx, key, arg0) + } + return nil +} + +// RemoveInstance is a mock for the corresponding method. +func (m *MockTargetPools) RemoveInstance(ctx context.Context, key meta.Key, arg0 *ga.TargetPoolsRemoveInstanceRequest) error { + if m.RemoveInstanceHook != nil { + return m.RemoveInstanceHook(m, ctx, key, arg0) + } + return nil +} + +// GCETargetPools is a simplifying adapter for the GCE TargetPools. +type GCETargetPools struct { + s *Service +} + +// Get the TargetPool named by key. +func (g *GCETargetPools) Get(ctx context.Context, key meta.Key) (*ga.TargetPool, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetPools") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "TargetPools", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.TargetPools.Get(projectID, key.Region, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all TargetPool objects. +func (g *GCETargetPools) List(ctx context.Context, region string, fl *filter.F) ([]*ga.TargetPool, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetPools") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "TargetPools", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.TargetPools.List(projectID, region) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.TargetPool + f := func(l *ga.TargetPoolList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert TargetPool with key of value obj. +func (g *GCETargetPools) Insert(ctx context.Context, key meta.Key, obj *ga.TargetPool) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetPools") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "TargetPools", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.TargetPools.Insert(projectID, key.Region, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the TargetPool referenced by key. +func (g *GCETargetPools) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetPools") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "TargetPools", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.TargetPools.Delete(projectID, key.Region, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AddInstance is a method on GCETargetPools. +func (g *GCETargetPools) AddInstance(ctx context.Context, key meta.Key, arg0 *ga.TargetPoolsAddInstanceRequest) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetPools") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "AddInstance", + Version: meta.Version("ga"), + Service: "TargetPools", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.TargetPools.AddInstance(projectID, key.Region, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// RemoveInstance is a method on GCETargetPools. +func (g *GCETargetPools) RemoveInstance(ctx context.Context, key meta.Key, arg0 *ga.TargetPoolsRemoveInstanceRequest) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetPools") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "RemoveInstance", + Version: meta.Version("ga"), + Service: "TargetPools", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.TargetPools.RemoveInstance(projectID, key.Region, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// UrlMaps is an interface that allows for mocking of UrlMaps. +type UrlMaps interface { + Get(ctx context.Context, key meta.Key) (*ga.UrlMap, error) + List(ctx context.Context, fl *filter.F) ([]*ga.UrlMap, error) + Insert(ctx context.Context, key meta.Key, obj *ga.UrlMap) error + Delete(ctx context.Context, key meta.Key) error + Update(context.Context, meta.Key, *ga.UrlMap) error +} + +// NewMockUrlMaps returns a new mock for UrlMaps. +func NewMockUrlMaps(objs map[meta.Key]*MockUrlMapsObj) *MockUrlMaps { + mock := &MockUrlMaps{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockUrlMaps is the mock for UrlMaps. +type MockUrlMaps struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockUrlMapsObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockUrlMaps, ctx context.Context, key meta.Key) (bool, *ga.UrlMap, error) + ListHook func(m *MockUrlMaps, ctx context.Context, fl *filter.F) (bool, []*ga.UrlMap, error) + InsertHook func(m *MockUrlMaps, ctx context.Context, key meta.Key, obj *ga.UrlMap) (bool, error) + DeleteHook func(m *MockUrlMaps, ctx context.Context, key meta.Key) (bool, error) + UpdateHook func(*MockUrlMaps, context.Context, meta.Key, *ga.UrlMap) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockUrlMaps) Get(ctx context.Context, key meta.Key) (*ga.UrlMap, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockUrlMaps.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockUrlMaps.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockUrlMaps.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockUrlMaps %v not found", key), + } + glog.V(5).Infof("MockUrlMaps.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockUrlMaps) List(ctx context.Context, fl *filter.F) ([]*ga.UrlMap, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockUrlMaps.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockUrlMaps.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.UrlMap + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockUrlMaps.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockUrlMaps) Insert(ctx context.Context, key meta.Key, obj *ga.UrlMap) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockUrlMaps.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockUrlMaps.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockUrlMaps %v exists", key), + } + glog.V(5).Infof("MockUrlMaps.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "urlMaps", key) + } + + m.Objects[key] = &MockUrlMapsObj{obj} + glog.V(5).Infof("MockUrlMaps.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockUrlMaps) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockUrlMaps.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockUrlMaps.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockUrlMaps %v not found", key), + } + glog.V(5).Infof("MockUrlMaps.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockUrlMaps.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockUrlMaps) Obj(o *ga.UrlMap) *MockUrlMapsObj { + return &MockUrlMapsObj{o} +} + +// Update is a mock for the corresponding method. +func (m *MockUrlMaps) Update(ctx context.Context, key meta.Key, arg0 *ga.UrlMap) error { + if m.UpdateHook != nil { + return m.UpdateHook(m, ctx, key, arg0) + } + return nil +} + +// GCEUrlMaps is a simplifying adapter for the GCE UrlMaps. +type GCEUrlMaps struct { + s *Service +} + +// Get the UrlMap named by key. +func (g *GCEUrlMaps) Get(ctx context.Context, key meta.Key) (*ga.UrlMap, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "UrlMaps") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "UrlMaps", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.UrlMaps.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all UrlMap objects. +func (g *GCEUrlMaps) List(ctx context.Context, fl *filter.F) ([]*ga.UrlMap, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "UrlMaps") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "UrlMaps", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.UrlMaps.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.UrlMap + f := func(l *ga.UrlMapList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert UrlMap with key of value obj. +func (g *GCEUrlMaps) Insert(ctx context.Context, key meta.Key, obj *ga.UrlMap) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "UrlMaps") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "UrlMaps", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.UrlMaps.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the UrlMap referenced by key. +func (g *GCEUrlMaps) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "UrlMaps") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "UrlMaps", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.UrlMaps.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Update is a method on GCEUrlMaps. +func (g *GCEUrlMaps) Update(ctx context.Context, key meta.Key, arg0 *ga.UrlMap) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "UrlMaps") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Update", + Version: meta.Version("ga"), + Service: "UrlMaps", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.UrlMaps.Update(projectID, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Zones is an interface that allows for mocking of Zones. +type Zones interface { + Get(ctx context.Context, key meta.Key) (*ga.Zone, error) + List(ctx context.Context, fl *filter.F) ([]*ga.Zone, error) +} + +// NewMockZones returns a new mock for Zones. +func NewMockZones(objs map[meta.Key]*MockZonesObj) *MockZones { + mock := &MockZones{ + Objects: objs, + GetError: map[meta.Key]error{}, + } + return mock +} + +// MockZones is the mock for Zones. +type MockZones struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockZonesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockZones, ctx context.Context, key meta.Key) (bool, *ga.Zone, error) + ListHook func(m *MockZones, ctx context.Context, fl *filter.F) (bool, []*ga.Zone, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockZones) Get(ctx context.Context, key meta.Key) (*ga.Zone, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockZones.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockZones.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockZones.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockZones %v not found", key), + } + glog.V(5).Infof("MockZones.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockZones) List(ctx context.Context, fl *filter.F) ([]*ga.Zone, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockZones.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockZones.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.Zone + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockZones.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Obj wraps the object for use in the mock. +func (m *MockZones) Obj(o *ga.Zone) *MockZonesObj { + return &MockZonesObj{o} +} + +// GCEZones is a simplifying adapter for the GCE Zones. +type GCEZones struct { + s *Service +} + +// Get the Zone named by key. +func (g *GCEZones) Get(ctx context.Context, key meta.Key) (*ga.Zone, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Zones") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "Zones", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Zones.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Zone objects. +func (g *GCEZones) List(ctx context.Context, fl *filter.F) ([]*ga.Zone, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Zones") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "Zones", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Zones.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.Zone + f := func(l *ga.ZoneList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} diff --git a/pkg/cloudprovider/providers/gce/cloud/gen_test.go b/pkg/cloudprovider/providers/gce/cloud/gen_test.go new file mode 100644 index 00000000000..cbe5d9938d3 --- /dev/null +++ b/pkg/cloudprovider/providers/gce/cloud/gen_test.go @@ -0,0 +1,1749 @@ +/* +Copyright 2018 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// This file was generated by "go run gen/main.go -mode test > gen_test.go". Do not edit +// directly. + +package cloud + +import ( + "context" + "reflect" + "testing" + + alpha "google.golang.org/api/compute/v0.alpha" + beta "google.golang.org/api/compute/v0.beta" + ga "google.golang.org/api/compute/v1" + + "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/filter" + "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta" +) + +const location = "location" + +func TestDisksGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyAlpha := meta.ZonalKey("key-alpha", "location") + key = keyAlpha + keyGA := meta.ZonalKey("key-ga", "location") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaDisks().Get(ctx, *key); err == nil { + t.Errorf("AlphaDisks().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.Disks().Get(ctx, *key); err == nil { + t.Errorf("Disks().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.Disk{} + if err := mock.AlphaDisks().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaDisks().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + { + obj := &ga.Disk{} + if err := mock.Disks().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("Disks().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaDisks().Get(ctx, *key); err != nil { + t.Errorf("AlphaDisks().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.Disks().Get(ctx, *key); err != nil { + t.Errorf("Disks().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaDisks.Objects[*keyAlpha] = mock.MockAlphaDisks.Obj(&alpha.Disk{Name: keyAlpha.Name}) + mock.MockDisks.Objects[*keyGA] = mock.MockDisks.Obj(&ga.Disk{Name: keyGA.Name}) + want := map[string]bool{ + "key-alpha": true, + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaDisks().List(ctx, location, filter.None) + if err != nil { + t.Errorf("AlphaDisks().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaDisks().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.Disks().List(ctx, location, filter.None) + if err != nil { + t.Errorf("Disks().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaDisks().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaDisks().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaDisks().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + if err := mock.Disks().Delete(ctx, *keyGA); err != nil { + t.Errorf("Disks().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.AlphaDisks().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaDisks().Delete(%v, %v) = nil; want error", ctx, key) + } + if err := mock.Disks().Delete(ctx, *keyGA); err == nil { + t.Errorf("Disks().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestFirewallsGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.Firewalls().Get(ctx, *key); err == nil { + t.Errorf("Firewalls().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.Firewall{} + if err := mock.Firewalls().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("Firewalls().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.Firewalls().Get(ctx, *key); err != nil { + t.Errorf("Firewalls().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockFirewalls.Objects[*keyGA] = mock.MockFirewalls.Obj(&ga.Firewall{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.Firewalls().List(ctx, filter.None) + if err != nil { + t.Errorf("Firewalls().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaFirewalls().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.Firewalls().Delete(ctx, *keyGA); err != nil { + t.Errorf("Firewalls().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.Firewalls().Delete(ctx, *keyGA); err == nil { + t.Errorf("Firewalls().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestInstancesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyAlpha := meta.ZonalKey("key-alpha", "location") + key = keyAlpha + keyBeta := meta.ZonalKey("key-beta", "location") + key = keyBeta + keyGA := meta.ZonalKey("key-ga", "location") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaInstances().Get(ctx, *key); err == nil { + t.Errorf("AlphaInstances().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.BetaInstances().Get(ctx, *key); err == nil { + t.Errorf("BetaInstances().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.Instances().Get(ctx, *key); err == nil { + t.Errorf("Instances().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.Instance{} + if err := mock.AlphaInstances().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaInstances().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + { + obj := &beta.Instance{} + if err := mock.BetaInstances().Insert(ctx, *keyBeta, obj); err != nil { + t.Errorf("BetaInstances().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + { + obj := &ga.Instance{} + if err := mock.Instances().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("Instances().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaInstances().Get(ctx, *key); err != nil { + t.Errorf("AlphaInstances().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.BetaInstances().Get(ctx, *key); err != nil { + t.Errorf("BetaInstances().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.Instances().Get(ctx, *key); err != nil { + t.Errorf("Instances().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaInstances.Objects[*keyAlpha] = mock.MockAlphaInstances.Obj(&alpha.Instance{Name: keyAlpha.Name}) + mock.MockBetaInstances.Objects[*keyBeta] = mock.MockBetaInstances.Obj(&beta.Instance{Name: keyBeta.Name}) + mock.MockInstances.Objects[*keyGA] = mock.MockInstances.Obj(&ga.Instance{Name: keyGA.Name}) + want := map[string]bool{ + "key-alpha": true, + "key-beta": true, + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaInstances().List(ctx, location, filter.None) + if err != nil { + t.Errorf("AlphaInstances().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaInstances().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.BetaInstances().List(ctx, location, filter.None) + if err != nil { + t.Errorf("BetaInstances().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaInstances().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.Instances().List(ctx, location, filter.None) + if err != nil { + t.Errorf("Instances().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaInstances().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaInstances().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaInstances().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + if err := mock.BetaInstances().Delete(ctx, *keyBeta); err != nil { + t.Errorf("BetaInstances().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + if err := mock.Instances().Delete(ctx, *keyGA); err != nil { + t.Errorf("Instances().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.AlphaInstances().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaInstances().Delete(%v, %v) = nil; want error", ctx, key) + } + if err := mock.BetaInstances().Delete(ctx, *keyBeta); err == nil { + t.Errorf("BetaInstances().Delete(%v, %v) = nil; want error", ctx, key) + } + if err := mock.Instances().Delete(ctx, *keyGA); err == nil { + t.Errorf("Instances().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestProjectsGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + + // Insert. + + // Get across versions. + + // List. + mock.MockProjects.Objects[*keyGA] = mock.MockProjects.Obj(&ga.Project{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + + // Delete across versions. + + // Delete not found. +} + +func TestRoutesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.Routes().Get(ctx, *key); err == nil { + t.Errorf("Routes().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.Route{} + if err := mock.Routes().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("Routes().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.Routes().Get(ctx, *key); err != nil { + t.Errorf("Routes().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockRoutes.Objects[*keyGA] = mock.MockRoutes.Obj(&ga.Route{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.Routes().List(ctx, filter.None) + if err != nil { + t.Errorf("Routes().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaRoutes().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.Routes().Delete(ctx, *keyGA); err != nil { + t.Errorf("Routes().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.Routes().Delete(ctx, *keyGA); err == nil { + t.Errorf("Routes().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestTargetPoolsGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.RegionalKey("key-ga", "location") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.TargetPools().Get(ctx, *key); err == nil { + t.Errorf("TargetPools().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.TargetPool{} + if err := mock.TargetPools().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("TargetPools().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.TargetPools().Get(ctx, *key); err != nil { + t.Errorf("TargetPools().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockTargetPools.Objects[*keyGA] = mock.MockTargetPools.Obj(&ga.TargetPool{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.TargetPools().List(ctx, location, filter.None) + if err != nil { + t.Errorf("TargetPools().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaTargetPools().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.TargetPools().Delete(ctx, *keyGA); err != nil { + t.Errorf("TargetPools().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.TargetPools().Delete(ctx, *keyGA); err == nil { + t.Errorf("TargetPools().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestGlobalForwardingRulesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.GlobalForwardingRules().Get(ctx, *key); err == nil { + t.Errorf("GlobalForwardingRules().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.ForwardingRule{} + if err := mock.GlobalForwardingRules().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("GlobalForwardingRules().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.GlobalForwardingRules().Get(ctx, *key); err != nil { + t.Errorf("GlobalForwardingRules().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockGlobalForwardingRules.Objects[*keyGA] = mock.MockGlobalForwardingRules.Obj(&ga.ForwardingRule{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.GlobalForwardingRules().List(ctx, filter.None) + if err != nil { + t.Errorf("GlobalForwardingRules().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaGlobalForwardingRules().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.GlobalForwardingRules().Delete(ctx, *keyGA); err != nil { + t.Errorf("GlobalForwardingRules().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.GlobalForwardingRules().Delete(ctx, *keyGA); err == nil { + t.Errorf("GlobalForwardingRules().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestNetworkEndpointGroupsGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyAlpha := meta.ZonalKey("key-alpha", "location") + key = keyAlpha + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaNetworkEndpointGroups().Get(ctx, *key); err == nil { + t.Errorf("AlphaNetworkEndpointGroups().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.NetworkEndpointGroup{} + if err := mock.AlphaNetworkEndpointGroups().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaNetworkEndpointGroups().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaNetworkEndpointGroups().Get(ctx, *key); err != nil { + t.Errorf("AlphaNetworkEndpointGroups().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaNetworkEndpointGroups.Objects[*keyAlpha] = mock.MockAlphaNetworkEndpointGroups.Obj(&alpha.NetworkEndpointGroup{Name: keyAlpha.Name}) + want := map[string]bool{ + "key-alpha": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaNetworkEndpointGroups().List(ctx, location, filter.None) + if err != nil { + t.Errorf("AlphaNetworkEndpointGroups().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaNetworkEndpointGroups().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaNetworkEndpointGroups().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaNetworkEndpointGroups().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.AlphaNetworkEndpointGroups().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaNetworkEndpointGroups().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestTargetHttpProxiesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.TargetHttpProxies().Get(ctx, *key); err == nil { + t.Errorf("TargetHttpProxies().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.TargetHttpProxy{} + if err := mock.TargetHttpProxies().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("TargetHttpProxies().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.TargetHttpProxies().Get(ctx, *key); err != nil { + t.Errorf("TargetHttpProxies().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockTargetHttpProxies.Objects[*keyGA] = mock.MockTargetHttpProxies.Obj(&ga.TargetHttpProxy{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.TargetHttpProxies().List(ctx, filter.None) + if err != nil { + t.Errorf("TargetHttpProxies().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaTargetHttpProxies().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.TargetHttpProxies().Delete(ctx, *keyGA); err != nil { + t.Errorf("TargetHttpProxies().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.TargetHttpProxies().Delete(ctx, *keyGA); err == nil { + t.Errorf("TargetHttpProxies().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestUrlMapsGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.UrlMaps().Get(ctx, *key); err == nil { + t.Errorf("UrlMaps().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.UrlMap{} + if err := mock.UrlMaps().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("UrlMaps().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.UrlMaps().Get(ctx, *key); err != nil { + t.Errorf("UrlMaps().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockUrlMaps.Objects[*keyGA] = mock.MockUrlMaps.Obj(&ga.UrlMap{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.UrlMaps().List(ctx, filter.None) + if err != nil { + t.Errorf("UrlMaps().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaUrlMaps().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.UrlMaps().Delete(ctx, *keyGA); err != nil { + t.Errorf("UrlMaps().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.UrlMaps().Delete(ctx, *keyGA); err == nil { + t.Errorf("UrlMaps().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestZonesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.Zones().Get(ctx, *key); err == nil { + t.Errorf("Zones().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + + // Get across versions. + + // List. + mock.MockZones.Objects[*keyGA] = mock.MockZones.Obj(&ga.Zone{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.Zones().List(ctx, filter.None) + if err != nil { + t.Errorf("Zones().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaZones().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + + // Delete not found. +} + +func TestGlobalAddressesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.GlobalAddresses().Get(ctx, *key); err == nil { + t.Errorf("GlobalAddresses().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.Address{} + if err := mock.GlobalAddresses().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("GlobalAddresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.GlobalAddresses().Get(ctx, *key); err != nil { + t.Errorf("GlobalAddresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockGlobalAddresses.Objects[*keyGA] = mock.MockGlobalAddresses.Obj(&ga.Address{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.GlobalAddresses().List(ctx, filter.None) + if err != nil { + t.Errorf("GlobalAddresses().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaGlobalAddresses().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.GlobalAddresses().Delete(ctx, *keyGA); err != nil { + t.Errorf("GlobalAddresses().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.GlobalAddresses().Delete(ctx, *keyGA); err == nil { + t.Errorf("GlobalAddresses().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestBackendServicesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyAlpha := meta.GlobalKey("key-alpha") + key = keyAlpha + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaBackendServices().Get(ctx, *key); err == nil { + t.Errorf("AlphaBackendServices().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.BackendServices().Get(ctx, *key); err == nil { + t.Errorf("BackendServices().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.BackendService{} + if err := mock.AlphaBackendServices().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaBackendServices().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + { + obj := &ga.BackendService{} + if err := mock.BackendServices().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("BackendServices().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaBackendServices().Get(ctx, *key); err != nil { + t.Errorf("AlphaBackendServices().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.BackendServices().Get(ctx, *key); err != nil { + t.Errorf("BackendServices().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaBackendServices.Objects[*keyAlpha] = mock.MockAlphaBackendServices.Obj(&alpha.BackendService{Name: keyAlpha.Name}) + mock.MockBackendServices.Objects[*keyGA] = mock.MockBackendServices.Obj(&ga.BackendService{Name: keyGA.Name}) + want := map[string]bool{ + "key-alpha": true, + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaBackendServices().List(ctx, filter.None) + if err != nil { + t.Errorf("AlphaBackendServices().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaBackendServices().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.BackendServices().List(ctx, filter.None) + if err != nil { + t.Errorf("BackendServices().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaBackendServices().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaBackendServices().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaBackendServices().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + if err := mock.BackendServices().Delete(ctx, *keyGA); err != nil { + t.Errorf("BackendServices().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.AlphaBackendServices().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaBackendServices().Delete(%v, %v) = nil; want error", ctx, key) + } + if err := mock.BackendServices().Delete(ctx, *keyGA); err == nil { + t.Errorf("BackendServices().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestForwardingRulesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyAlpha := meta.RegionalKey("key-alpha", "location") + key = keyAlpha + keyGA := meta.RegionalKey("key-ga", "location") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaForwardingRules().Get(ctx, *key); err == nil { + t.Errorf("AlphaForwardingRules().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.ForwardingRules().Get(ctx, *key); err == nil { + t.Errorf("ForwardingRules().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.ForwardingRule{} + if err := mock.AlphaForwardingRules().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaForwardingRules().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + { + obj := &ga.ForwardingRule{} + if err := mock.ForwardingRules().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("ForwardingRules().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaForwardingRules().Get(ctx, *key); err != nil { + t.Errorf("AlphaForwardingRules().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.ForwardingRules().Get(ctx, *key); err != nil { + t.Errorf("ForwardingRules().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaForwardingRules.Objects[*keyAlpha] = mock.MockAlphaForwardingRules.Obj(&alpha.ForwardingRule{Name: keyAlpha.Name}) + mock.MockForwardingRules.Objects[*keyGA] = mock.MockForwardingRules.Obj(&ga.ForwardingRule{Name: keyGA.Name}) + want := map[string]bool{ + "key-alpha": true, + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaForwardingRules().List(ctx, location, filter.None) + if err != nil { + t.Errorf("AlphaForwardingRules().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaForwardingRules().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.ForwardingRules().List(ctx, location, filter.None) + if err != nil { + t.Errorf("ForwardingRules().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaForwardingRules().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaForwardingRules().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaForwardingRules().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + if err := mock.ForwardingRules().Delete(ctx, *keyGA); err != nil { + t.Errorf("ForwardingRules().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.AlphaForwardingRules().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaForwardingRules().Delete(%v, %v) = nil; want error", ctx, key) + } + if err := mock.ForwardingRules().Delete(ctx, *keyGA); err == nil { + t.Errorf("ForwardingRules().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestRegionsGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.Regions().Get(ctx, *key); err == nil { + t.Errorf("Regions().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + + // Get across versions. + + // List. + mock.MockRegions.Objects[*keyGA] = mock.MockRegions.Obj(&ga.Region{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.Regions().List(ctx, filter.None) + if err != nil { + t.Errorf("Regions().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaRegions().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + + // Delete not found. +} + +func TestAddressesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyAlpha := meta.RegionalKey("key-alpha", "location") + key = keyAlpha + keyBeta := meta.RegionalKey("key-beta", "location") + key = keyBeta + keyGA := meta.RegionalKey("key-ga", "location") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaAddresses().Get(ctx, *key); err == nil { + t.Errorf("AlphaAddresses().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.BetaAddresses().Get(ctx, *key); err == nil { + t.Errorf("BetaAddresses().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.Addresses().Get(ctx, *key); err == nil { + t.Errorf("Addresses().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.Address{} + if err := mock.AlphaAddresses().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaAddresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + { + obj := &beta.Address{} + if err := mock.BetaAddresses().Insert(ctx, *keyBeta, obj); err != nil { + t.Errorf("BetaAddresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + { + obj := &ga.Address{} + if err := mock.Addresses().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("Addresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaAddresses().Get(ctx, *key); err != nil { + t.Errorf("AlphaAddresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.BetaAddresses().Get(ctx, *key); err != nil { + t.Errorf("BetaAddresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.Addresses().Get(ctx, *key); err != nil { + t.Errorf("Addresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaAddresses.Objects[*keyAlpha] = mock.MockAlphaAddresses.Obj(&alpha.Address{Name: keyAlpha.Name}) + mock.MockBetaAddresses.Objects[*keyBeta] = mock.MockBetaAddresses.Obj(&beta.Address{Name: keyBeta.Name}) + mock.MockAddresses.Objects[*keyGA] = mock.MockAddresses.Obj(&ga.Address{Name: keyGA.Name}) + want := map[string]bool{ + "key-alpha": true, + "key-beta": true, + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaAddresses().List(ctx, location, filter.None) + if err != nil { + t.Errorf("AlphaAddresses().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaAddresses().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.BetaAddresses().List(ctx, location, filter.None) + if err != nil { + t.Errorf("BetaAddresses().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaAddresses().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.Addresses().List(ctx, location, filter.None) + if err != nil { + t.Errorf("Addresses().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaAddresses().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaAddresses().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaAddresses().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + if err := mock.BetaAddresses().Delete(ctx, *keyBeta); err != nil { + t.Errorf("BetaAddresses().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + if err := mock.Addresses().Delete(ctx, *keyGA); err != nil { + t.Errorf("Addresses().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.AlphaAddresses().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaAddresses().Delete(%v, %v) = nil; want error", ctx, key) + } + if err := mock.BetaAddresses().Delete(ctx, *keyBeta); err == nil { + t.Errorf("BetaAddresses().Delete(%v, %v) = nil; want error", ctx, key) + } + if err := mock.Addresses().Delete(ctx, *keyGA); err == nil { + t.Errorf("Addresses().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestRegionBackendServicesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyAlpha := meta.RegionalKey("key-alpha", "location") + key = keyAlpha + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaRegionBackendServices().Get(ctx, *key); err == nil { + t.Errorf("AlphaRegionBackendServices().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.BackendService{} + if err := mock.AlphaRegionBackendServices().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaRegionBackendServices().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaRegionBackendServices().Get(ctx, *key); err != nil { + t.Errorf("AlphaRegionBackendServices().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaRegionBackendServices.Objects[*keyAlpha] = mock.MockAlphaRegionBackendServices.Obj(&alpha.BackendService{Name: keyAlpha.Name}) + want := map[string]bool{ + "key-alpha": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaRegionBackendServices().List(ctx, location, filter.None) + if err != nil { + t.Errorf("AlphaRegionBackendServices().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaRegionBackendServices().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaRegionBackendServices().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaRegionBackendServices().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.AlphaRegionBackendServices().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaRegionBackendServices().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestRegionDisksGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyAlpha := meta.RegionalKey("key-alpha", "location") + key = keyAlpha + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaRegionDisks().Get(ctx, *key); err == nil { + t.Errorf("AlphaRegionDisks().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.Disk{} + if err := mock.AlphaRegionDisks().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaRegionDisks().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaRegionDisks().Get(ctx, *key); err != nil { + t.Errorf("AlphaRegionDisks().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaRegionDisks.Objects[*keyAlpha] = mock.MockAlphaRegionDisks.Obj(&alpha.Disk{Name: keyAlpha.Name}) + want := map[string]bool{ + "key-alpha": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaRegionDisks().List(ctx, location, filter.None) + if err != nil { + t.Errorf("AlphaRegionDisks().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaRegionDisks().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaRegionDisks().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaRegionDisks().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.AlphaRegionDisks().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaRegionDisks().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestHealthChecksGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyAlpha := meta.GlobalKey("key-alpha") + key = keyAlpha + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaHealthChecks().Get(ctx, *key); err == nil { + t.Errorf("AlphaHealthChecks().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.HealthChecks().Get(ctx, *key); err == nil { + t.Errorf("HealthChecks().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.HealthCheck{} + if err := mock.AlphaHealthChecks().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaHealthChecks().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + { + obj := &ga.HealthCheck{} + if err := mock.HealthChecks().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("HealthChecks().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaHealthChecks().Get(ctx, *key); err != nil { + t.Errorf("AlphaHealthChecks().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.HealthChecks().Get(ctx, *key); err != nil { + t.Errorf("HealthChecks().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaHealthChecks.Objects[*keyAlpha] = mock.MockAlphaHealthChecks.Obj(&alpha.HealthCheck{Name: keyAlpha.Name}) + mock.MockHealthChecks.Objects[*keyGA] = mock.MockHealthChecks.Obj(&ga.HealthCheck{Name: keyGA.Name}) + want := map[string]bool{ + "key-alpha": true, + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaHealthChecks().List(ctx, filter.None) + if err != nil { + t.Errorf("AlphaHealthChecks().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaHealthChecks().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.HealthChecks().List(ctx, filter.None) + if err != nil { + t.Errorf("HealthChecks().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaHealthChecks().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaHealthChecks().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaHealthChecks().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + if err := mock.HealthChecks().Delete(ctx, *keyGA); err != nil { + t.Errorf("HealthChecks().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.AlphaHealthChecks().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaHealthChecks().Delete(%v, %v) = nil; want error", ctx, key) + } + if err := mock.HealthChecks().Delete(ctx, *keyGA); err == nil { + t.Errorf("HealthChecks().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestHttpHealthChecksGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.HttpHealthChecks().Get(ctx, *key); err == nil { + t.Errorf("HttpHealthChecks().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.HttpHealthCheck{} + if err := mock.HttpHealthChecks().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("HttpHealthChecks().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.HttpHealthChecks().Get(ctx, *key); err != nil { + t.Errorf("HttpHealthChecks().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockHttpHealthChecks.Objects[*keyGA] = mock.MockHttpHealthChecks.Obj(&ga.HttpHealthCheck{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.HttpHealthChecks().List(ctx, filter.None) + if err != nil { + t.Errorf("HttpHealthChecks().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaHttpHealthChecks().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.HttpHealthChecks().Delete(ctx, *keyGA); err != nil { + t.Errorf("HttpHealthChecks().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.HttpHealthChecks().Delete(ctx, *keyGA); err == nil { + t.Errorf("HttpHealthChecks().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestHttpsHealthChecksGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.HttpsHealthChecks().Get(ctx, *key); err == nil { + t.Errorf("HttpsHealthChecks().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.HttpsHealthCheck{} + if err := mock.HttpsHealthChecks().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("HttpsHealthChecks().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.HttpsHealthChecks().Get(ctx, *key); err != nil { + t.Errorf("HttpsHealthChecks().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockHttpsHealthChecks.Objects[*keyGA] = mock.MockHttpsHealthChecks.Obj(&ga.HttpsHealthCheck{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.HttpsHealthChecks().List(ctx, filter.None) + if err != nil { + t.Errorf("HttpsHealthChecks().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaHttpsHealthChecks().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.HttpsHealthChecks().Delete(ctx, *keyGA); err != nil { + t.Errorf("HttpsHealthChecks().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.HttpsHealthChecks().Delete(ctx, *keyGA); err == nil { + t.Errorf("HttpsHealthChecks().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestInstanceGroupsGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.ZonalKey("key-ga", "location") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.InstanceGroups().Get(ctx, *key); err == nil { + t.Errorf("InstanceGroups().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.InstanceGroup{} + if err := mock.InstanceGroups().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("InstanceGroups().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.InstanceGroups().Get(ctx, *key); err != nil { + t.Errorf("InstanceGroups().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockInstanceGroups.Objects[*keyGA] = mock.MockInstanceGroups.Obj(&ga.InstanceGroup{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.InstanceGroups().List(ctx, location, filter.None) + if err != nil { + t.Errorf("InstanceGroups().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaInstanceGroups().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.InstanceGroups().Delete(ctx, *keyGA); err != nil { + t.Errorf("InstanceGroups().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.InstanceGroups().Delete(ctx, *keyGA); err == nil { + t.Errorf("InstanceGroups().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestSslCertificatesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.SslCertificates().Get(ctx, *key); err == nil { + t.Errorf("SslCertificates().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.SslCertificate{} + if err := mock.SslCertificates().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("SslCertificates().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.SslCertificates().Get(ctx, *key); err != nil { + t.Errorf("SslCertificates().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockSslCertificates.Objects[*keyGA] = mock.MockSslCertificates.Obj(&ga.SslCertificate{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.SslCertificates().List(ctx, filter.None) + if err != nil { + t.Errorf("SslCertificates().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaSslCertificates().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.SslCertificates().Delete(ctx, *keyGA); err != nil { + t.Errorf("SslCertificates().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.SslCertificates().Delete(ctx, *keyGA); err == nil { + t.Errorf("SslCertificates().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestTargetHttpsProxiesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.TargetHttpsProxies().Get(ctx, *key); err == nil { + t.Errorf("TargetHttpsProxies().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.TargetHttpsProxy{} + if err := mock.TargetHttpsProxies().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("TargetHttpsProxies().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.TargetHttpsProxies().Get(ctx, *key); err != nil { + t.Errorf("TargetHttpsProxies().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockTargetHttpsProxies.Objects[*keyGA] = mock.MockTargetHttpsProxies.Obj(&ga.TargetHttpsProxy{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.TargetHttpsProxies().List(ctx, filter.None) + if err != nil { + t.Errorf("TargetHttpsProxies().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaTargetHttpsProxies().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.TargetHttpsProxies().Delete(ctx, *keyGA); err != nil { + t.Errorf("TargetHttpsProxies().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.TargetHttpsProxies().Delete(ctx, *keyGA); err == nil { + t.Errorf("TargetHttpsProxies().Delete(%v, %v) = nil; want error", ctx, key) + } +}