From db64122d4c281b420e4ce1b906b69f7ba37e47b0 Mon Sep 17 00:00:00 2001 From: Spencer Hance Date: Fri, 24 May 2019 14:42:33 -0700 Subject: [PATCH 1/2] Add additional SslCertificate services --- pkg/cloud/gen.go | 1446 +++++++++++++++++++++++++++++++++++----- pkg/cloud/gen_test.go | 138 +++- pkg/cloud/meta/meta.go | 32 +- 3 files changed, 1436 insertions(+), 180 deletions(-) diff --git a/pkg/cloud/gen.go b/pkg/cloud/gen.go index ad9750f4..908f200d 100644 --- a/pkg/cloud/gen.go +++ b/pkg/cloud/gen.go @@ -77,6 +77,9 @@ type Cloud interface { Routes() Routes BetaSecurityPolicies() BetaSecurityPolicies SslCertificates() SslCertificates + BetaSslCertificates() BetaSslCertificates + AlphaSslCertificates() AlphaSslCertificates + AlphaRegionSslCertificates() AlphaRegionSslCertificates AlphaSubnetworks() AlphaSubnetworks BetaSubnetworks() BetaSubnetworks Subnetworks() Subnetworks @@ -138,6 +141,9 @@ func NewGCE(s *Service) *GCE { gceRoutes: &GCERoutes{s}, gceBetaSecurityPolicies: &GCEBetaSecurityPolicies{s}, gceSslCertificates: &GCESslCertificates{s}, + gceBetaSslCertificates: &GCEBetaSslCertificates{s}, + gceAlphaSslCertificates: &GCEAlphaSslCertificates{s}, + gceAlphaRegionSslCertificates: &GCEAlphaRegionSslCertificates{s}, gceAlphaSubnetworks: &GCEAlphaSubnetworks{s}, gceBetaSubnetworks: &GCEBetaSubnetworks{s}, gceSubnetworks: &GCESubnetworks{s}, @@ -203,6 +209,9 @@ type GCE struct { gceRoutes *GCERoutes gceBetaSecurityPolicies *GCEBetaSecurityPolicies gceSslCertificates *GCESslCertificates + gceBetaSslCertificates *GCEBetaSslCertificates + gceAlphaSslCertificates *GCEAlphaSslCertificates + gceAlphaRegionSslCertificates *GCEAlphaRegionSslCertificates gceAlphaSubnetworks *GCEAlphaSubnetworks gceBetaSubnetworks *GCEBetaSubnetworks gceSubnetworks *GCESubnetworks @@ -417,6 +426,21 @@ func (gce *GCE) SslCertificates() SslCertificates { return gce.gceSslCertificates } +// BetaSslCertificates returns the interface for the beta SslCertificates. +func (gce *GCE) BetaSslCertificates() BetaSslCertificates { + return gce.gceBetaSslCertificates +} + +// AlphaSslCertificates returns the interface for the alpha SslCertificates. +func (gce *GCE) AlphaSslCertificates() AlphaSslCertificates { + return gce.gceAlphaSslCertificates +} + +// AlphaRegionSslCertificates returns the interface for the alpha RegionSslCertificates. +func (gce *GCE) AlphaRegionSslCertificates() AlphaRegionSslCertificates { + return gce.gceAlphaRegionSslCertificates +} + // AlphaSubnetworks returns the interface for the alpha Subnetworks. func (gce *GCE) AlphaSubnetworks() AlphaSubnetworks { return gce.gceAlphaSubnetworks @@ -522,6 +546,7 @@ func NewMockGCE(projectRouter ProjectRouter) *MockGCE { mockRegionBackendServicesObjs := map[meta.Key]*MockRegionBackendServicesObj{} mockRegionDisksObjs := map[meta.Key]*MockRegionDisksObj{} mockRegionHealthChecksObjs := map[meta.Key]*MockRegionHealthChecksObj{} + mockRegionSslCertificatesObjs := map[meta.Key]*MockRegionSslCertificatesObj{} mockRegionTargetHttpProxiesObjs := map[meta.Key]*MockRegionTargetHttpProxiesObj{} mockRegionTargetHttpsProxiesObjs := map[meta.Key]*MockRegionTargetHttpsProxiesObj{} mockRegionUrlMapsObjs := map[meta.Key]*MockRegionUrlMapsObj{} @@ -576,6 +601,9 @@ func NewMockGCE(projectRouter ProjectRouter) *MockGCE { MockRoutes: NewMockRoutes(projectRouter, mockRoutesObjs), MockBetaSecurityPolicies: NewMockBetaSecurityPolicies(projectRouter, mockSecurityPoliciesObjs), MockSslCertificates: NewMockSslCertificates(projectRouter, mockSslCertificatesObjs), + MockBetaSslCertificates: NewMockBetaSslCertificates(projectRouter, mockSslCertificatesObjs), + MockAlphaSslCertificates: NewMockAlphaSslCertificates(projectRouter, mockSslCertificatesObjs), + MockAlphaRegionSslCertificates: NewMockAlphaRegionSslCertificates(projectRouter, mockRegionSslCertificatesObjs), MockAlphaSubnetworks: NewMockAlphaSubnetworks(projectRouter, mockSubnetworksObjs), MockBetaSubnetworks: NewMockBetaSubnetworks(projectRouter, mockSubnetworksObjs), MockSubnetworks: NewMockSubnetworks(projectRouter, mockSubnetworksObjs), @@ -641,6 +669,9 @@ type MockGCE struct { MockRoutes *MockRoutes MockBetaSecurityPolicies *MockBetaSecurityPolicies MockSslCertificates *MockSslCertificates + MockBetaSslCertificates *MockBetaSslCertificates + MockAlphaSslCertificates *MockAlphaSslCertificates + MockAlphaRegionSslCertificates *MockAlphaRegionSslCertificates MockAlphaSubnetworks *MockAlphaSubnetworks MockBetaSubnetworks *MockBetaSubnetworks MockSubnetworks *MockSubnetworks @@ -855,6 +886,21 @@ func (mock *MockGCE) SslCertificates() SslCertificates { return mock.MockSslCertificates } +// BetaSslCertificates returns the interface for the beta SslCertificates. +func (mock *MockGCE) BetaSslCertificates() BetaSslCertificates { + return mock.MockBetaSslCertificates +} + +// AlphaSslCertificates returns the interface for the alpha SslCertificates. +func (mock *MockGCE) AlphaSslCertificates() AlphaSslCertificates { + return mock.MockAlphaSslCertificates +} + +// AlphaRegionSslCertificates returns the interface for the alpha RegionSslCertificates. +func (mock *MockGCE) AlphaRegionSslCertificates() AlphaRegionSslCertificates { + return mock.MockAlphaRegionSslCertificates +} + // AlphaSubnetworks returns the interface for the alpha Subnetworks. func (mock *MockGCE) AlphaSubnetworks() AlphaSubnetworks { return mock.MockAlphaSubnetworks @@ -1521,6 +1567,26 @@ func (m *MockRegionHealthChecksObj) ToAlpha() *alpha.HealthCheck { return ret } +// MockRegionSslCertificatesObj 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 MockRegionSslCertificatesObj struct { + Obj interface{} +} + +// ToAlpha retrieves the given version of the object. +func (m *MockRegionSslCertificatesObj) ToAlpha() *alpha.SslCertificate { + if ret, ok := m.Obj.(*alpha.SslCertificate); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &alpha.SslCertificate{} + if err := copyViaJSON(ret, m.Obj); err != nil { + klog.Errorf("Could not convert %T to *alpha.SslCertificate via JSON: %v", m.Obj, err) + } + return ret +} + // MockRegionTargetHttpProxiesObj 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. @@ -1648,6 +1714,32 @@ type MockSslCertificatesObj struct { Obj interface{} } +// ToAlpha retrieves the given version of the object. +func (m *MockSslCertificatesObj) ToAlpha() *alpha.SslCertificate { + if ret, ok := m.Obj.(*alpha.SslCertificate); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &alpha.SslCertificate{} + if err := copyViaJSON(ret, m.Obj); err != nil { + klog.Errorf("Could not convert %T to *alpha.SslCertificate via JSON: %v", m.Obj, err) + } + return ret +} + +// ToBeta retrieves the given version of the object. +func (m *MockSslCertificatesObj) ToBeta() *beta.SslCertificate { + if ret, ok := m.Obj.(*beta.SslCertificate); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &beta.SslCertificate{} + if err := copyViaJSON(ret, m.Obj); err != nil { + klog.Errorf("Could not convert %T to *beta.SslCertificate via JSON: %v", m.Obj, err) + } + return ret +} + // ToGA retrieves the given version of the object. func (m *MockSslCertificatesObj) ToGA() *ga.SslCertificate { if ret, ok := m.Obj.(*ga.SslCertificate); ok { @@ -16859,17 +16951,17 @@ func (g *GCESslCertificates) Delete(ctx context.Context, key *meta.Key) error { return err } -// AlphaSubnetworks is an interface that allows for mocking of Subnetworks. -type AlphaSubnetworks interface { - Get(ctx context.Context, key *meta.Key) (*alpha.Subnetwork, error) - List(ctx context.Context, region string, fl *filter.F) ([]*alpha.Subnetwork, error) - Insert(ctx context.Context, key *meta.Key, obj *alpha.Subnetwork) error +// BetaSslCertificates is an interface that allows for mocking of SslCertificates. +type BetaSslCertificates interface { + Get(ctx context.Context, key *meta.Key) (*beta.SslCertificate, error) + List(ctx context.Context, fl *filter.F) ([]*beta.SslCertificate, error) + Insert(ctx context.Context, key *meta.Key, obj *beta.SslCertificate) error Delete(ctx context.Context, key *meta.Key) error } -// NewMockAlphaSubnetworks returns a new mock for Subnetworks. -func NewMockAlphaSubnetworks(pr ProjectRouter, objs map[meta.Key]*MockSubnetworksObj) *MockAlphaSubnetworks { - mock := &MockAlphaSubnetworks{ +// NewMockBetaSslCertificates returns a new mock for SslCertificates. +func NewMockBetaSslCertificates(pr ProjectRouter, objs map[meta.Key]*MockSslCertificatesObj) *MockBetaSslCertificates { + mock := &MockBetaSslCertificates{ ProjectRouter: pr, Objects: objs, @@ -16880,14 +16972,14 @@ func NewMockAlphaSubnetworks(pr ProjectRouter, objs map[meta.Key]*MockSubnetwork return mock } -// MockAlphaSubnetworks is the mock for Subnetworks. -type MockAlphaSubnetworks struct { +// MockBetaSslCertificates is the mock for SslCertificates. +type MockBetaSslCertificates struct { Lock sync.Mutex ProjectRouter ProjectRouter // Objects maintained by the mock. - Objects map[meta.Key]*MockSubnetworksObj + 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. @@ -16900,10 +16992,10 @@ type MockAlphaSubnetworks struct { // 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(ctx context.Context, key *meta.Key, m *MockAlphaSubnetworks) (bool, *alpha.Subnetwork, error) - ListHook func(ctx context.Context, region string, fl *filter.F, m *MockAlphaSubnetworks) (bool, []*alpha.Subnetwork, error) - InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.Subnetwork, m *MockAlphaSubnetworks) (bool, error) - DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaSubnetworks) (bool, error) + GetHook func(ctx context.Context, key *meta.Key, m *MockBetaSslCertificates) (bool, *beta.SslCertificate, error) + ListHook func(ctx context.Context, fl *filter.F, m *MockBetaSslCertificates) (bool, []*beta.SslCertificate, error) + InsertHook func(ctx context.Context, key *meta.Key, obj *beta.SslCertificate, m *MockBetaSslCertificates) (bool, error) + DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaSslCertificates) (bool, error) // X is extra state that can be used as part of the mock. Generated code // will not use this field. @@ -16911,10 +17003,10 @@ type MockAlphaSubnetworks struct { } // Get returns the object from the mock. -func (m *MockAlphaSubnetworks) Get(ctx context.Context, key *meta.Key) (*alpha.Subnetwork, error) { +func (m *MockBetaSslCertificates) Get(ctx context.Context, key *meta.Key) (*beta.SslCertificate, error) { if m.GetHook != nil { if intercept, obj, err := m.GetHook(ctx, key, m); intercept { - klog.V(5).Infof("MockAlphaSubnetworks.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + klog.V(5).Infof("MockBetaSslCertificates.Get(%v, %s) = %+v, %v", ctx, key, obj, err) return obj, err } } @@ -16926,28 +17018,28 @@ func (m *MockAlphaSubnetworks) Get(ctx context.Context, key *meta.Key) (*alpha.S defer m.Lock.Unlock() if err, ok := m.GetError[*key]; ok { - klog.V(5).Infof("MockAlphaSubnetworks.Get(%v, %s) = nil, %v", ctx, key, err) + klog.V(5).Infof("MockBetaSslCertificates.Get(%v, %s) = nil, %v", ctx, key, err) return nil, err } if obj, ok := m.Objects[*key]; ok { - typedObj := obj.ToAlpha() - klog.V(5).Infof("MockAlphaSubnetworks.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + typedObj := obj.ToBeta() + klog.V(5).Infof("MockBetaSslCertificates.Get(%v, %s) = %+v, nil", ctx, key, typedObj) return typedObj, nil } err := &googleapi.Error{ Code: http.StatusNotFound, - Message: fmt.Sprintf("MockAlphaSubnetworks %v not found", key), + Message: fmt.Sprintf("MockBetaSslCertificates %v not found", key), } - klog.V(5).Infof("MockAlphaSubnetworks.Get(%v, %s) = nil, %v", ctx, key, err) + klog.V(5).Infof("MockBetaSslCertificates.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 *MockAlphaSubnetworks) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.Subnetwork, error) { +// List all of the objects in the mock. +func (m *MockBetaSslCertificates) List(ctx context.Context, fl *filter.F) ([]*beta.SslCertificate, error) { if m.ListHook != nil { - if intercept, objs, err := m.ListHook(ctx, region, fl, m); intercept { - klog.V(5).Infof("MockAlphaSubnetworks.List(%v, %q, %v) = [%v items], %v", ctx, region, fl, len(objs), err) + if intercept, objs, err := m.ListHook(ctx, fl, m); intercept { + klog.V(5).Infof("MockBetaSslCertificates.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) return objs, err } } @@ -16957,31 +17049,28 @@ func (m *MockAlphaSubnetworks) List(ctx context.Context, region string, fl *filt if m.ListError != nil { err := *m.ListError - klog.V(5).Infof("MockAlphaSubnetworks.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + klog.V(5).Infof("MockBetaSslCertificates.List(%v, %v) = nil, %v", ctx, fl, err) return nil, *m.ListError } - var objs []*alpha.Subnetwork - for key, obj := range m.Objects { - if key.Region != region { - continue - } - if !fl.Match(obj.ToAlpha()) { + var objs []*beta.SslCertificate + for _, obj := range m.Objects { + if !fl.Match(obj.ToBeta()) { continue } - objs = append(objs, obj.ToAlpha()) + objs = append(objs, obj.ToBeta()) } - klog.V(5).Infof("MockAlphaSubnetworks.List(%v, %q, %v) = [%v items], nil", ctx, region, fl, len(objs)) + klog.V(5).Infof("MockBetaSslCertificates.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 *MockAlphaSubnetworks) Insert(ctx context.Context, key *meta.Key, obj *alpha.Subnetwork) error { +func (m *MockBetaSslCertificates) Insert(ctx context.Context, key *meta.Key, obj *beta.SslCertificate) error { if m.InsertHook != nil { if intercept, err := m.InsertHook(ctx, key, obj, m); intercept { - klog.V(5).Infof("MockAlphaSubnetworks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + klog.V(5).Infof("MockBetaSslCertificates.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) return err } } @@ -16993,32 +17082,32 @@ func (m *MockAlphaSubnetworks) Insert(ctx context.Context, key *meta.Key, obj *a defer m.Lock.Unlock() if err, ok := m.InsertError[*key]; ok { - klog.V(5).Infof("MockAlphaSubnetworks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + klog.V(5).Infof("MockBetaSslCertificates.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("MockAlphaSubnetworks %v exists", key), + Message: fmt.Sprintf("MockBetaSslCertificates %v exists", key), } - klog.V(5).Infof("MockAlphaSubnetworks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + klog.V(5).Infof("MockBetaSslCertificates.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) return err } obj.Name = key.Name - projectID := m.ProjectRouter.ProjectID(ctx, "alpha", "subnetworks") - obj.SelfLink = SelfLink(meta.VersionAlpha, projectID, "subnetworks", key) + projectID := m.ProjectRouter.ProjectID(ctx, "beta", "sslCertificates") + obj.SelfLink = SelfLink(meta.VersionBeta, projectID, "sslCertificates", key) - m.Objects[*key] = &MockSubnetworksObj{obj} - klog.V(5).Infof("MockAlphaSubnetworks.Insert(%v, %v, %+v) = nil", ctx, key, obj) + m.Objects[*key] = &MockSslCertificatesObj{obj} + klog.V(5).Infof("MockBetaSslCertificates.Insert(%v, %v, %+v) = nil", ctx, key, obj) return nil } // Delete is a mock for deleting the object. -func (m *MockAlphaSubnetworks) Delete(ctx context.Context, key *meta.Key) error { +func (m *MockBetaSslCertificates) Delete(ctx context.Context, key *meta.Key) error { if m.DeleteHook != nil { if intercept, err := m.DeleteHook(ctx, key, m); intercept { - klog.V(5).Infof("MockAlphaSubnetworks.Delete(%v, %v) = %v", ctx, key, err) + klog.V(5).Infof("MockBetaSslCertificates.Delete(%v, %v) = %v", ctx, key, err) return err } } @@ -17030,180 +17119,181 @@ func (m *MockAlphaSubnetworks) Delete(ctx context.Context, key *meta.Key) error defer m.Lock.Unlock() if err, ok := m.DeleteError[*key]; ok { - klog.V(5).Infof("MockAlphaSubnetworks.Delete(%v, %v) = %v", ctx, key, err) + klog.V(5).Infof("MockBetaSslCertificates.Delete(%v, %v) = %v", ctx, key, err) return err } if _, ok := m.Objects[*key]; !ok { err := &googleapi.Error{ Code: http.StatusNotFound, - Message: fmt.Sprintf("MockAlphaSubnetworks %v not found", key), + Message: fmt.Sprintf("MockBetaSslCertificates %v not found", key), } - klog.V(5).Infof("MockAlphaSubnetworks.Delete(%v, %v) = %v", ctx, key, err) + klog.V(5).Infof("MockBetaSslCertificates.Delete(%v, %v) = %v", ctx, key, err) return err } delete(m.Objects, *key) - klog.V(5).Infof("MockAlphaSubnetworks.Delete(%v, %v) = nil", ctx, key) + klog.V(5).Infof("MockBetaSslCertificates.Delete(%v, %v) = nil", ctx, key) return nil } // Obj wraps the object for use in the mock. -func (m *MockAlphaSubnetworks) Obj(o *alpha.Subnetwork) *MockSubnetworksObj { - return &MockSubnetworksObj{o} +func (m *MockBetaSslCertificates) Obj(o *beta.SslCertificate) *MockSslCertificatesObj { + return &MockSslCertificatesObj{o} } -// GCEAlphaSubnetworks is a simplifying adapter for the GCE Subnetworks. -type GCEAlphaSubnetworks struct { +// GCEBetaSslCertificates is a simplifying adapter for the GCE SslCertificates. +type GCEBetaSslCertificates struct { s *Service } -// Get the Subnetwork named by key. -func (g *GCEAlphaSubnetworks) Get(ctx context.Context, key *meta.Key) (*alpha.Subnetwork, error) { - klog.V(5).Infof("GCEAlphaSubnetworks.Get(%v, %v): called", ctx, key) +// Get the SslCertificate named by key. +func (g *GCEBetaSslCertificates) Get(ctx context.Context, key *meta.Key) (*beta.SslCertificate, error) { + klog.V(5).Infof("GCEBetaSslCertificates.Get(%v, %v): called", ctx, key) if !key.Valid() { - klog.V(2).Infof("GCEAlphaSubnetworks.Get(%v, %v): key is invalid (%#v)", ctx, key, key) + klog.V(2).Infof("GCEBetaSslCertificates.Get(%v, %v): key is invalid (%#v)", ctx, key, key) return nil, fmt.Errorf("invalid GCE key (%#v)", key) } - projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Subnetworks") + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "SslCertificates") rk := &RateLimitKey{ ProjectID: projectID, Operation: "Get", - Version: meta.Version("alpha"), - Service: "Subnetworks", + Version: meta.Version("beta"), + Service: "SslCertificates", } - klog.V(5).Infof("GCEAlphaSubnetworks.Get(%v, %v): projectID = %v, rk = %+v", ctx, key, projectID, rk) + klog.V(5).Infof("GCEBetaSslCertificates.Get(%v, %v): projectID = %v, rk = %+v", ctx, key, projectID, rk) if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { - klog.V(4).Infof("GCEAlphaSubnetworks.Get(%v, %v): RateLimiter error: %v", ctx, key, err) + klog.V(4).Infof("GCEBetaSslCertificates.Get(%v, %v): RateLimiter error: %v", ctx, key, err) return nil, err } - call := g.s.Alpha.Subnetworks.Get(projectID, key.Region, key.Name) + call := g.s.Beta.SslCertificates.Get(projectID, key.Name) call.Context(ctx) v, err := call.Do() - klog.V(4).Infof("GCEAlphaSubnetworks.Get(%v, %v) = %+v, %v", ctx, key, v, err) + klog.V(4).Infof("GCEBetaSslCertificates.Get(%v, %v) = %+v, %v", ctx, key, v, err) return v, err } -// List all Subnetwork objects. -func (g *GCEAlphaSubnetworks) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.Subnetwork, error) { - klog.V(5).Infof("GCEAlphaSubnetworks.List(%v, %v, %v) called", ctx, region, fl) - projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Subnetworks") +// List all SslCertificate objects. +func (g *GCEBetaSslCertificates) List(ctx context.Context, fl *filter.F) ([]*beta.SslCertificate, error) { + klog.V(5).Infof("GCEBetaSslCertificates.List(%v, %v) called", ctx, fl) + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "SslCertificates") rk := &RateLimitKey{ ProjectID: projectID, Operation: "List", - Version: meta.Version("alpha"), - Service: "Subnetworks", + Version: meta.Version("beta"), + Service: "SslCertificates", } if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { return nil, err } - klog.V(5).Infof("GCEAlphaSubnetworks.List(%v, %v, %v): projectID = %v, rk = %+v", ctx, region, fl, projectID, rk) - call := g.s.Alpha.Subnetworks.List(projectID, region) + klog.V(5).Infof("GCEBetaSslCertificates.List(%v, %v): projectID = %v, rk = %+v", ctx, fl, projectID, rk) + call := g.s.Beta.SslCertificates.List(projectID) if fl != filter.None { call.Filter(fl.String()) } - var all []*alpha.Subnetwork - f := func(l *alpha.SubnetworkList) error { - klog.V(5).Infof("GCEAlphaSubnetworks.List(%v, ..., %v): page %+v", ctx, fl, l) + var all []*beta.SslCertificate + f := func(l *beta.SslCertificateList) error { + klog.V(5).Infof("GCEBetaSslCertificates.List(%v, ..., %v): page %+v", ctx, fl, l) all = append(all, l.Items...) return nil } if err := call.Pages(ctx, f); err != nil { - klog.V(4).Infof("GCEAlphaSubnetworks.List(%v, ..., %v) = %v, %v", ctx, fl, nil, err) + klog.V(4).Infof("GCEBetaSslCertificates.List(%v, ..., %v) = %v, %v", ctx, fl, nil, err) return nil, err } if klog.V(4) { - klog.V(4).Infof("GCEAlphaSubnetworks.List(%v, ..., %v) = [%v items], %v", ctx, fl, len(all), nil) + klog.V(4).Infof("GCEBetaSslCertificates.List(%v, ..., %v) = [%v items], %v", ctx, fl, len(all), nil) } else if klog.V(5) { var asStr []string for _, o := range all { asStr = append(asStr, fmt.Sprintf("%+v", o)) } - klog.V(5).Infof("GCEAlphaSubnetworks.List(%v, ..., %v) = %v, %v", ctx, fl, asStr, nil) + klog.V(5).Infof("GCEBetaSslCertificates.List(%v, ..., %v) = %v, %v", ctx, fl, asStr, nil) } return all, nil } -// Insert Subnetwork with key of value obj. -func (g *GCEAlphaSubnetworks) Insert(ctx context.Context, key *meta.Key, obj *alpha.Subnetwork) error { - klog.V(5).Infof("GCEAlphaSubnetworks.Insert(%v, %v, %+v): called", ctx, key, obj) +// Insert SslCertificate with key of value obj. +func (g *GCEBetaSslCertificates) Insert(ctx context.Context, key *meta.Key, obj *beta.SslCertificate) error { + klog.V(5).Infof("GCEBetaSslCertificates.Insert(%v, %v, %+v): called", ctx, key, obj) if !key.Valid() { - klog.V(2).Infof("GCEAlphaSubnetworks.Insert(%v, %v, ...): key is invalid (%#v)", ctx, key, key) + klog.V(2).Infof("GCEBetaSslCertificates.Insert(%v, %v, ...): key is invalid (%#v)", ctx, key, key) return fmt.Errorf("invalid GCE key (%+v)", key) } - projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Subnetworks") + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "SslCertificates") rk := &RateLimitKey{ ProjectID: projectID, Operation: "Insert", - Version: meta.Version("alpha"), - Service: "Subnetworks", + Version: meta.Version("beta"), + Service: "SslCertificates", } - klog.V(5).Infof("GCEAlphaSubnetworks.Insert(%v, %v, ...): projectID = %v, rk = %+v", ctx, key, projectID, rk) + klog.V(5).Infof("GCEBetaSslCertificates.Insert(%v, %v, ...): projectID = %v, rk = %+v", ctx, key, projectID, rk) if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { - klog.V(4).Infof("GCEAlphaSubnetworks.Insert(%v, %v, ...): RateLimiter error: %v", ctx, key, err) + klog.V(4).Infof("GCEBetaSslCertificates.Insert(%v, %v, ...): RateLimiter error: %v", ctx, key, err) return err } obj.Name = key.Name - call := g.s.Alpha.Subnetworks.Insert(projectID, key.Region, obj) + call := g.s.Beta.SslCertificates.Insert(projectID, obj) call.Context(ctx) op, err := call.Do() if err != nil { - klog.V(4).Infof("GCEAlphaSubnetworks.Insert(%v, %v, ...) = %+v", ctx, key, err) + klog.V(4).Infof("GCEBetaSslCertificates.Insert(%v, %v, ...) = %+v", ctx, key, err) return err } err = g.s.WaitForCompletion(ctx, op) - klog.V(4).Infof("GCEAlphaSubnetworks.Insert(%v, %v, %+v) = %+v", ctx, key, obj, err) + klog.V(4).Infof("GCEBetaSslCertificates.Insert(%v, %v, %+v) = %+v", ctx, key, obj, err) return err } -// Delete the Subnetwork referenced by key. -func (g *GCEAlphaSubnetworks) Delete(ctx context.Context, key *meta.Key) error { - klog.V(5).Infof("GCEAlphaSubnetworks.Delete(%v, %v): called", ctx, key) +// Delete the SslCertificate referenced by key. +func (g *GCEBetaSslCertificates) Delete(ctx context.Context, key *meta.Key) error { + klog.V(5).Infof("GCEBetaSslCertificates.Delete(%v, %v): called", ctx, key) if !key.Valid() { - klog.V(2).Infof("GCEAlphaSubnetworks.Delete(%v, %v): key is invalid (%#v)", ctx, key, key) + klog.V(2).Infof("GCEBetaSslCertificates.Delete(%v, %v): key is invalid (%#v)", ctx, key, key) return fmt.Errorf("invalid GCE key (%+v)", key) } - projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Subnetworks") + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "SslCertificates") rk := &RateLimitKey{ ProjectID: projectID, Operation: "Delete", - Version: meta.Version("alpha"), - Service: "Subnetworks", + Version: meta.Version("beta"), + Service: "SslCertificates", } - klog.V(5).Infof("GCEAlphaSubnetworks.Delete(%v, %v): projectID = %v, rk = %+v", ctx, key, projectID, rk) + klog.V(5).Infof("GCEBetaSslCertificates.Delete(%v, %v): projectID = %v, rk = %+v", ctx, key, projectID, rk) if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { - klog.V(4).Infof("GCEAlphaSubnetworks.Delete(%v, %v): RateLimiter error: %v", ctx, key, err) + klog.V(4).Infof("GCEBetaSslCertificates.Delete(%v, %v): RateLimiter error: %v", ctx, key, err) return err } - call := g.s.Alpha.Subnetworks.Delete(projectID, key.Region, key.Name) + call := g.s.Beta.SslCertificates.Delete(projectID, key.Name) + call.Context(ctx) op, err := call.Do() if err != nil { - klog.V(4).Infof("GCEAlphaSubnetworks.Delete(%v, %v) = %v", ctx, key, err) + klog.V(4).Infof("GCEBetaSslCertificates.Delete(%v, %v) = %v", ctx, key, err) return err } err = g.s.WaitForCompletion(ctx, op) - klog.V(4).Infof("GCEAlphaSubnetworks.Delete(%v, %v) = %v", ctx, key, err) + klog.V(4).Infof("GCEBetaSslCertificates.Delete(%v, %v) = %v", ctx, key, err) return err } -// BetaSubnetworks is an interface that allows for mocking of Subnetworks. -type BetaSubnetworks interface { - Get(ctx context.Context, key *meta.Key) (*beta.Subnetwork, error) - List(ctx context.Context, region string, fl *filter.F) ([]*beta.Subnetwork, error) - Insert(ctx context.Context, key *meta.Key, obj *beta.Subnetwork) error +// AlphaSslCertificates is an interface that allows for mocking of SslCertificates. +type AlphaSslCertificates interface { + Get(ctx context.Context, key *meta.Key) (*alpha.SslCertificate, error) + List(ctx context.Context, fl *filter.F) ([]*alpha.SslCertificate, error) + Insert(ctx context.Context, key *meta.Key, obj *alpha.SslCertificate) error Delete(ctx context.Context, key *meta.Key) error } -// NewMockBetaSubnetworks returns a new mock for Subnetworks. -func NewMockBetaSubnetworks(pr ProjectRouter, objs map[meta.Key]*MockSubnetworksObj) *MockBetaSubnetworks { - mock := &MockBetaSubnetworks{ +// NewMockAlphaSslCertificates returns a new mock for SslCertificates. +func NewMockAlphaSslCertificates(pr ProjectRouter, objs map[meta.Key]*MockSslCertificatesObj) *MockAlphaSslCertificates { + mock := &MockAlphaSslCertificates{ ProjectRouter: pr, Objects: objs, @@ -17214,14 +17304,14 @@ func NewMockBetaSubnetworks(pr ProjectRouter, objs map[meta.Key]*MockSubnetworks return mock } -// MockBetaSubnetworks is the mock for Subnetworks. -type MockBetaSubnetworks struct { +// MockAlphaSslCertificates is the mock for SslCertificates. +type MockAlphaSslCertificates struct { Lock sync.Mutex ProjectRouter ProjectRouter // Objects maintained by the mock. - Objects map[meta.Key]*MockSubnetworksObj + 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. @@ -17234,10 +17324,10 @@ type MockBetaSubnetworks struct { // 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(ctx context.Context, key *meta.Key, m *MockBetaSubnetworks) (bool, *beta.Subnetwork, error) - ListHook func(ctx context.Context, region string, fl *filter.F, m *MockBetaSubnetworks) (bool, []*beta.Subnetwork, error) - InsertHook func(ctx context.Context, key *meta.Key, obj *beta.Subnetwork, m *MockBetaSubnetworks) (bool, error) - DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaSubnetworks) (bool, error) + GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaSslCertificates) (bool, *alpha.SslCertificate, error) + ListHook func(ctx context.Context, fl *filter.F, m *MockAlphaSslCertificates) (bool, []*alpha.SslCertificate, error) + InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.SslCertificate, m *MockAlphaSslCertificates) (bool, error) + DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaSslCertificates) (bool, error) // X is extra state that can be used as part of the mock. Generated code // will not use this field. @@ -17245,10 +17335,10 @@ type MockBetaSubnetworks struct { } // Get returns the object from the mock. -func (m *MockBetaSubnetworks) Get(ctx context.Context, key *meta.Key) (*beta.Subnetwork, error) { +func (m *MockAlphaSslCertificates) Get(ctx context.Context, key *meta.Key) (*alpha.SslCertificate, error) { if m.GetHook != nil { if intercept, obj, err := m.GetHook(ctx, key, m); intercept { - klog.V(5).Infof("MockBetaSubnetworks.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + klog.V(5).Infof("MockAlphaSslCertificates.Get(%v, %s) = %+v, %v", ctx, key, obj, err) return obj, err } } @@ -17260,28 +17350,28 @@ func (m *MockBetaSubnetworks) Get(ctx context.Context, key *meta.Key) (*beta.Sub defer m.Lock.Unlock() if err, ok := m.GetError[*key]; ok { - klog.V(5).Infof("MockBetaSubnetworks.Get(%v, %s) = nil, %v", ctx, key, err) + klog.V(5).Infof("MockAlphaSslCertificates.Get(%v, %s) = nil, %v", ctx, key, err) return nil, err } if obj, ok := m.Objects[*key]; ok { - typedObj := obj.ToBeta() - klog.V(5).Infof("MockBetaSubnetworks.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + typedObj := obj.ToAlpha() + klog.V(5).Infof("MockAlphaSslCertificates.Get(%v, %s) = %+v, nil", ctx, key, typedObj) return typedObj, nil } err := &googleapi.Error{ Code: http.StatusNotFound, - Message: fmt.Sprintf("MockBetaSubnetworks %v not found", key), + Message: fmt.Sprintf("MockAlphaSslCertificates %v not found", key), } - klog.V(5).Infof("MockBetaSubnetworks.Get(%v, %s) = nil, %v", ctx, key, err) + klog.V(5).Infof("MockAlphaSslCertificates.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 *MockBetaSubnetworks) List(ctx context.Context, region string, fl *filter.F) ([]*beta.Subnetwork, error) { +// List all of the objects in the mock. +func (m *MockAlphaSslCertificates) List(ctx context.Context, fl *filter.F) ([]*alpha.SslCertificate, error) { if m.ListHook != nil { - if intercept, objs, err := m.ListHook(ctx, region, fl, m); intercept { - klog.V(5).Infof("MockBetaSubnetworks.List(%v, %q, %v) = [%v items], %v", ctx, region, fl, len(objs), err) + if intercept, objs, err := m.ListHook(ctx, fl, m); intercept { + klog.V(5).Infof("MockAlphaSslCertificates.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) return objs, err } } @@ -17291,31 +17381,28 @@ func (m *MockBetaSubnetworks) List(ctx context.Context, region string, fl *filte if m.ListError != nil { err := *m.ListError - klog.V(5).Infof("MockBetaSubnetworks.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + klog.V(5).Infof("MockAlphaSslCertificates.List(%v, %v) = nil, %v", ctx, fl, err) return nil, *m.ListError } - var objs []*beta.Subnetwork - for key, obj := range m.Objects { - if key.Region != region { - continue - } - if !fl.Match(obj.ToBeta()) { + var objs []*alpha.SslCertificate + for _, obj := range m.Objects { + if !fl.Match(obj.ToAlpha()) { continue } - objs = append(objs, obj.ToBeta()) + objs = append(objs, obj.ToAlpha()) } - klog.V(5).Infof("MockBetaSubnetworks.List(%v, %q, %v) = [%v items], nil", ctx, region, fl, len(objs)) + klog.V(5).Infof("MockAlphaSslCertificates.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 *MockBetaSubnetworks) Insert(ctx context.Context, key *meta.Key, obj *beta.Subnetwork) error { +func (m *MockAlphaSslCertificates) Insert(ctx context.Context, key *meta.Key, obj *alpha.SslCertificate) error { if m.InsertHook != nil { if intercept, err := m.InsertHook(ctx, key, obj, m); intercept { - klog.V(5).Infof("MockBetaSubnetworks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + klog.V(5).Infof("MockAlphaSslCertificates.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) return err } } @@ -17327,32 +17414,32 @@ func (m *MockBetaSubnetworks) Insert(ctx context.Context, key *meta.Key, obj *be defer m.Lock.Unlock() if err, ok := m.InsertError[*key]; ok { - klog.V(5).Infof("MockBetaSubnetworks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + klog.V(5).Infof("MockAlphaSslCertificates.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("MockBetaSubnetworks %v exists", key), + Message: fmt.Sprintf("MockAlphaSslCertificates %v exists", key), } - klog.V(5).Infof("MockBetaSubnetworks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + klog.V(5).Infof("MockAlphaSslCertificates.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) return err } obj.Name = key.Name - projectID := m.ProjectRouter.ProjectID(ctx, "beta", "subnetworks") - obj.SelfLink = SelfLink(meta.VersionBeta, projectID, "subnetworks", key) + projectID := m.ProjectRouter.ProjectID(ctx, "alpha", "sslCertificates") + obj.SelfLink = SelfLink(meta.VersionAlpha, projectID, "sslCertificates", key) - m.Objects[*key] = &MockSubnetworksObj{obj} - klog.V(5).Infof("MockBetaSubnetworks.Insert(%v, %v, %+v) = nil", ctx, key, obj) + m.Objects[*key] = &MockSslCertificatesObj{obj} + klog.V(5).Infof("MockAlphaSslCertificates.Insert(%v, %v, %+v) = nil", ctx, key, obj) return nil } // Delete is a mock for deleting the object. -func (m *MockBetaSubnetworks) Delete(ctx context.Context, key *meta.Key) error { +func (m *MockAlphaSslCertificates) Delete(ctx context.Context, key *meta.Key) error { if m.DeleteHook != nil { if intercept, err := m.DeleteHook(ctx, key, m); intercept { - klog.V(5).Infof("MockBetaSubnetworks.Delete(%v, %v) = %v", ctx, key, err) + klog.V(5).Infof("MockAlphaSslCertificates.Delete(%v, %v) = %v", ctx, key, err) return err } } @@ -17364,74 +17451,1077 @@ func (m *MockBetaSubnetworks) Delete(ctx context.Context, key *meta.Key) error { defer m.Lock.Unlock() if err, ok := m.DeleteError[*key]; ok { - klog.V(5).Infof("MockBetaSubnetworks.Delete(%v, %v) = %v", ctx, key, err) + klog.V(5).Infof("MockAlphaSslCertificates.Delete(%v, %v) = %v", ctx, key, err) return err } if _, ok := m.Objects[*key]; !ok { err := &googleapi.Error{ Code: http.StatusNotFound, - Message: fmt.Sprintf("MockBetaSubnetworks %v not found", key), + Message: fmt.Sprintf("MockAlphaSslCertificates %v not found", key), } - klog.V(5).Infof("MockBetaSubnetworks.Delete(%v, %v) = %v", ctx, key, err) + klog.V(5).Infof("MockAlphaSslCertificates.Delete(%v, %v) = %v", ctx, key, err) return err } delete(m.Objects, *key) - klog.V(5).Infof("MockBetaSubnetworks.Delete(%v, %v) = nil", ctx, key) + klog.V(5).Infof("MockAlphaSslCertificates.Delete(%v, %v) = nil", ctx, key) return nil } // Obj wraps the object for use in the mock. -func (m *MockBetaSubnetworks) Obj(o *beta.Subnetwork) *MockSubnetworksObj { - return &MockSubnetworksObj{o} +func (m *MockAlphaSslCertificates) Obj(o *alpha.SslCertificate) *MockSslCertificatesObj { + return &MockSslCertificatesObj{o} } -// GCEBetaSubnetworks is a simplifying adapter for the GCE Subnetworks. -type GCEBetaSubnetworks struct { +// GCEAlphaSslCertificates is a simplifying adapter for the GCE SslCertificates. +type GCEAlphaSslCertificates struct { s *Service } -// Get the Subnetwork named by key. -func (g *GCEBetaSubnetworks) Get(ctx context.Context, key *meta.Key) (*beta.Subnetwork, error) { - klog.V(5).Infof("GCEBetaSubnetworks.Get(%v, %v): called", ctx, key) +// Get the SslCertificate named by key. +func (g *GCEAlphaSslCertificates) Get(ctx context.Context, key *meta.Key) (*alpha.SslCertificate, error) { + klog.V(5).Infof("GCEAlphaSslCertificates.Get(%v, %v): called", ctx, key) if !key.Valid() { - klog.V(2).Infof("GCEBetaSubnetworks.Get(%v, %v): key is invalid (%#v)", ctx, key, key) + klog.V(2).Infof("GCEAlphaSslCertificates.Get(%v, %v): key is invalid (%#v)", ctx, key, key) return nil, fmt.Errorf("invalid GCE key (%#v)", key) } - projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "Subnetworks") + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "SslCertificates") rk := &RateLimitKey{ ProjectID: projectID, Operation: "Get", - Version: meta.Version("beta"), - Service: "Subnetworks", + Version: meta.Version("alpha"), + Service: "SslCertificates", } - klog.V(5).Infof("GCEBetaSubnetworks.Get(%v, %v): projectID = %v, rk = %+v", ctx, key, projectID, rk) + klog.V(5).Infof("GCEAlphaSslCertificates.Get(%v, %v): projectID = %v, rk = %+v", ctx, key, projectID, rk) if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { - klog.V(4).Infof("GCEBetaSubnetworks.Get(%v, %v): RateLimiter error: %v", ctx, key, err) + klog.V(4).Infof("GCEAlphaSslCertificates.Get(%v, %v): RateLimiter error: %v", ctx, key, err) return nil, err } - call := g.s.Beta.Subnetworks.Get(projectID, key.Region, key.Name) + call := g.s.Alpha.SslCertificates.Get(projectID, key.Name) call.Context(ctx) v, err := call.Do() - klog.V(4).Infof("GCEBetaSubnetworks.Get(%v, %v) = %+v, %v", ctx, key, v, err) + klog.V(4).Infof("GCEAlphaSslCertificates.Get(%v, %v) = %+v, %v", ctx, key, v, err) return v, err } -// List all Subnetwork objects. -func (g *GCEBetaSubnetworks) List(ctx context.Context, region string, fl *filter.F) ([]*beta.Subnetwork, error) { - klog.V(5).Infof("GCEBetaSubnetworks.List(%v, %v, %v) called", ctx, region, fl) - projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "Subnetworks") +// List all SslCertificate objects. +func (g *GCEAlphaSslCertificates) List(ctx context.Context, fl *filter.F) ([]*alpha.SslCertificate, error) { + klog.V(5).Infof("GCEAlphaSslCertificates.List(%v, %v) called", ctx, fl) + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "SslCertificates") rk := &RateLimitKey{ ProjectID: projectID, Operation: "List", - Version: meta.Version("beta"), - Service: "Subnetworks", + Version: meta.Version("alpha"), + Service: "SslCertificates", } if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { return nil, err } - klog.V(5).Infof("GCEBetaSubnetworks.List(%v, %v, %v): projectID = %v, rk = %+v", ctx, region, fl, projectID, rk) + klog.V(5).Infof("GCEAlphaSslCertificates.List(%v, %v): projectID = %v, rk = %+v", ctx, fl, projectID, rk) + call := g.s.Alpha.SslCertificates.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*alpha.SslCertificate + f := func(l *alpha.SslCertificateList) error { + klog.V(5).Infof("GCEAlphaSslCertificates.List(%v, ..., %v): page %+v", ctx, fl, l) + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + klog.V(4).Infof("GCEAlphaSslCertificates.List(%v, ..., %v) = %v, %v", ctx, fl, nil, err) + return nil, err + } + + if klog.V(4) { + klog.V(4).Infof("GCEAlphaSslCertificates.List(%v, ..., %v) = [%v items], %v", ctx, fl, len(all), nil) + } else if klog.V(5) { + var asStr []string + for _, o := range all { + asStr = append(asStr, fmt.Sprintf("%+v", o)) + } + klog.V(5).Infof("GCEAlphaSslCertificates.List(%v, ..., %v) = %v, %v", ctx, fl, asStr, nil) + } + + return all, nil +} + +// Insert SslCertificate with key of value obj. +func (g *GCEAlphaSslCertificates) Insert(ctx context.Context, key *meta.Key, obj *alpha.SslCertificate) error { + klog.V(5).Infof("GCEAlphaSslCertificates.Insert(%v, %v, %+v): called", ctx, key, obj) + if !key.Valid() { + klog.V(2).Infof("GCEAlphaSslCertificates.Insert(%v, %v, ...): key is invalid (%#v)", ctx, key, key) + return fmt.Errorf("invalid GCE key (%+v)", key) + } + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "SslCertificates") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("alpha"), + Service: "SslCertificates", + } + klog.V(5).Infof("GCEAlphaSslCertificates.Insert(%v, %v, ...): projectID = %v, rk = %+v", ctx, key, projectID, rk) + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + klog.V(4).Infof("GCEAlphaSslCertificates.Insert(%v, %v, ...): RateLimiter error: %v", ctx, key, err) + return err + } + obj.Name = key.Name + call := g.s.Alpha.SslCertificates.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + klog.V(4).Infof("GCEAlphaSslCertificates.Insert(%v, %v, ...) = %+v", ctx, key, err) + return err + } + + err = g.s.WaitForCompletion(ctx, op) + klog.V(4).Infof("GCEAlphaSslCertificates.Insert(%v, %v, %+v) = %+v", ctx, key, obj, err) + return err +} + +// Delete the SslCertificate referenced by key. +func (g *GCEAlphaSslCertificates) Delete(ctx context.Context, key *meta.Key) error { + klog.V(5).Infof("GCEAlphaSslCertificates.Delete(%v, %v): called", ctx, key) + if !key.Valid() { + klog.V(2).Infof("GCEAlphaSslCertificates.Delete(%v, %v): key is invalid (%#v)", ctx, key, key) + return fmt.Errorf("invalid GCE key (%+v)", key) + } + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "SslCertificates") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("alpha"), + Service: "SslCertificates", + } + klog.V(5).Infof("GCEAlphaSslCertificates.Delete(%v, %v): projectID = %v, rk = %+v", ctx, key, projectID, rk) + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + klog.V(4).Infof("GCEAlphaSslCertificates.Delete(%v, %v): RateLimiter error: %v", ctx, key, err) + return err + } + call := g.s.Alpha.SslCertificates.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + klog.V(4).Infof("GCEAlphaSslCertificates.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + err = g.s.WaitForCompletion(ctx, op) + klog.V(4).Infof("GCEAlphaSslCertificates.Delete(%v, %v) = %v", ctx, key, err) + return err +} + +// AlphaRegionSslCertificates is an interface that allows for mocking of RegionSslCertificates. +type AlphaRegionSslCertificates interface { + Get(ctx context.Context, key *meta.Key) (*alpha.SslCertificate, error) + List(ctx context.Context, region string, fl *filter.F) ([]*alpha.SslCertificate, error) + Insert(ctx context.Context, key *meta.Key, obj *alpha.SslCertificate) error + Delete(ctx context.Context, key *meta.Key) error +} + +// NewMockAlphaRegionSslCertificates returns a new mock for RegionSslCertificates. +func NewMockAlphaRegionSslCertificates(pr ProjectRouter, objs map[meta.Key]*MockRegionSslCertificatesObj) *MockAlphaRegionSslCertificates { + mock := &MockAlphaRegionSslCertificates{ + ProjectRouter: pr, + + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockAlphaRegionSslCertificates is the mock for RegionSslCertificates. +type MockAlphaRegionSslCertificates struct { + Lock sync.Mutex + + ProjectRouter ProjectRouter + + // Objects maintained by the mock. + Objects map[meta.Key]*MockRegionSslCertificatesObj + + // 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(ctx context.Context, key *meta.Key, m *MockAlphaRegionSslCertificates) (bool, *alpha.SslCertificate, error) + ListHook func(ctx context.Context, region string, fl *filter.F, m *MockAlphaRegionSslCertificates) (bool, []*alpha.SslCertificate, error) + InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.SslCertificate, m *MockAlphaRegionSslCertificates) (bool, error) + DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaRegionSslCertificates) (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 *MockAlphaRegionSslCertificates) Get(ctx context.Context, key *meta.Key) (*alpha.SslCertificate, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(ctx, key, m); intercept { + klog.V(5).Infof("MockAlphaRegionSslCertificates.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + if !key.Valid() { + return nil, fmt.Errorf("invalid GCE key (%+v)", key) + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[*key]; ok { + klog.V(5).Infof("MockAlphaRegionSslCertificates.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[*key]; ok { + typedObj := obj.ToAlpha() + klog.V(5).Infof("MockAlphaRegionSslCertificates.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaRegionSslCertificates %v not found", key), + } + klog.V(5).Infof("MockAlphaRegionSslCertificates.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 *MockAlphaRegionSslCertificates) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.SslCertificate, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(ctx, region, fl, m); intercept { + klog.V(5).Infof("MockAlphaRegionSslCertificates.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 + klog.V(5).Infof("MockAlphaRegionSslCertificates.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + + return nil, *m.ListError + } + + var objs []*alpha.SslCertificate + for key, obj := range m.Objects { + if key.Region != region { + continue + } + if !fl.Match(obj.ToAlpha()) { + continue + } + objs = append(objs, obj.ToAlpha()) + } + + klog.V(5).Infof("MockAlphaRegionSslCertificates.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 *MockAlphaRegionSslCertificates) Insert(ctx context.Context, key *meta.Key, obj *alpha.SslCertificate) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(ctx, key, obj, m); intercept { + klog.V(5).Infof("MockAlphaRegionSslCertificates.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + if !key.Valid() { + return fmt.Errorf("invalid GCE key (%+v)", key) + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[*key]; ok { + klog.V(5).Infof("MockAlphaRegionSslCertificates.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("MockAlphaRegionSslCertificates %v exists", key), + } + klog.V(5).Infof("MockAlphaRegionSslCertificates.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + projectID := m.ProjectRouter.ProjectID(ctx, "alpha", "sslCertificates") + obj.SelfLink = SelfLink(meta.VersionAlpha, projectID, "sslCertificates", key) + + m.Objects[*key] = &MockRegionSslCertificatesObj{obj} + klog.V(5).Infof("MockAlphaRegionSslCertificates.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockAlphaRegionSslCertificates) Delete(ctx context.Context, key *meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(ctx, key, m); intercept { + klog.V(5).Infof("MockAlphaRegionSslCertificates.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + if !key.Valid() { + return fmt.Errorf("invalid GCE key (%+v)", key) + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[*key]; ok { + klog.V(5).Infof("MockAlphaRegionSslCertificates.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[*key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaRegionSslCertificates %v not found", key), + } + klog.V(5).Infof("MockAlphaRegionSslCertificates.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, *key) + klog.V(5).Infof("MockAlphaRegionSslCertificates.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockAlphaRegionSslCertificates) Obj(o *alpha.SslCertificate) *MockRegionSslCertificatesObj { + return &MockRegionSslCertificatesObj{o} +} + +// GCEAlphaRegionSslCertificates is a simplifying adapter for the GCE RegionSslCertificates. +type GCEAlphaRegionSslCertificates struct { + s *Service +} + +// Get the SslCertificate named by key. +func (g *GCEAlphaRegionSslCertificates) Get(ctx context.Context, key *meta.Key) (*alpha.SslCertificate, error) { + klog.V(5).Infof("GCEAlphaRegionSslCertificates.Get(%v, %v): called", ctx, key) + + if !key.Valid() { + klog.V(2).Infof("GCEAlphaRegionSslCertificates.Get(%v, %v): key is invalid (%#v)", ctx, key, key) + return nil, fmt.Errorf("invalid GCE key (%#v)", key) + } + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "RegionSslCertificates") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("alpha"), + Service: "RegionSslCertificates", + } + klog.V(5).Infof("GCEAlphaRegionSslCertificates.Get(%v, %v): projectID = %v, rk = %+v", ctx, key, projectID, rk) + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + klog.V(4).Infof("GCEAlphaRegionSslCertificates.Get(%v, %v): RateLimiter error: %v", ctx, key, err) + return nil, err + } + call := g.s.Alpha.RegionSslCertificates.Get(projectID, key.Region, key.Name) + call.Context(ctx) + v, err := call.Do() + klog.V(4).Infof("GCEAlphaRegionSslCertificates.Get(%v, %v) = %+v, %v", ctx, key, v, err) + return v, err +} + +// List all SslCertificate objects. +func (g *GCEAlphaRegionSslCertificates) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.SslCertificate, error) { + klog.V(5).Infof("GCEAlphaRegionSslCertificates.List(%v, %v, %v) called", ctx, region, fl) + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "RegionSslCertificates") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("alpha"), + Service: "RegionSslCertificates", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + klog.V(5).Infof("GCEAlphaRegionSslCertificates.List(%v, %v, %v): projectID = %v, rk = %+v", ctx, region, fl, projectID, rk) + call := g.s.Alpha.RegionSslCertificates.List(projectID, region) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*alpha.SslCertificate + f := func(l *alpha.SslCertificateList) error { + klog.V(5).Infof("GCEAlphaRegionSslCertificates.List(%v, ..., %v): page %+v", ctx, fl, l) + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + klog.V(4).Infof("GCEAlphaRegionSslCertificates.List(%v, ..., %v) = %v, %v", ctx, fl, nil, err) + return nil, err + } + + if klog.V(4) { + klog.V(4).Infof("GCEAlphaRegionSslCertificates.List(%v, ..., %v) = [%v items], %v", ctx, fl, len(all), nil) + } else if klog.V(5) { + var asStr []string + for _, o := range all { + asStr = append(asStr, fmt.Sprintf("%+v", o)) + } + klog.V(5).Infof("GCEAlphaRegionSslCertificates.List(%v, ..., %v) = %v, %v", ctx, fl, asStr, nil) + } + + return all, nil +} + +// Insert SslCertificate with key of value obj. +func (g *GCEAlphaRegionSslCertificates) Insert(ctx context.Context, key *meta.Key, obj *alpha.SslCertificate) error { + klog.V(5).Infof("GCEAlphaRegionSslCertificates.Insert(%v, %v, %+v): called", ctx, key, obj) + if !key.Valid() { + klog.V(2).Infof("GCEAlphaRegionSslCertificates.Insert(%v, %v, ...): key is invalid (%#v)", ctx, key, key) + return fmt.Errorf("invalid GCE key (%+v)", key) + } + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "RegionSslCertificates") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("alpha"), + Service: "RegionSslCertificates", + } + klog.V(5).Infof("GCEAlphaRegionSslCertificates.Insert(%v, %v, ...): projectID = %v, rk = %+v", ctx, key, projectID, rk) + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + klog.V(4).Infof("GCEAlphaRegionSslCertificates.Insert(%v, %v, ...): RateLimiter error: %v", ctx, key, err) + return err + } + obj.Name = key.Name + call := g.s.Alpha.RegionSslCertificates.Insert(projectID, key.Region, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + klog.V(4).Infof("GCEAlphaRegionSslCertificates.Insert(%v, %v, ...) = %+v", ctx, key, err) + return err + } + + err = g.s.WaitForCompletion(ctx, op) + klog.V(4).Infof("GCEAlphaRegionSslCertificates.Insert(%v, %v, %+v) = %+v", ctx, key, obj, err) + return err +} + +// Delete the SslCertificate referenced by key. +func (g *GCEAlphaRegionSslCertificates) Delete(ctx context.Context, key *meta.Key) error { + klog.V(5).Infof("GCEAlphaRegionSslCertificates.Delete(%v, %v): called", ctx, key) + if !key.Valid() { + klog.V(2).Infof("GCEAlphaRegionSslCertificates.Delete(%v, %v): key is invalid (%#v)", ctx, key, key) + return fmt.Errorf("invalid GCE key (%+v)", key) + } + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "RegionSslCertificates") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("alpha"), + Service: "RegionSslCertificates", + } + klog.V(5).Infof("GCEAlphaRegionSslCertificates.Delete(%v, %v): projectID = %v, rk = %+v", ctx, key, projectID, rk) + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + klog.V(4).Infof("GCEAlphaRegionSslCertificates.Delete(%v, %v): RateLimiter error: %v", ctx, key, err) + return err + } + call := g.s.Alpha.RegionSslCertificates.Delete(projectID, key.Region, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + klog.V(4).Infof("GCEAlphaRegionSslCertificates.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + err = g.s.WaitForCompletion(ctx, op) + klog.V(4).Infof("GCEAlphaRegionSslCertificates.Delete(%v, %v) = %v", ctx, key, err) + return err +} + +// AlphaSubnetworks is an interface that allows for mocking of Subnetworks. +type AlphaSubnetworks interface { + Get(ctx context.Context, key *meta.Key) (*alpha.Subnetwork, error) + List(ctx context.Context, region string, fl *filter.F) ([]*alpha.Subnetwork, error) + Insert(ctx context.Context, key *meta.Key, obj *alpha.Subnetwork) error + Delete(ctx context.Context, key *meta.Key) error +} + +// NewMockAlphaSubnetworks returns a new mock for Subnetworks. +func NewMockAlphaSubnetworks(pr ProjectRouter, objs map[meta.Key]*MockSubnetworksObj) *MockAlphaSubnetworks { + mock := &MockAlphaSubnetworks{ + ProjectRouter: pr, + + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockAlphaSubnetworks is the mock for Subnetworks. +type MockAlphaSubnetworks struct { + Lock sync.Mutex + + ProjectRouter ProjectRouter + + // Objects maintained by the mock. + Objects map[meta.Key]*MockSubnetworksObj + + // 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(ctx context.Context, key *meta.Key, m *MockAlphaSubnetworks) (bool, *alpha.Subnetwork, error) + ListHook func(ctx context.Context, region string, fl *filter.F, m *MockAlphaSubnetworks) (bool, []*alpha.Subnetwork, error) + InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.Subnetwork, m *MockAlphaSubnetworks) (bool, error) + DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaSubnetworks) (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 *MockAlphaSubnetworks) Get(ctx context.Context, key *meta.Key) (*alpha.Subnetwork, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(ctx, key, m); intercept { + klog.V(5).Infof("MockAlphaSubnetworks.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + if !key.Valid() { + return nil, fmt.Errorf("invalid GCE key (%+v)", key) + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[*key]; ok { + klog.V(5).Infof("MockAlphaSubnetworks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[*key]; ok { + typedObj := obj.ToAlpha() + klog.V(5).Infof("MockAlphaSubnetworks.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaSubnetworks %v not found", key), + } + klog.V(5).Infof("MockAlphaSubnetworks.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 *MockAlphaSubnetworks) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.Subnetwork, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(ctx, region, fl, m); intercept { + klog.V(5).Infof("MockAlphaSubnetworks.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 + klog.V(5).Infof("MockAlphaSubnetworks.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + + return nil, *m.ListError + } + + var objs []*alpha.Subnetwork + for key, obj := range m.Objects { + if key.Region != region { + continue + } + if !fl.Match(obj.ToAlpha()) { + continue + } + objs = append(objs, obj.ToAlpha()) + } + + klog.V(5).Infof("MockAlphaSubnetworks.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 *MockAlphaSubnetworks) Insert(ctx context.Context, key *meta.Key, obj *alpha.Subnetwork) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(ctx, key, obj, m); intercept { + klog.V(5).Infof("MockAlphaSubnetworks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + if !key.Valid() { + return fmt.Errorf("invalid GCE key (%+v)", key) + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[*key]; ok { + klog.V(5).Infof("MockAlphaSubnetworks.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("MockAlphaSubnetworks %v exists", key), + } + klog.V(5).Infof("MockAlphaSubnetworks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + projectID := m.ProjectRouter.ProjectID(ctx, "alpha", "subnetworks") + obj.SelfLink = SelfLink(meta.VersionAlpha, projectID, "subnetworks", key) + + m.Objects[*key] = &MockSubnetworksObj{obj} + klog.V(5).Infof("MockAlphaSubnetworks.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockAlphaSubnetworks) Delete(ctx context.Context, key *meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(ctx, key, m); intercept { + klog.V(5).Infof("MockAlphaSubnetworks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + if !key.Valid() { + return fmt.Errorf("invalid GCE key (%+v)", key) + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[*key]; ok { + klog.V(5).Infof("MockAlphaSubnetworks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[*key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaSubnetworks %v not found", key), + } + klog.V(5).Infof("MockAlphaSubnetworks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, *key) + klog.V(5).Infof("MockAlphaSubnetworks.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockAlphaSubnetworks) Obj(o *alpha.Subnetwork) *MockSubnetworksObj { + return &MockSubnetworksObj{o} +} + +// GCEAlphaSubnetworks is a simplifying adapter for the GCE Subnetworks. +type GCEAlphaSubnetworks struct { + s *Service +} + +// Get the Subnetwork named by key. +func (g *GCEAlphaSubnetworks) Get(ctx context.Context, key *meta.Key) (*alpha.Subnetwork, error) { + klog.V(5).Infof("GCEAlphaSubnetworks.Get(%v, %v): called", ctx, key) + + if !key.Valid() { + klog.V(2).Infof("GCEAlphaSubnetworks.Get(%v, %v): key is invalid (%#v)", ctx, key, key) + return nil, fmt.Errorf("invalid GCE key (%#v)", key) + } + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Subnetworks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("alpha"), + Service: "Subnetworks", + } + klog.V(5).Infof("GCEAlphaSubnetworks.Get(%v, %v): projectID = %v, rk = %+v", ctx, key, projectID, rk) + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + klog.V(4).Infof("GCEAlphaSubnetworks.Get(%v, %v): RateLimiter error: %v", ctx, key, err) + return nil, err + } + call := g.s.Alpha.Subnetworks.Get(projectID, key.Region, key.Name) + call.Context(ctx) + v, err := call.Do() + klog.V(4).Infof("GCEAlphaSubnetworks.Get(%v, %v) = %+v, %v", ctx, key, v, err) + return v, err +} + +// List all Subnetwork objects. +func (g *GCEAlphaSubnetworks) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.Subnetwork, error) { + klog.V(5).Infof("GCEAlphaSubnetworks.List(%v, %v, %v) called", ctx, region, fl) + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Subnetworks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("alpha"), + Service: "Subnetworks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + klog.V(5).Infof("GCEAlphaSubnetworks.List(%v, %v, %v): projectID = %v, rk = %+v", ctx, region, fl, projectID, rk) + call := g.s.Alpha.Subnetworks.List(projectID, region) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*alpha.Subnetwork + f := func(l *alpha.SubnetworkList) error { + klog.V(5).Infof("GCEAlphaSubnetworks.List(%v, ..., %v): page %+v", ctx, fl, l) + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + klog.V(4).Infof("GCEAlphaSubnetworks.List(%v, ..., %v) = %v, %v", ctx, fl, nil, err) + return nil, err + } + + if klog.V(4) { + klog.V(4).Infof("GCEAlphaSubnetworks.List(%v, ..., %v) = [%v items], %v", ctx, fl, len(all), nil) + } else if klog.V(5) { + var asStr []string + for _, o := range all { + asStr = append(asStr, fmt.Sprintf("%+v", o)) + } + klog.V(5).Infof("GCEAlphaSubnetworks.List(%v, ..., %v) = %v, %v", ctx, fl, asStr, nil) + } + + return all, nil +} + +// Insert Subnetwork with key of value obj. +func (g *GCEAlphaSubnetworks) Insert(ctx context.Context, key *meta.Key, obj *alpha.Subnetwork) error { + klog.V(5).Infof("GCEAlphaSubnetworks.Insert(%v, %v, %+v): called", ctx, key, obj) + if !key.Valid() { + klog.V(2).Infof("GCEAlphaSubnetworks.Insert(%v, %v, ...): key is invalid (%#v)", ctx, key, key) + return fmt.Errorf("invalid GCE key (%+v)", key) + } + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Subnetworks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("alpha"), + Service: "Subnetworks", + } + klog.V(5).Infof("GCEAlphaSubnetworks.Insert(%v, %v, ...): projectID = %v, rk = %+v", ctx, key, projectID, rk) + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + klog.V(4).Infof("GCEAlphaSubnetworks.Insert(%v, %v, ...): RateLimiter error: %v", ctx, key, err) + return err + } + obj.Name = key.Name + call := g.s.Alpha.Subnetworks.Insert(projectID, key.Region, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + klog.V(4).Infof("GCEAlphaSubnetworks.Insert(%v, %v, ...) = %+v", ctx, key, err) + return err + } + + err = g.s.WaitForCompletion(ctx, op) + klog.V(4).Infof("GCEAlphaSubnetworks.Insert(%v, %v, %+v) = %+v", ctx, key, obj, err) + return err +} + +// Delete the Subnetwork referenced by key. +func (g *GCEAlphaSubnetworks) Delete(ctx context.Context, key *meta.Key) error { + klog.V(5).Infof("GCEAlphaSubnetworks.Delete(%v, %v): called", ctx, key) + if !key.Valid() { + klog.V(2).Infof("GCEAlphaSubnetworks.Delete(%v, %v): key is invalid (%#v)", ctx, key, key) + return fmt.Errorf("invalid GCE key (%+v)", key) + } + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Subnetworks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("alpha"), + Service: "Subnetworks", + } + klog.V(5).Infof("GCEAlphaSubnetworks.Delete(%v, %v): projectID = %v, rk = %+v", ctx, key, projectID, rk) + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + klog.V(4).Infof("GCEAlphaSubnetworks.Delete(%v, %v): RateLimiter error: %v", ctx, key, err) + return err + } + call := g.s.Alpha.Subnetworks.Delete(projectID, key.Region, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + klog.V(4).Infof("GCEAlphaSubnetworks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + err = g.s.WaitForCompletion(ctx, op) + klog.V(4).Infof("GCEAlphaSubnetworks.Delete(%v, %v) = %v", ctx, key, err) + return err +} + +// BetaSubnetworks is an interface that allows for mocking of Subnetworks. +type BetaSubnetworks interface { + Get(ctx context.Context, key *meta.Key) (*beta.Subnetwork, error) + List(ctx context.Context, region string, fl *filter.F) ([]*beta.Subnetwork, error) + Insert(ctx context.Context, key *meta.Key, obj *beta.Subnetwork) error + Delete(ctx context.Context, key *meta.Key) error +} + +// NewMockBetaSubnetworks returns a new mock for Subnetworks. +func NewMockBetaSubnetworks(pr ProjectRouter, objs map[meta.Key]*MockSubnetworksObj) *MockBetaSubnetworks { + mock := &MockBetaSubnetworks{ + ProjectRouter: pr, + + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockBetaSubnetworks is the mock for Subnetworks. +type MockBetaSubnetworks struct { + Lock sync.Mutex + + ProjectRouter ProjectRouter + + // Objects maintained by the mock. + Objects map[meta.Key]*MockSubnetworksObj + + // 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(ctx context.Context, key *meta.Key, m *MockBetaSubnetworks) (bool, *beta.Subnetwork, error) + ListHook func(ctx context.Context, region string, fl *filter.F, m *MockBetaSubnetworks) (bool, []*beta.Subnetwork, error) + InsertHook func(ctx context.Context, key *meta.Key, obj *beta.Subnetwork, m *MockBetaSubnetworks) (bool, error) + DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaSubnetworks) (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 *MockBetaSubnetworks) Get(ctx context.Context, key *meta.Key) (*beta.Subnetwork, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(ctx, key, m); intercept { + klog.V(5).Infof("MockBetaSubnetworks.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + if !key.Valid() { + return nil, fmt.Errorf("invalid GCE key (%+v)", key) + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[*key]; ok { + klog.V(5).Infof("MockBetaSubnetworks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[*key]; ok { + typedObj := obj.ToBeta() + klog.V(5).Infof("MockBetaSubnetworks.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockBetaSubnetworks %v not found", key), + } + klog.V(5).Infof("MockBetaSubnetworks.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 *MockBetaSubnetworks) List(ctx context.Context, region string, fl *filter.F) ([]*beta.Subnetwork, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(ctx, region, fl, m); intercept { + klog.V(5).Infof("MockBetaSubnetworks.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 + klog.V(5).Infof("MockBetaSubnetworks.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + + return nil, *m.ListError + } + + var objs []*beta.Subnetwork + for key, obj := range m.Objects { + if key.Region != region { + continue + } + if !fl.Match(obj.ToBeta()) { + continue + } + objs = append(objs, obj.ToBeta()) + } + + klog.V(5).Infof("MockBetaSubnetworks.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 *MockBetaSubnetworks) Insert(ctx context.Context, key *meta.Key, obj *beta.Subnetwork) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(ctx, key, obj, m); intercept { + klog.V(5).Infof("MockBetaSubnetworks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + if !key.Valid() { + return fmt.Errorf("invalid GCE key (%+v)", key) + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[*key]; ok { + klog.V(5).Infof("MockBetaSubnetworks.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("MockBetaSubnetworks %v exists", key), + } + klog.V(5).Infof("MockBetaSubnetworks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + projectID := m.ProjectRouter.ProjectID(ctx, "beta", "subnetworks") + obj.SelfLink = SelfLink(meta.VersionBeta, projectID, "subnetworks", key) + + m.Objects[*key] = &MockSubnetworksObj{obj} + klog.V(5).Infof("MockBetaSubnetworks.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockBetaSubnetworks) Delete(ctx context.Context, key *meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(ctx, key, m); intercept { + klog.V(5).Infof("MockBetaSubnetworks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + if !key.Valid() { + return fmt.Errorf("invalid GCE key (%+v)", key) + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[*key]; ok { + klog.V(5).Infof("MockBetaSubnetworks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[*key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockBetaSubnetworks %v not found", key), + } + klog.V(5).Infof("MockBetaSubnetworks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, *key) + klog.V(5).Infof("MockBetaSubnetworks.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockBetaSubnetworks) Obj(o *beta.Subnetwork) *MockSubnetworksObj { + return &MockSubnetworksObj{o} +} + +// GCEBetaSubnetworks is a simplifying adapter for the GCE Subnetworks. +type GCEBetaSubnetworks struct { + s *Service +} + +// Get the Subnetwork named by key. +func (g *GCEBetaSubnetworks) Get(ctx context.Context, key *meta.Key) (*beta.Subnetwork, error) { + klog.V(5).Infof("GCEBetaSubnetworks.Get(%v, %v): called", ctx, key) + + if !key.Valid() { + klog.V(2).Infof("GCEBetaSubnetworks.Get(%v, %v): key is invalid (%#v)", ctx, key, key) + return nil, fmt.Errorf("invalid GCE key (%#v)", key) + } + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "Subnetworks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("beta"), + Service: "Subnetworks", + } + klog.V(5).Infof("GCEBetaSubnetworks.Get(%v, %v): projectID = %v, rk = %+v", ctx, key, projectID, rk) + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + klog.V(4).Infof("GCEBetaSubnetworks.Get(%v, %v): RateLimiter error: %v", ctx, key, err) + return nil, err + } + call := g.s.Beta.Subnetworks.Get(projectID, key.Region, key.Name) + call.Context(ctx) + v, err := call.Do() + klog.V(4).Infof("GCEBetaSubnetworks.Get(%v, %v) = %+v, %v", ctx, key, v, err) + return v, err +} + +// List all Subnetwork objects. +func (g *GCEBetaSubnetworks) List(ctx context.Context, region string, fl *filter.F) ([]*beta.Subnetwork, error) { + klog.V(5).Infof("GCEBetaSubnetworks.List(%v, %v, %v) called", ctx, region, fl) + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "Subnetworks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("beta"), + Service: "Subnetworks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + klog.V(5).Infof("GCEBetaSubnetworks.List(%v, %v, %v): projectID = %v, rk = %+v", ctx, region, fl, projectID, rk) call := g.s.Beta.Subnetworks.List(projectID, region) if fl != filter.None { call.Filter(fl.String()) @@ -23253,6 +24343,12 @@ func NewRegionHealthChecksResourceID(project, region, name string) *ResourceID { return &ResourceID{project, "healthChecks", key} } +// NewRegionSslCertificatesResourceID creates a ResourceID for the RegionSslCertificates resource. +func NewRegionSslCertificatesResourceID(project, region, name string) *ResourceID { + key := meta.RegionalKey(name, region) + return &ResourceID{project, "sslCertificates", key} +} + // NewRegionTargetHttpProxiesResourceID creates a ResourceID for the RegionTargetHttpProxies resource. func NewRegionTargetHttpProxiesResourceID(project, region, name string) *ResourceID { key := meta.RegionalKey(name, region) diff --git a/pkg/cloud/gen_test.go b/pkg/cloud/gen_test.go index 1d437583..aeca6c81 100644 --- a/pkg/cloud/gen_test.go +++ b/pkg/cloud/gen_test.go @@ -1748,6 +1748,69 @@ func TestRegionHealthChecksGroup(t *testing.T) { } } +func TestRegionSslCertificatesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + pr := &SingleProjectRouter{"mock-project"} + mock := NewMockGCE(pr) + + var key *meta.Key + keyAlpha := meta.RegionalKey("key-alpha", "location") + key = keyAlpha + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaRegionSslCertificates().Get(ctx, key); err == nil { + t.Errorf("AlphaRegionSslCertificates().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.SslCertificate{} + if err := mock.AlphaRegionSslCertificates().Insert(ctx, keyAlpha, obj); err != nil { + t.Errorf("AlphaRegionSslCertificates().Insert(%v, %v, %v) = %v; want nil", ctx, keyAlpha, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaRegionSslCertificates().Get(ctx, key); err != nil { + t.Errorf("AlphaRegionSslCertificates().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaRegionSslCertificates.Objects[*keyAlpha] = mock.MockAlphaRegionSslCertificates.Obj(&alpha.SslCertificate{Name: keyAlpha.Name}) + want := map[string]bool{ + "key-alpha": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaRegionSslCertificates().List(ctx, location, filter.None) + if err != nil { + t.Errorf("AlphaRegionSslCertificates().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("AlphaRegionSslCertificates().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaRegionSslCertificates().Delete(ctx, keyAlpha); err != nil { + t.Errorf("AlphaRegionSslCertificates().Delete(%v, %v) = %v; want nil", ctx, keyAlpha, err) + } + + // Delete not found. + if err := mock.AlphaRegionSslCertificates().Delete(ctx, keyAlpha); err == nil { + t.Errorf("AlphaRegionSslCertificates().Delete(%v, %v) = nil; want error", ctx, keyAlpha) + } +} + func TestRegionTargetHttpProxiesGroup(t *testing.T) { t.Parallel() @@ -2119,17 +2182,39 @@ func TestSslCertificatesGroup(t *testing.T) { mock := NewMockGCE(pr) var key *meta.Key + keyAlpha := meta.GlobalKey("key-alpha") + key = keyAlpha + keyBeta := meta.GlobalKey("key-beta") + key = keyBeta keyGA := meta.GlobalKey("key-ga") key = keyGA // Ignore unused variables. _, _, _ = ctx, mock, key // Get not found. + if _, err := mock.AlphaSslCertificates().Get(ctx, key); err == nil { + t.Errorf("AlphaSslCertificates().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.BetaSslCertificates().Get(ctx, key); err == nil { + t.Errorf("BetaSslCertificates().Get(%v, %v) = _, nil; want error", ctx, key) + } if _, err := mock.SslCertificates().Get(ctx, key); err == nil { t.Errorf("SslCertificates().Get(%v, %v) = _, nil; want error", ctx, key) } // Insert. + { + obj := &alpha.SslCertificate{} + if err := mock.AlphaSslCertificates().Insert(ctx, keyAlpha, obj); err != nil { + t.Errorf("AlphaSslCertificates().Insert(%v, %v, %v) = %v; want nil", ctx, keyAlpha, obj, err) + } + } + { + obj := &beta.SslCertificate{} + if err := mock.BetaSslCertificates().Insert(ctx, keyBeta, obj); err != nil { + t.Errorf("BetaSslCertificates().Insert(%v, %v, %v) = %v; want nil", ctx, keyBeta, obj, err) + } + } { obj := &ga.SslCertificate{} if err := mock.SslCertificates().Insert(ctx, keyGA, obj); err != nil { @@ -2138,16 +2223,54 @@ func TestSslCertificatesGroup(t *testing.T) { } // Get across versions. + if obj, err := mock.AlphaSslCertificates().Get(ctx, key); err != nil { + t.Errorf("AlphaSslCertificates().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.BetaSslCertificates().Get(ctx, key); err != nil { + t.Errorf("BetaSslCertificates().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } 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.MockAlphaSslCertificates.Objects[*keyAlpha] = mock.MockAlphaSslCertificates.Obj(&alpha.SslCertificate{Name: keyAlpha.Name}) + mock.MockBetaSslCertificates.Objects[*keyBeta] = mock.MockBetaSslCertificates.Obj(&beta.SslCertificate{Name: keyBeta.Name}) mock.MockSslCertificates.Objects[*keyGA] = mock.MockSslCertificates.Obj(&ga.SslCertificate{Name: keyGA.Name}) want := map[string]bool{ - "key-ga": true, + "key-alpha": true, + "key-beta": true, + "key-ga": true, } _ = want // ignore unused variables. + { + objs, err := mock.AlphaSslCertificates().List(ctx, filter.None) + if err != nil { + t.Errorf("AlphaSslCertificates().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) + } + } + } + { + objs, err := mock.BetaSslCertificates().List(ctx, filter.None) + if err != nil { + t.Errorf("BetaSslCertificates().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("BetaSslCertificates().List(); got %+v, want %+v", got, want) + } + } + } { objs, err := mock.SslCertificates().List(ctx, filter.None) if err != nil { @@ -2164,11 +2287,23 @@ func TestSslCertificatesGroup(t *testing.T) { } // Delete across versions. + if err := mock.AlphaSslCertificates().Delete(ctx, keyAlpha); err != nil { + t.Errorf("AlphaSslCertificates().Delete(%v, %v) = %v; want nil", ctx, keyAlpha, err) + } + if err := mock.BetaSslCertificates().Delete(ctx, keyBeta); err != nil { + t.Errorf("BetaSslCertificates().Delete(%v, %v) = %v; want nil", ctx, keyBeta, err) + } if err := mock.SslCertificates().Delete(ctx, keyGA); err != nil { t.Errorf("SslCertificates().Delete(%v, %v) = %v; want nil", ctx, keyGA, err) } // Delete not found. + if err := mock.AlphaSslCertificates().Delete(ctx, keyAlpha); err == nil { + t.Errorf("AlphaSslCertificates().Delete(%v, %v) = nil; want error", ctx, keyAlpha) + } + if err := mock.BetaSslCertificates().Delete(ctx, keyBeta); err == nil { + t.Errorf("BetaSslCertificates().Delete(%v, %v) = nil; want error", ctx, keyBeta) + } if err := mock.SslCertificates().Delete(ctx, keyGA); err == nil { t.Errorf("SslCertificates().Delete(%v, %v) = nil; want error", ctx, keyGA) } @@ -2847,6 +2982,7 @@ func TestResourceIDConversion(t *testing.T) { NewRegionBackendServicesResourceID("some-project", "us-central1", "my-backendServices-resource"), NewRegionDisksResourceID("some-project", "us-central1", "my-disks-resource"), NewRegionHealthChecksResourceID("some-project", "us-central1", "my-healthChecks-resource"), + NewRegionSslCertificatesResourceID("some-project", "us-central1", "my-sslCertificates-resource"), NewRegionTargetHttpProxiesResourceID("some-project", "us-central1", "my-targetHttpProxies-resource"), NewRegionTargetHttpsProxiesResourceID("some-project", "us-central1", "my-targetHttpsProxies-resource"), NewRegionUrlMapsResourceID("some-project", "us-central1", "my-urlMaps-resource"), diff --git a/pkg/cloud/meta/meta.go b/pkg/cloud/meta/meta.go index 5877dfc2..1156e82d 100644 --- a/pkg/cloud/meta/meta.go +++ b/pkg/cloud/meta/meta.go @@ -71,7 +71,7 @@ var AllServices = []*ServiceInfo{ Resource: "addresses", keyType: Regional, serviceType: reflect.TypeOf(&ga.AddressesService{}), - options: AggregatedList, + options: AggregatedList, }, { Object: "Address", @@ -80,7 +80,7 @@ var AllServices = []*ServiceInfo{ version: VersionAlpha, keyType: Regional, serviceType: reflect.TypeOf(&alpha.AddressesService{}), - options: AggregatedList, + options: AggregatedList, }, { Object: "Address", @@ -89,7 +89,7 @@ var AllServices = []*ServiceInfo{ version: VersionBeta, keyType: Regional, serviceType: reflect.TypeOf(&beta.AddressesService{}), - options: AggregatedList, + options: AggregatedList, }, { Object: "Address", @@ -463,6 +463,30 @@ var AllServices = []*ServiceInfo{ keyType: Global, serviceType: reflect.TypeOf(&ga.SslCertificatesService{}), }, + { + Object: "SslCertificate", + Service: "SslCertificates", + Resource: "sslCertificates", + version: VersionBeta, + keyType: Global, + serviceType: reflect.TypeOf(&beta.SslCertificatesService{}), + }, + { + Object: "SslCertificate", + Service: "SslCertificates", + Resource: "sslCertificates", + version: VersionAlpha, + keyType: Global, + serviceType: reflect.TypeOf(&alpha.SslCertificatesService{}), + }, + { + Object: "SslCertificate", + Service: "RegionSslCertificates", + Resource: "sslCertificates", + version: VersionAlpha, + keyType: Regional, + serviceType: reflect.TypeOf(&alpha.RegionSslCertificatesService{}), + }, { Object: "Subnetwork", Service: "Subnetworks", @@ -523,7 +547,7 @@ var AllServices = []*ServiceInfo{ Object: "TargetHttpProxy", Service: "RegionTargetHttpProxies", Resource: "targetHttpProxies", - version: VersionAlpha, + version: VersionAlpha, keyType: Regional, serviceType: reflect.TypeOf(&alpha.RegionTargetHttpProxiesService{}), additionalMethods: []string{ From 7995c7c5f2f98170e2131a51606884ff368e51ef Mon Sep 17 00:00:00 2001 From: Spencer Hance Date: Tue, 28 May 2019 17:54:56 -0700 Subject: [PATCH 2/2] Add SetTarget method to regional forwarding rules (alpha, beta, ga) --- pkg/cloud/gen.go | 153 +++++++++++++++++++++++++++++++++++++---- pkg/cloud/meta/meta.go | 9 +++ 2 files changed, 150 insertions(+), 12 deletions(-) diff --git a/pkg/cloud/gen.go b/pkg/cloud/gen.go index 908f200d..b503211a 100644 --- a/pkg/cloud/gen.go +++ b/pkg/cloud/gen.go @@ -7158,6 +7158,7 @@ type ForwardingRules interface { 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 + SetTarget(context.Context, *meta.Key, *ga.TargetReference) error } // NewMockForwardingRules returns a new mock for ForwardingRules. @@ -7193,10 +7194,11 @@ type MockForwardingRules struct { // 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(ctx context.Context, key *meta.Key, m *MockForwardingRules) (bool, *ga.ForwardingRule, error) - ListHook func(ctx context.Context, region string, fl *filter.F, m *MockForwardingRules) (bool, []*ga.ForwardingRule, error) - InsertHook func(ctx context.Context, key *meta.Key, obj *ga.ForwardingRule, m *MockForwardingRules) (bool, error) - DeleteHook func(ctx context.Context, key *meta.Key, m *MockForwardingRules) (bool, error) + GetHook func(ctx context.Context, key *meta.Key, m *MockForwardingRules) (bool, *ga.ForwardingRule, error) + ListHook func(ctx context.Context, region string, fl *filter.F, m *MockForwardingRules) (bool, []*ga.ForwardingRule, error) + InsertHook func(ctx context.Context, key *meta.Key, obj *ga.ForwardingRule, m *MockForwardingRules) (bool, error) + DeleteHook func(ctx context.Context, key *meta.Key, m *MockForwardingRules) (bool, error) + SetTargetHook func(context.Context, *meta.Key, *ga.TargetReference, *MockForwardingRules) error // X is extra state that can be used as part of the mock. Generated code // will not use this field. @@ -7345,6 +7347,14 @@ func (m *MockForwardingRules) Obj(o *ga.ForwardingRule) *MockForwardingRulesObj return &MockForwardingRulesObj{o} } +// SetTarget is a mock for the corresponding method. +func (m *MockForwardingRules) SetTarget(ctx context.Context, key *meta.Key, arg0 *ga.TargetReference) error { + if m.SetTargetHook != nil { + return m.SetTargetHook(ctx, key, arg0, m) + } + return nil +} + // GCEForwardingRules is a simplifying adapter for the GCE ForwardingRules. type GCEForwardingRules struct { s *Service @@ -7486,12 +7496,46 @@ func (g *GCEForwardingRules) Delete(ctx context.Context, key *meta.Key) error { return err } +// SetTarget is a method on GCEForwardingRules. +func (g *GCEForwardingRules) SetTarget(ctx context.Context, key *meta.Key, arg0 *ga.TargetReference) error { + klog.V(5).Infof("GCEForwardingRules.SetTarget(%v, %v, ...): called", ctx, key) + + if !key.Valid() { + klog.V(2).Infof("GCEForwardingRules.SetTarget(%v, %v, ...): key is invalid (%#v)", ctx, key, key) + return fmt.Errorf("invalid GCE key (%+v)", key) + } + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "ForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "SetTarget", + Version: meta.Version("ga"), + Service: "ForwardingRules", + } + klog.V(5).Infof("GCEForwardingRules.SetTarget(%v, %v, ...): projectID = %v, rk = %+v", ctx, key, projectID, rk) + + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + klog.V(4).Infof("GCEForwardingRules.SetTarget(%v, %v, ...): RateLimiter error: %v", ctx, key, err) + return err + } + call := g.s.GA.ForwardingRules.SetTarget(projectID, key.Region, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + klog.V(4).Infof("GCEForwardingRules.SetTarget(%v, %v, ...) = %+v", ctx, key, err) + return err + } + err = g.s.WaitForCompletion(ctx, op) + klog.V(4).Infof("GCEForwardingRules.SetTarget(%v, %v, ...) = %+v", ctx, key, err) + return err +} + // 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 + SetTarget(context.Context, *meta.Key, *alpha.TargetReference) error } // NewMockAlphaForwardingRules returns a new mock for ForwardingRules. @@ -7527,10 +7571,11 @@ type MockAlphaForwardingRules struct { // 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(ctx context.Context, key *meta.Key, m *MockAlphaForwardingRules) (bool, *alpha.ForwardingRule, error) - ListHook func(ctx context.Context, region string, fl *filter.F, m *MockAlphaForwardingRules) (bool, []*alpha.ForwardingRule, error) - InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.ForwardingRule, m *MockAlphaForwardingRules) (bool, error) - DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaForwardingRules) (bool, error) + GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaForwardingRules) (bool, *alpha.ForwardingRule, error) + ListHook func(ctx context.Context, region string, fl *filter.F, m *MockAlphaForwardingRules) (bool, []*alpha.ForwardingRule, error) + InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.ForwardingRule, m *MockAlphaForwardingRules) (bool, error) + DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaForwardingRules) (bool, error) + SetTargetHook func(context.Context, *meta.Key, *alpha.TargetReference, *MockAlphaForwardingRules) error // X is extra state that can be used as part of the mock. Generated code // will not use this field. @@ -7679,6 +7724,14 @@ func (m *MockAlphaForwardingRules) Obj(o *alpha.ForwardingRule) *MockForwardingR return &MockForwardingRulesObj{o} } +// SetTarget is a mock for the corresponding method. +func (m *MockAlphaForwardingRules) SetTarget(ctx context.Context, key *meta.Key, arg0 *alpha.TargetReference) error { + if m.SetTargetHook != nil { + return m.SetTargetHook(ctx, key, arg0, m) + } + return nil +} + // GCEAlphaForwardingRules is a simplifying adapter for the GCE ForwardingRules. type GCEAlphaForwardingRules struct { s *Service @@ -7820,12 +7873,46 @@ func (g *GCEAlphaForwardingRules) Delete(ctx context.Context, key *meta.Key) err return err } +// SetTarget is a method on GCEAlphaForwardingRules. +func (g *GCEAlphaForwardingRules) SetTarget(ctx context.Context, key *meta.Key, arg0 *alpha.TargetReference) error { + klog.V(5).Infof("GCEAlphaForwardingRules.SetTarget(%v, %v, ...): called", ctx, key) + + if !key.Valid() { + klog.V(2).Infof("GCEAlphaForwardingRules.SetTarget(%v, %v, ...): key is invalid (%#v)", ctx, key, key) + return fmt.Errorf("invalid GCE key (%+v)", key) + } + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "ForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "SetTarget", + Version: meta.Version("alpha"), + Service: "ForwardingRules", + } + klog.V(5).Infof("GCEAlphaForwardingRules.SetTarget(%v, %v, ...): projectID = %v, rk = %+v", ctx, key, projectID, rk) + + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + klog.V(4).Infof("GCEAlphaForwardingRules.SetTarget(%v, %v, ...): RateLimiter error: %v", ctx, key, err) + return err + } + call := g.s.Alpha.ForwardingRules.SetTarget(projectID, key.Region, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + klog.V(4).Infof("GCEAlphaForwardingRules.SetTarget(%v, %v, ...) = %+v", ctx, key, err) + return err + } + err = g.s.WaitForCompletion(ctx, op) + klog.V(4).Infof("GCEAlphaForwardingRules.SetTarget(%v, %v, ...) = %+v", ctx, key, err) + return err +} + // BetaForwardingRules is an interface that allows for mocking of ForwardingRules. type BetaForwardingRules interface { Get(ctx context.Context, key *meta.Key) (*beta.ForwardingRule, error) List(ctx context.Context, region string, fl *filter.F) ([]*beta.ForwardingRule, error) Insert(ctx context.Context, key *meta.Key, obj *beta.ForwardingRule) error Delete(ctx context.Context, key *meta.Key) error + SetTarget(context.Context, *meta.Key, *beta.TargetReference) error } // NewMockBetaForwardingRules returns a new mock for ForwardingRules. @@ -7861,10 +7948,11 @@ type MockBetaForwardingRules struct { // 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(ctx context.Context, key *meta.Key, m *MockBetaForwardingRules) (bool, *beta.ForwardingRule, error) - ListHook func(ctx context.Context, region string, fl *filter.F, m *MockBetaForwardingRules) (bool, []*beta.ForwardingRule, error) - InsertHook func(ctx context.Context, key *meta.Key, obj *beta.ForwardingRule, m *MockBetaForwardingRules) (bool, error) - DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaForwardingRules) (bool, error) + GetHook func(ctx context.Context, key *meta.Key, m *MockBetaForwardingRules) (bool, *beta.ForwardingRule, error) + ListHook func(ctx context.Context, region string, fl *filter.F, m *MockBetaForwardingRules) (bool, []*beta.ForwardingRule, error) + InsertHook func(ctx context.Context, key *meta.Key, obj *beta.ForwardingRule, m *MockBetaForwardingRules) (bool, error) + DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaForwardingRules) (bool, error) + SetTargetHook func(context.Context, *meta.Key, *beta.TargetReference, *MockBetaForwardingRules) error // X is extra state that can be used as part of the mock. Generated code // will not use this field. @@ -8013,6 +8101,14 @@ func (m *MockBetaForwardingRules) Obj(o *beta.ForwardingRule) *MockForwardingRul return &MockForwardingRulesObj{o} } +// SetTarget is a mock for the corresponding method. +func (m *MockBetaForwardingRules) SetTarget(ctx context.Context, key *meta.Key, arg0 *beta.TargetReference) error { + if m.SetTargetHook != nil { + return m.SetTargetHook(ctx, key, arg0, m) + } + return nil +} + // GCEBetaForwardingRules is a simplifying adapter for the GCE ForwardingRules. type GCEBetaForwardingRules struct { s *Service @@ -8154,6 +8250,39 @@ func (g *GCEBetaForwardingRules) Delete(ctx context.Context, key *meta.Key) erro return err } +// SetTarget is a method on GCEBetaForwardingRules. +func (g *GCEBetaForwardingRules) SetTarget(ctx context.Context, key *meta.Key, arg0 *beta.TargetReference) error { + klog.V(5).Infof("GCEBetaForwardingRules.SetTarget(%v, %v, ...): called", ctx, key) + + if !key.Valid() { + klog.V(2).Infof("GCEBetaForwardingRules.SetTarget(%v, %v, ...): key is invalid (%#v)", ctx, key, key) + return fmt.Errorf("invalid GCE key (%+v)", key) + } + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "ForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "SetTarget", + Version: meta.Version("beta"), + Service: "ForwardingRules", + } + klog.V(5).Infof("GCEBetaForwardingRules.SetTarget(%v, %v, ...): projectID = %v, rk = %+v", ctx, key, projectID, rk) + + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + klog.V(4).Infof("GCEBetaForwardingRules.SetTarget(%v, %v, ...): RateLimiter error: %v", ctx, key, err) + return err + } + call := g.s.Beta.ForwardingRules.SetTarget(projectID, key.Region, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + klog.V(4).Infof("GCEBetaForwardingRules.SetTarget(%v, %v, ...) = %+v", ctx, key, err) + return err + } + err = g.s.WaitForCompletion(ctx, op) + klog.V(4).Infof("GCEBetaForwardingRules.SetTarget(%v, %v, ...) = %+v", ctx, key, err) + return err +} + // AlphaGlobalForwardingRules is an interface that allows for mocking of GlobalForwardingRules. type AlphaGlobalForwardingRules interface { Get(ctx context.Context, key *meta.Key) (*alpha.ForwardingRule, error) diff --git a/pkg/cloud/meta/meta.go b/pkg/cloud/meta/meta.go index 1156e82d..5f5214e9 100644 --- a/pkg/cloud/meta/meta.go +++ b/pkg/cloud/meta/meta.go @@ -203,6 +203,9 @@ var AllServices = []*ServiceInfo{ Resource: "forwardingRules", keyType: Regional, serviceType: reflect.TypeOf(&ga.ForwardingRulesService{}), + additionalMethods: []string{ + "SetTarget", + }, }, { Object: "ForwardingRule", @@ -211,6 +214,9 @@ var AllServices = []*ServiceInfo{ version: VersionAlpha, keyType: Regional, serviceType: reflect.TypeOf(&alpha.ForwardingRulesService{}), + additionalMethods: []string{ + "SetTarget", + }, }, { Object: "ForwardingRule", @@ -219,6 +225,9 @@ var AllServices = []*ServiceInfo{ version: VersionBeta, keyType: Regional, serviceType: reflect.TypeOf(&beta.ForwardingRulesService{}), + additionalMethods: []string{ + "SetTarget", + }, }, { Object: "ForwardingRule",