From daf0cf7138f2ad694cf8097595d173f1b9ecbc83 Mon Sep 17 00:00:00 2001 From: Yang Song Date: Thu, 30 May 2024 22:47:36 +0000 Subject: [PATCH 1/2] Add regional NEG to generated resource. --- pkg/cloud/meta/compute_services.go | 39 ++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/pkg/cloud/meta/compute_services.go b/pkg/cloud/meta/compute_services.go index ba36fddf..31b2092c 100644 --- a/pkg/cloud/meta/compute_services.go +++ b/pkg/cloud/meta/compute_services.go @@ -648,6 +648,45 @@ var ComputeServices = []*ServiceInfo{ "ListNetworkEndpoints", }, }, + { + Object: "NetworkEndpointGroup", + Service: "RegionNetworkEndpointGroups", + Resource: "networkEndpointGroups", + version: VersionAlpha, + keyType: Regional, + serviceType: reflect.TypeOf(&alpha.RegionNetworkEndpointGroupsService{}), + additionalMethods: []string{ + "AttachNetworkEndpoints", + "DetachNetworkEndpoints", + "ListNetworkEndpoints", + }, + }, + { + Object: "NetworkEndpointGroup", + Service: "RegionNetworkEndpointGroups", + Resource: "networkEndpointGroups", + version: VersionBeta, + keyType: Regional, + serviceType: reflect.TypeOf(&beta.RegionNetworkEndpointGroupsService{}), + additionalMethods: []string{ + "AttachNetworkEndpoints", + "DetachNetworkEndpoints", + "ListNetworkEndpoints", + }, + }, + { + Object: "NetworkEndpointGroup", + Service: "RegionNetworkEndpointGroups", + Resource: "networkEndpointGroups", + version: VersionGA, + keyType: Regional, + serviceType: reflect.TypeOf(&ga.RegionNetworkEndpointGroupsService{}), + additionalMethods: []string{ + "AttachNetworkEndpoints", + "DetachNetworkEndpoints", + "ListNetworkEndpoints", + }, + }, { Object: "Project", Service: "Projects", From c68a02c87177b96978d73c7ab13da38c27385a97 Mon Sep 17 00:00:00 2001 From: Yang Song Date: Thu, 30 May 2024 22:49:21 +0000 Subject: [PATCH 2/2] Regional NEG generated code. --- pkg/cloud/gen.go | 2560 ++++++++++++++++++++++++++++++++++------- pkg/cloud/gen_test.go | 136 +++ 2 files changed, 2269 insertions(+), 427 deletions(-) diff --git a/pkg/cloud/gen.go b/pkg/cloud/gen.go index 6f7a8c14..7fd46739 100644 --- a/pkg/cloud/gen.go +++ b/pkg/cloud/gen.go @@ -95,6 +95,9 @@ type Cloud interface { AlphaGlobalNetworkEndpointGroups() AlphaGlobalNetworkEndpointGroups BetaGlobalNetworkEndpointGroups() BetaGlobalNetworkEndpointGroups GlobalNetworkEndpointGroups() GlobalNetworkEndpointGroups + AlphaRegionNetworkEndpointGroups() AlphaRegionNetworkEndpointGroups + BetaRegionNetworkEndpointGroups() BetaRegionNetworkEndpointGroups + RegionNetworkEndpointGroups() RegionNetworkEndpointGroups Projects() Projects Regions() Regions AlphaRouters() AlphaRouters @@ -199,6 +202,9 @@ func NewGCE(s *Service) *GCE { gceAlphaGlobalNetworkEndpointGroups: &GCEAlphaGlobalNetworkEndpointGroups{s}, gceBetaGlobalNetworkEndpointGroups: &GCEBetaGlobalNetworkEndpointGroups{s}, gceGlobalNetworkEndpointGroups: &GCEGlobalNetworkEndpointGroups{s}, + gceAlphaRegionNetworkEndpointGroups: &GCEAlphaRegionNetworkEndpointGroups{s}, + gceBetaRegionNetworkEndpointGroups: &GCEBetaRegionNetworkEndpointGroups{s}, + gceRegionNetworkEndpointGroups: &GCERegionNetworkEndpointGroups{s}, gceProjects: &GCEProjects{s}, gceRegions: &GCERegions{s}, gceAlphaRouters: &GCEAlphaRouters{s}, @@ -307,6 +313,9 @@ type GCE struct { gceAlphaGlobalNetworkEndpointGroups *GCEAlphaGlobalNetworkEndpointGroups gceBetaGlobalNetworkEndpointGroups *GCEBetaGlobalNetworkEndpointGroups gceGlobalNetworkEndpointGroups *GCEGlobalNetworkEndpointGroups + gceAlphaRegionNetworkEndpointGroups *GCEAlphaRegionNetworkEndpointGroups + gceBetaRegionNetworkEndpointGroups *GCEBetaRegionNetworkEndpointGroups + gceRegionNetworkEndpointGroups *GCERegionNetworkEndpointGroups gceProjects *GCEProjects gceRegions *GCERegions gceAlphaRouters *GCEAlphaRouters @@ -612,6 +621,21 @@ func (gce *GCE) GlobalNetworkEndpointGroups() GlobalNetworkEndpointGroups { return gce.gceGlobalNetworkEndpointGroups } +// AlphaRegionNetworkEndpointGroups returns the interface for the alpha RegionNetworkEndpointGroups. +func (gce *GCE) AlphaRegionNetworkEndpointGroups() AlphaRegionNetworkEndpointGroups { + return gce.gceAlphaRegionNetworkEndpointGroups +} + +// BetaRegionNetworkEndpointGroups returns the interface for the beta RegionNetworkEndpointGroups. +func (gce *GCE) BetaRegionNetworkEndpointGroups() BetaRegionNetworkEndpointGroups { + return gce.gceBetaRegionNetworkEndpointGroups +} + +// RegionNetworkEndpointGroups returns the interface for the ga RegionNetworkEndpointGroups. +func (gce *GCE) RegionNetworkEndpointGroups() RegionNetworkEndpointGroups { + return gce.gceRegionNetworkEndpointGroups +} + // Projects returns the interface for the ga Projects. func (gce *GCE) Projects() Projects { return gce.gceProjects @@ -878,6 +902,7 @@ func NewMockGCE(projectRouter ProjectRouter) *MockGCE { mockRegionBackendServicesObjs := map[meta.Key]*MockRegionBackendServicesObj{} mockRegionDisksObjs := map[meta.Key]*MockRegionDisksObj{} mockRegionHealthChecksObjs := map[meta.Key]*MockRegionHealthChecksObj{} + mockRegionNetworkEndpointGroupsObjs := map[meta.Key]*MockRegionNetworkEndpointGroupsObj{} mockRegionNetworkFirewallPoliciesObjs := map[meta.Key]*MockRegionNetworkFirewallPoliciesObj{} mockRegionSslCertificatesObjs := map[meta.Key]*MockRegionSslCertificatesObj{} mockRegionSslPoliciesObjs := map[meta.Key]*MockRegionSslPoliciesObj{} @@ -952,6 +977,9 @@ func NewMockGCE(projectRouter ProjectRouter) *MockGCE { MockAlphaGlobalNetworkEndpointGroups: NewMockAlphaGlobalNetworkEndpointGroups(projectRouter, mockGlobalNetworkEndpointGroupsObjs), MockBetaGlobalNetworkEndpointGroups: NewMockBetaGlobalNetworkEndpointGroups(projectRouter, mockGlobalNetworkEndpointGroupsObjs), MockGlobalNetworkEndpointGroups: NewMockGlobalNetworkEndpointGroups(projectRouter, mockGlobalNetworkEndpointGroupsObjs), + MockAlphaRegionNetworkEndpointGroups: NewMockAlphaRegionNetworkEndpointGroups(projectRouter, mockRegionNetworkEndpointGroupsObjs), + MockBetaRegionNetworkEndpointGroups: NewMockBetaRegionNetworkEndpointGroups(projectRouter, mockRegionNetworkEndpointGroupsObjs), + MockRegionNetworkEndpointGroups: NewMockRegionNetworkEndpointGroups(projectRouter, mockRegionNetworkEndpointGroupsObjs), MockProjects: NewMockProjects(projectRouter, mockProjectsObjs), MockRegions: NewMockRegions(projectRouter, mockRegionsObjs), MockAlphaRouters: NewMockAlphaRouters(projectRouter, mockRoutersObjs), @@ -1060,6 +1088,9 @@ type MockGCE struct { MockAlphaGlobalNetworkEndpointGroups *MockAlphaGlobalNetworkEndpointGroups MockBetaGlobalNetworkEndpointGroups *MockBetaGlobalNetworkEndpointGroups MockGlobalNetworkEndpointGroups *MockGlobalNetworkEndpointGroups + MockAlphaRegionNetworkEndpointGroups *MockAlphaRegionNetworkEndpointGroups + MockBetaRegionNetworkEndpointGroups *MockBetaRegionNetworkEndpointGroups + MockRegionNetworkEndpointGroups *MockRegionNetworkEndpointGroups MockProjects *MockProjects MockRegions *MockRegions MockAlphaRouters *MockAlphaRouters @@ -1365,6 +1396,21 @@ func (mock *MockGCE) GlobalNetworkEndpointGroups() GlobalNetworkEndpointGroups { return mock.MockGlobalNetworkEndpointGroups } +// AlphaRegionNetworkEndpointGroups returns the interface for the alpha RegionNetworkEndpointGroups. +func (mock *MockGCE) AlphaRegionNetworkEndpointGroups() AlphaRegionNetworkEndpointGroups { + return mock.MockAlphaRegionNetworkEndpointGroups +} + +// BetaRegionNetworkEndpointGroups returns the interface for the beta RegionNetworkEndpointGroups. +func (mock *MockGCE) BetaRegionNetworkEndpointGroups() BetaRegionNetworkEndpointGroups { + return mock.MockBetaRegionNetworkEndpointGroups +} + +// RegionNetworkEndpointGroups returns the interface for the ga RegionNetworkEndpointGroups. +func (mock *MockGCE) RegionNetworkEndpointGroups() RegionNetworkEndpointGroups { + return mock.MockRegionNetworkEndpointGroups +} + // Projects returns the interface for the ga Projects. func (mock *MockGCE) Projects() Projects { return mock.MockProjects @@ -2462,6 +2508,52 @@ func (m *MockRegionHealthChecksObj) ToGA() *computega.HealthCheck { return ret } +// MockRegionNetworkEndpointGroupsObj 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 MockRegionNetworkEndpointGroupsObj struct { + Obj interface{} +} + +// ToAlpha retrieves the given version of the object. +func (m *MockRegionNetworkEndpointGroupsObj) ToAlpha() *computealpha.NetworkEndpointGroup { + if ret, ok := m.Obj.(*computealpha.NetworkEndpointGroup); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &computealpha.NetworkEndpointGroup{} + if err := copyViaJSON(ret, m.Obj); err != nil { + klog.Errorf("Could not convert %T to *computealpha.NetworkEndpointGroup via JSON: %v", m.Obj, err) + } + return ret +} + +// ToBeta retrieves the given version of the object. +func (m *MockRegionNetworkEndpointGroupsObj) ToBeta() *computebeta.NetworkEndpointGroup { + if ret, ok := m.Obj.(*computebeta.NetworkEndpointGroup); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &computebeta.NetworkEndpointGroup{} + if err := copyViaJSON(ret, m.Obj); err != nil { + klog.Errorf("Could not convert %T to *computebeta.NetworkEndpointGroup via JSON: %v", m.Obj, err) + } + return ret +} + +// ToGA retrieves the given version of the object. +func (m *MockRegionNetworkEndpointGroupsObj) ToGA() *computega.NetworkEndpointGroup { + if ret, ok := m.Obj.(*computega.NetworkEndpointGroup); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &computega.NetworkEndpointGroup{} + if err := copyViaJSON(ret, m.Obj); err != nil { + klog.Errorf("Could not convert %T to *computega.NetworkEndpointGroup via JSON: %v", m.Obj, err) + } + return ret +} + // MockRegionNetworkFirewallPoliciesObj 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. @@ -29539,276 +29631,20 @@ func (g *GCEGlobalNetworkEndpointGroups) ListNetworkEndpoints(ctx context.Contex return all, nil } -// Projects is an interface that allows for mocking of Projects. -type Projects interface { - // ProjectsOps is an interface with additional non-CRUD type methods. - // This interface is expected to be implemented by hand (non-autogenerated). - ProjectsOps -} - -// NewMockProjects returns a new mock for Projects. -func NewMockProjects(pr ProjectRouter, objs map[meta.Key]*MockProjectsObj) *MockProjects { - mock := &MockProjects{ - ProjectRouter: pr, - - Objects: objs, - } - return mock -} - -// MockProjects is the mock for Projects. -type MockProjects struct { - Lock sync.Mutex - - ProjectRouter ProjectRouter - - // Objects maintained by the mock. - Objects map[meta.Key]*MockProjectsObj - - // If an entry exists for the given key and operation, then the error - // will be returned instead of the operation. - - // xxxHook allow you to intercept the standard processing of the mock in - // order to add your own logic. Return (true, _, _) to prevent the normal - // execution flow of the mock. Return (false, nil, nil) to continue with - // normal mock behavior/ after the hook function executes. - - // X is extra state that can be used as part of the mock. Generated code - // will not use this field. - X interface{} -} - -// Obj wraps the object for use in the mock. -func (m *MockProjects) Obj(o *computega.Project) *MockProjectsObj { - return &MockProjectsObj{o} -} - -// GCEProjects is a simplifying adapter for the GCE Projects. -type GCEProjects struct { - s *Service -} - -// Regions is an interface that allows for mocking of Regions. -type Regions interface { - Get(ctx context.Context, key *meta.Key, options ...Option) (*computega.Region, error) - List(ctx context.Context, fl *filter.F, options ...Option) ([]*computega.Region, error) -} - -// NewMockRegions returns a new mock for Regions. -func NewMockRegions(pr ProjectRouter, objs map[meta.Key]*MockRegionsObj) *MockRegions { - mock := &MockRegions{ - ProjectRouter: pr, - - Objects: objs, - GetError: map[meta.Key]error{}, - } - return mock -} - -// MockRegions is the mock for Regions. -type MockRegions struct { - Lock sync.Mutex - - ProjectRouter ProjectRouter - - // Objects maintained by the mock. - Objects map[meta.Key]*MockRegionsObj - - // If an entry exists for the given key and operation, then the error - // will be returned instead of the operation. - GetError map[meta.Key]error - ListError *error - - // xxxHook allow you to intercept the standard processing of the mock in - // order to add your own logic. Return (true, _, _) to prevent the normal - // execution flow of the mock. Return (false, nil, nil) to continue with - // normal mock behavior/ after the hook function executes. - GetHook func(ctx context.Context, key *meta.Key, m *MockRegions, options ...Option) (bool, *computega.Region, error) - ListHook func(ctx context.Context, fl *filter.F, m *MockRegions, options ...Option) (bool, []*computega.Region, error) - - // X is extra state that can be used as part of the mock. Generated code - // will not use this field. - X interface{} -} - -// Get returns the object from the mock. -func (m *MockRegions) Get(ctx context.Context, key *meta.Key, options ...Option) (*computega.Region, error) { - if m.GetHook != nil { - if intercept, obj, err := m.GetHook(ctx, key, m, options...); intercept { - klog.V(5).Infof("MockRegions.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("MockRegions.Get(%v, %s) = nil, %v", ctx, key, err) - return nil, err - } - if obj, ok := m.Objects[*key]; ok { - typedObj := obj.ToGA() - klog.V(5).Infof("MockRegions.Get(%v, %s) = %+v, nil", ctx, key, typedObj) - return typedObj, nil - } - - err := &googleapi.Error{ - Code: http.StatusNotFound, - Message: fmt.Sprintf("MockRegions %v not found", key), - } - klog.V(5).Infof("MockRegions.Get(%v, %s) = nil, %v", ctx, key, err) - return nil, err -} - -// List all of the objects in the mock. -func (m *MockRegions) List(ctx context.Context, fl *filter.F, options ...Option) ([]*computega.Region, error) { - if m.ListHook != nil { - if intercept, objs, err := m.ListHook(ctx, fl, m, options...); intercept { - klog.V(5).Infof("MockRegions.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) - return objs, err - } - } - - m.Lock.Lock() - defer m.Lock.Unlock() - - if m.ListError != nil { - err := *m.ListError - klog.V(5).Infof("MockRegions.List(%v, %v) = nil, %v", ctx, fl, err) - - return nil, *m.ListError - } - - var objs []*computega.Region - for _, obj := range m.Objects { - if !fl.Match(obj.ToGA()) { - continue - } - objs = append(objs, obj.ToGA()) - } - - klog.V(5).Infof("MockRegions.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) - return objs, nil -} - -// Obj wraps the object for use in the mock. -func (m *MockRegions) Obj(o *computega.Region) *MockRegionsObj { - return &MockRegionsObj{o} -} - -// GCERegions is a simplifying adapter for the GCE Regions. -type GCERegions struct { - s *Service -} - -// Get the Region named by key. -func (g *GCERegions) Get(ctx context.Context, key *meta.Key, options ...Option) (*computega.Region, error) { - opts := mergeOptions(options) - klog.V(5).Infof("GCERegions.Get(%v, %v, %v): called", ctx, key, opts) - - if !key.Valid() { - klog.V(2).Infof("GCERegions.Get(%v, %v): key is invalid (%#v)", ctx, key, key) - return nil, fmt.Errorf("invalid GCE key (%#v)", key) - } - projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "ga", "Regions") - - ck := &CallContextKey{ - ProjectID: projectID, - Operation: "Get", - Version: meta.Version("ga"), - Service: "Regions", - } - - klog.V(5).Infof("GCERegions.Get(%v, %v): projectID = %v, ck = %+v", ctx, key, projectID, ck) - callObserverStart(ctx, ck) - if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { - klog.V(4).Infof("GCERegions.Get(%v, %v): RateLimiter error: %v", ctx, key, err) - return nil, err - } - call := g.s.GA.Regions.Get(projectID, key.Name) - call.Context(ctx) - v, err := call.Do() - klog.V(4).Infof("GCERegions.Get(%v, %v) = %+v, %v", ctx, key, v, err) - - callObserverEnd(ctx, ck, err) - g.s.RateLimiter.Observe(ctx, err, ck) - - return v, err -} - -// List all Region objects. -func (g *GCERegions) List(ctx context.Context, fl *filter.F, options ...Option) ([]*computega.Region, error) { - opts := mergeOptions(options) - klog.V(5).Infof("GCERegions.List(%v, %v, %v) called", ctx, fl, opts) - projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "ga", "Regions") - - ck := &CallContextKey{ - ProjectID: projectID, - Operation: "List", - Version: meta.Version("ga"), - Service: "Regions", - } - - callObserverStart(ctx, ck) - if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { - return nil, err - } - klog.V(5).Infof("GCERegions.List(%v, %v): projectID = %v, ck = %+v", ctx, fl, projectID, ck) - call := g.s.GA.Regions.List(projectID) - if fl != filter.None { - call.Filter(fl.String()) - } - - var all []*computega.Region - f := func(l *computega.RegionList) error { - klog.V(5).Infof("GCERegions.List(%v, ..., %v): page %+v", ctx, fl, l) - all = append(all, l.Items...) - return nil - } - if err := call.Pages(ctx, f); err != nil { - callObserverEnd(ctx, ck, err) - g.s.RateLimiter.Observe(ctx, err, ck) - - klog.V(4).Infof("GCERegions.List(%v, ..., %v) = %v, %v", ctx, fl, nil, err) - return nil, err - } - - callObserverEnd(ctx, ck, nil) - g.s.RateLimiter.Observe(ctx, nil, ck) - - if kLogEnabled(4) { - klog.V(4).Infof("GCERegions.List(%v, ..., %v) = [%v items], %v", ctx, fl, len(all), nil) - } else if kLogEnabled(5) { - var asStr []string - for _, o := range all { - asStr = append(asStr, fmt.Sprintf("%+v", o)) - } - klog.V(5).Infof("GCERegions.List(%v, ..., %v) = %v, %v", ctx, fl, asStr, nil) - } - - return all, nil -} - -// AlphaRouters is an interface that allows for mocking of Routers. -type AlphaRouters interface { - Get(ctx context.Context, key *meta.Key, options ...Option) (*computealpha.Router, error) - List(ctx context.Context, region string, fl *filter.F, options ...Option) ([]*computealpha.Router, error) - Insert(ctx context.Context, key *meta.Key, obj *computealpha.Router, options ...Option) error +// AlphaRegionNetworkEndpointGroups is an interface that allows for mocking of RegionNetworkEndpointGroups. +type AlphaRegionNetworkEndpointGroups interface { + Get(ctx context.Context, key *meta.Key, options ...Option) (*computealpha.NetworkEndpointGroup, error) + List(ctx context.Context, region string, fl *filter.F, options ...Option) ([]*computealpha.NetworkEndpointGroup, error) + Insert(ctx context.Context, key *meta.Key, obj *computealpha.NetworkEndpointGroup, options ...Option) error Delete(ctx context.Context, key *meta.Key, options ...Option) error - AggregatedList(ctx context.Context, fl *filter.F, options ...Option) (map[string][]*computealpha.Router, error) - GetRouterStatus(context.Context, *meta.Key, ...Option) (*computealpha.RouterStatusResponse, error) - Patch(context.Context, *meta.Key, *computealpha.Router, ...Option) error - Preview(context.Context, *meta.Key, *computealpha.Router, ...Option) (*computealpha.RoutersPreviewResponse, error) - TestIamPermissions(context.Context, *meta.Key, *computealpha.TestPermissionsRequest, ...Option) (*computealpha.TestPermissionsResponse, error) + AttachNetworkEndpoints(context.Context, *meta.Key, *computealpha.RegionNetworkEndpointGroupsAttachEndpointsRequest, ...Option) error + DetachNetworkEndpoints(context.Context, *meta.Key, *computealpha.RegionNetworkEndpointGroupsDetachEndpointsRequest, ...Option) error + ListNetworkEndpoints(context.Context, *meta.Key, *filter.F, ...Option) ([]*computealpha.NetworkEndpointWithHealthStatus, error) } -// NewMockAlphaRouters returns a new mock for Routers. -func NewMockAlphaRouters(pr ProjectRouter, objs map[meta.Key]*MockRoutersObj) *MockAlphaRouters { - mock := &MockAlphaRouters{ +// NewMockAlphaRegionNetworkEndpointGroups returns a new mock for RegionNetworkEndpointGroups. +func NewMockAlphaRegionNetworkEndpointGroups(pr ProjectRouter, objs map[meta.Key]*MockRegionNetworkEndpointGroupsObj) *MockAlphaRegionNetworkEndpointGroups { + mock := &MockAlphaRegionNetworkEndpointGroups{ ProjectRouter: pr, Objects: objs, @@ -29819,36 +29655,33 @@ func NewMockAlphaRouters(pr ProjectRouter, objs map[meta.Key]*MockRoutersObj) *M return mock } -// MockAlphaRouters is the mock for Routers. -type MockAlphaRouters struct { +// MockAlphaRegionNetworkEndpointGroups is the mock for RegionNetworkEndpointGroups. +type MockAlphaRegionNetworkEndpointGroups struct { Lock sync.Mutex ProjectRouter ProjectRouter // Objects maintained by the mock. - Objects map[meta.Key]*MockRoutersObj + Objects map[meta.Key]*MockRegionNetworkEndpointGroupsObj // If an entry exists for the given key and operation, then the error // will be returned instead of the operation. - GetError map[meta.Key]error - ListError *error - InsertError map[meta.Key]error - DeleteError map[meta.Key]error - AggregatedListError *error + 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 *MockAlphaRouters, options ...Option) (bool, *computealpha.Router, error) - ListHook func(ctx context.Context, region string, fl *filter.F, m *MockAlphaRouters, options ...Option) (bool, []*computealpha.Router, error) - InsertHook func(ctx context.Context, key *meta.Key, obj *computealpha.Router, m *MockAlphaRouters, options ...Option) (bool, error) - DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaRouters, options ...Option) (bool, error) - AggregatedListHook func(ctx context.Context, fl *filter.F, m *MockAlphaRouters, options ...Option) (bool, map[string][]*computealpha.Router, error) - GetRouterStatusHook func(context.Context, *meta.Key, *MockAlphaRouters, ...Option) (*computealpha.RouterStatusResponse, error) - PatchHook func(context.Context, *meta.Key, *computealpha.Router, *MockAlphaRouters, ...Option) error - PreviewHook func(context.Context, *meta.Key, *computealpha.Router, *MockAlphaRouters, ...Option) (*computealpha.RoutersPreviewResponse, error) - TestIamPermissionsHook func(context.Context, *meta.Key, *computealpha.TestPermissionsRequest, *MockAlphaRouters, ...Option) (*computealpha.TestPermissionsResponse, error) + GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaRegionNetworkEndpointGroups, options ...Option) (bool, *computealpha.NetworkEndpointGroup, error) + ListHook func(ctx context.Context, region string, fl *filter.F, m *MockAlphaRegionNetworkEndpointGroups, options ...Option) (bool, []*computealpha.NetworkEndpointGroup, error) + InsertHook func(ctx context.Context, key *meta.Key, obj *computealpha.NetworkEndpointGroup, m *MockAlphaRegionNetworkEndpointGroups, options ...Option) (bool, error) + DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaRegionNetworkEndpointGroups, options ...Option) (bool, error) + AttachNetworkEndpointsHook func(context.Context, *meta.Key, *computealpha.RegionNetworkEndpointGroupsAttachEndpointsRequest, *MockAlphaRegionNetworkEndpointGroups, ...Option) error + DetachNetworkEndpointsHook func(context.Context, *meta.Key, *computealpha.RegionNetworkEndpointGroupsDetachEndpointsRequest, *MockAlphaRegionNetworkEndpointGroups, ...Option) error + ListNetworkEndpointsHook func(context.Context, *meta.Key, *filter.F, *MockAlphaRegionNetworkEndpointGroups, ...Option) ([]*computealpha.NetworkEndpointWithHealthStatus, error) // X is extra state that can be used as part of the mock. Generated code // will not use this field. @@ -29856,10 +29689,10 @@ type MockAlphaRouters struct { } // Get returns the object from the mock. -func (m *MockAlphaRouters) Get(ctx context.Context, key *meta.Key, options ...Option) (*computealpha.Router, error) { +func (m *MockAlphaRegionNetworkEndpointGroups) Get(ctx context.Context, key *meta.Key, options ...Option) (*computealpha.NetworkEndpointGroup, error) { if m.GetHook != nil { if intercept, obj, err := m.GetHook(ctx, key, m, options...); intercept { - klog.V(5).Infof("MockAlphaRouters.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + klog.V(5).Infof("MockAlphaRegionNetworkEndpointGroups.Get(%v, %s) = %+v, %v", ctx, key, obj, err) return obj, err } } @@ -29871,28 +29704,28 @@ func (m *MockAlphaRouters) Get(ctx context.Context, key *meta.Key, options ...Op defer m.Lock.Unlock() if err, ok := m.GetError[*key]; ok { - klog.V(5).Infof("MockAlphaRouters.Get(%v, %s) = nil, %v", ctx, key, err) + klog.V(5).Infof("MockAlphaRegionNetworkEndpointGroups.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("MockAlphaRouters.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + klog.V(5).Infof("MockAlphaRegionNetworkEndpointGroups.Get(%v, %s) = %+v, nil", ctx, key, typedObj) return typedObj, nil } err := &googleapi.Error{ Code: http.StatusNotFound, - Message: fmt.Sprintf("MockAlphaRouters %v not found", key), + Message: fmt.Sprintf("MockAlphaRegionNetworkEndpointGroups %v not found", key), } - klog.V(5).Infof("MockAlphaRouters.Get(%v, %s) = nil, %v", ctx, key, err) + klog.V(5).Infof("MockAlphaRegionNetworkEndpointGroups.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 *MockAlphaRouters) List(ctx context.Context, region string, fl *filter.F, options ...Option) ([]*computealpha.Router, error) { +func (m *MockAlphaRegionNetworkEndpointGroups) List(ctx context.Context, region string, fl *filter.F, options ...Option) ([]*computealpha.NetworkEndpointGroup, error) { if m.ListHook != nil { if intercept, objs, err := m.ListHook(ctx, region, fl, m, options...); intercept { - klog.V(5).Infof("MockAlphaRouters.List(%v, %q, %v) = [%v items], %v", ctx, region, fl, len(objs), err) + klog.V(5).Infof("MockAlphaRegionNetworkEndpointGroups.List(%v, %q, %v) = [%v items], %v", ctx, region, fl, len(objs), err) return objs, err } } @@ -29902,12 +29735,12 @@ func (m *MockAlphaRouters) List(ctx context.Context, region string, fl *filter.F if m.ListError != nil { err := *m.ListError - klog.V(5).Infof("MockAlphaRouters.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + klog.V(5).Infof("MockAlphaRegionNetworkEndpointGroups.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) return nil, *m.ListError } - var objs []*computealpha.Router + var objs []*computealpha.NetworkEndpointGroup for key, obj := range m.Objects { if key.Region != region { continue @@ -29918,15 +29751,15 @@ func (m *MockAlphaRouters) List(ctx context.Context, region string, fl *filter.F objs = append(objs, obj.ToAlpha()) } - klog.V(5).Infof("MockAlphaRouters.List(%v, %q, %v) = [%v items], nil", ctx, region, fl, len(objs)) + klog.V(5).Infof("MockAlphaRegionNetworkEndpointGroups.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 *MockAlphaRouters) Insert(ctx context.Context, key *meta.Key, obj *computealpha.Router, options ...Option) error { +func (m *MockAlphaRegionNetworkEndpointGroups) Insert(ctx context.Context, key *meta.Key, obj *computealpha.NetworkEndpointGroup, options ...Option) error { if m.InsertHook != nil { if intercept, err := m.InsertHook(ctx, key, obj, m, options...); intercept { - klog.V(5).Infof("MockAlphaRouters.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + klog.V(5).Infof("MockAlphaRegionNetworkEndpointGroups.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) return err } } @@ -29939,32 +29772,32 @@ func (m *MockAlphaRouters) Insert(ctx context.Context, key *meta.Key, obj *compu defer m.Lock.Unlock() if err, ok := m.InsertError[*key]; ok { - klog.V(5).Infof("MockAlphaRouters.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + klog.V(5).Infof("MockAlphaRegionNetworkEndpointGroups.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("MockAlphaRouters %v exists", key), + Message: fmt.Sprintf("MockAlphaRegionNetworkEndpointGroups %v exists", key), } - klog.V(5).Infof("MockAlphaRouters.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + klog.V(5).Infof("MockAlphaRegionNetworkEndpointGroups.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) return err } obj.Name = key.Name - projectID := getProjectID(ctx, m.ProjectRouter, opts, "alpha", "routers") - obj.SelfLink = SelfLinkWithGroup("compute", meta.VersionAlpha, projectID, "routers", key) + projectID := getProjectID(ctx, m.ProjectRouter, opts, "alpha", "networkEndpointGroups") + obj.SelfLink = SelfLinkWithGroup("compute", meta.VersionAlpha, projectID, "networkEndpointGroups", key) - m.Objects[*key] = &MockRoutersObj{obj} - klog.V(5).Infof("MockAlphaRouters.Insert(%v, %v, %+v) = nil", ctx, key, obj) + m.Objects[*key] = &MockRegionNetworkEndpointGroupsObj{obj} + klog.V(5).Infof("MockAlphaRegionNetworkEndpointGroups.Insert(%v, %v, %+v) = nil", ctx, key, obj) return nil } // Delete is a mock for deleting the object. -func (m *MockAlphaRouters) Delete(ctx context.Context, key *meta.Key, options ...Option) error { +func (m *MockAlphaRegionNetworkEndpointGroups) Delete(ctx context.Context, key *meta.Key, options ...Option) error { if m.DeleteHook != nil { if intercept, err := m.DeleteHook(ctx, key, m, options...); intercept { - klog.V(5).Infof("MockAlphaRouters.Delete(%v, %v) = %v", ctx, key, err) + klog.V(5).Infof("MockAlphaRegionNetworkEndpointGroups.Delete(%v, %v) = %v", ctx, key, err) return err } } @@ -29976,128 +29809,85 @@ func (m *MockAlphaRouters) Delete(ctx context.Context, key *meta.Key, options .. defer m.Lock.Unlock() if err, ok := m.DeleteError[*key]; ok { - klog.V(5).Infof("MockAlphaRouters.Delete(%v, %v) = %v", ctx, key, err) + klog.V(5).Infof("MockAlphaRegionNetworkEndpointGroups.Delete(%v, %v) = %v", ctx, key, err) return err } if _, ok := m.Objects[*key]; !ok { err := &googleapi.Error{ Code: http.StatusNotFound, - Message: fmt.Sprintf("MockAlphaRouters %v not found", key), + Message: fmt.Sprintf("MockAlphaRegionNetworkEndpointGroups %v not found", key), } - klog.V(5).Infof("MockAlphaRouters.Delete(%v, %v) = %v", ctx, key, err) + klog.V(5).Infof("MockAlphaRegionNetworkEndpointGroups.Delete(%v, %v) = %v", ctx, key, err) return err } delete(m.Objects, *key) - klog.V(5).Infof("MockAlphaRouters.Delete(%v, %v) = nil", ctx, key) + klog.V(5).Infof("MockAlphaRegionNetworkEndpointGroups.Delete(%v, %v) = nil", ctx, key) return nil } -// AggregatedList is a mock for AggregatedList. -func (m *MockAlphaRouters) AggregatedList(ctx context.Context, fl *filter.F, options ...Option) (map[string][]*computealpha.Router, error) { - if m.AggregatedListHook != nil { - if intercept, objs, err := m.AggregatedListHook(ctx, fl, m, options...); intercept { - klog.V(5).Infof("MockAlphaRouters.AggregatedList(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) - return objs, err - } - } - - m.Lock.Lock() - defer m.Lock.Unlock() - - if m.AggregatedListError != nil { - err := *m.AggregatedListError - klog.V(5).Infof("MockAlphaRouters.AggregatedList(%v, %v) = nil, %v", ctx, fl, err) - return nil, err - } - - objs := map[string][]*computealpha.Router{} - for _, obj := range m.Objects { - res, err := ParseResourceURL(obj.ToAlpha().SelfLink) - if err != nil { - klog.V(5).Infof("MockAlphaRouters.AggregatedList(%v, %v) = nil, %v", ctx, fl, err) - return nil, err - } - if !fl.Match(obj.ToAlpha()) { - continue - } - location := aggregatedListKey(res.Key) - objs[location] = append(objs[location], obj.ToAlpha()) - } - klog.V(5).Infof("MockAlphaRouters.AggregatedList(%v, %v) = [%v items], nil", ctx, fl, len(objs)) - return objs, nil -} - // Obj wraps the object for use in the mock. -func (m *MockAlphaRouters) Obj(o *computealpha.Router) *MockRoutersObj { - return &MockRoutersObj{o} -} - -// GetRouterStatus is a mock for the corresponding method. -func (m *MockAlphaRouters) GetRouterStatus(ctx context.Context, key *meta.Key, options ...Option) (*computealpha.RouterStatusResponse, error) { - if m.GetRouterStatusHook != nil { - return m.GetRouterStatusHook(ctx, key, m) - } - return nil, fmt.Errorf("GetRouterStatusHook must be set") +func (m *MockAlphaRegionNetworkEndpointGroups) Obj(o *computealpha.NetworkEndpointGroup) *MockRegionNetworkEndpointGroupsObj { + return &MockRegionNetworkEndpointGroupsObj{o} } -// Patch is a mock for the corresponding method. -func (m *MockAlphaRouters) Patch(ctx context.Context, key *meta.Key, arg0 *computealpha.Router, options ...Option) error { - if m.PatchHook != nil { - return m.PatchHook(ctx, key, arg0, m) +// AttachNetworkEndpoints is a mock for the corresponding method. +func (m *MockAlphaRegionNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key *meta.Key, arg0 *computealpha.RegionNetworkEndpointGroupsAttachEndpointsRequest, options ...Option) error { + if m.AttachNetworkEndpointsHook != nil { + return m.AttachNetworkEndpointsHook(ctx, key, arg0, m) } return nil } -// Preview is a mock for the corresponding method. -func (m *MockAlphaRouters) Preview(ctx context.Context, key *meta.Key, arg0 *computealpha.Router, options ...Option) (*computealpha.RoutersPreviewResponse, error) { - if m.PreviewHook != nil { - return m.PreviewHook(ctx, key, arg0, m) +// DetachNetworkEndpoints is a mock for the corresponding method. +func (m *MockAlphaRegionNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key *meta.Key, arg0 *computealpha.RegionNetworkEndpointGroupsDetachEndpointsRequest, options ...Option) error { + if m.DetachNetworkEndpointsHook != nil { + return m.DetachNetworkEndpointsHook(ctx, key, arg0, m) } - return nil, fmt.Errorf("PreviewHook must be set") + return nil } -// TestIamPermissions is a mock for the corresponding method. -func (m *MockAlphaRouters) TestIamPermissions(ctx context.Context, key *meta.Key, arg0 *computealpha.TestPermissionsRequest, options ...Option) (*computealpha.TestPermissionsResponse, error) { - if m.TestIamPermissionsHook != nil { - return m.TestIamPermissionsHook(ctx, key, arg0, m) +// ListNetworkEndpoints is a mock for the corresponding method. +func (m *MockAlphaRegionNetworkEndpointGroups) ListNetworkEndpoints(ctx context.Context, key *meta.Key, fl *filter.F, options ...Option) ([]*computealpha.NetworkEndpointWithHealthStatus, error) { + if m.ListNetworkEndpointsHook != nil { + return m.ListNetworkEndpointsHook(ctx, key, fl, m) } - return nil, fmt.Errorf("TestIamPermissionsHook must be set") + return nil, nil } -// GCEAlphaRouters is a simplifying adapter for the GCE Routers. -type GCEAlphaRouters struct { +// GCEAlphaRegionNetworkEndpointGroups is a simplifying adapter for the GCE RegionNetworkEndpointGroups. +type GCEAlphaRegionNetworkEndpointGroups struct { s *Service } -// Get the Router named by key. -func (g *GCEAlphaRouters) Get(ctx context.Context, key *meta.Key, options ...Option) (*computealpha.Router, error) { +// Get the NetworkEndpointGroup named by key. +func (g *GCEAlphaRegionNetworkEndpointGroups) Get(ctx context.Context, key *meta.Key, options ...Option) (*computealpha.NetworkEndpointGroup, error) { opts := mergeOptions(options) - klog.V(5).Infof("GCEAlphaRouters.Get(%v, %v, %v): called", ctx, key, opts) + klog.V(5).Infof("GCEAlphaRegionNetworkEndpointGroups.Get(%v, %v, %v): called", ctx, key, opts) if !key.Valid() { - klog.V(2).Infof("GCEAlphaRouters.Get(%v, %v): key is invalid (%#v)", ctx, key, key) + klog.V(2).Infof("GCEAlphaRegionNetworkEndpointGroups.Get(%v, %v): key is invalid (%#v)", ctx, key, key) return nil, fmt.Errorf("invalid GCE key (%#v)", key) } - projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "alpha", "Routers") + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "alpha", "RegionNetworkEndpointGroups") ck := &CallContextKey{ ProjectID: projectID, Operation: "Get", Version: meta.Version("alpha"), - Service: "Routers", + Service: "RegionNetworkEndpointGroups", } - klog.V(5).Infof("GCEAlphaRouters.Get(%v, %v): projectID = %v, ck = %+v", ctx, key, projectID, ck) + klog.V(5).Infof("GCEAlphaRegionNetworkEndpointGroups.Get(%v, %v): projectID = %v, ck = %+v", ctx, key, projectID, ck) callObserverStart(ctx, ck) if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { - klog.V(4).Infof("GCEAlphaRouters.Get(%v, %v): RateLimiter error: %v", ctx, key, err) + klog.V(4).Infof("GCEAlphaRegionNetworkEndpointGroups.Get(%v, %v): RateLimiter error: %v", ctx, key, err) return nil, err } - call := g.s.Alpha.Routers.Get(projectID, key.Region, key.Name) + call := g.s.Alpha.RegionNetworkEndpointGroups.Get(projectID, key.Region, key.Name) call.Context(ctx) v, err := call.Do() - klog.V(4).Infof("GCEAlphaRouters.Get(%v, %v) = %+v, %v", ctx, key, v, err) + klog.V(4).Infof("GCEAlphaRegionNetworkEndpointGroups.Get(%v, %v) = %+v, %v", ctx, key, v, err) callObserverEnd(ctx, ck, err) g.s.RateLimiter.Observe(ctx, err, ck) @@ -30105,32 +29895,32 @@ func (g *GCEAlphaRouters) Get(ctx context.Context, key *meta.Key, options ...Opt return v, err } -// List all Router objects. -func (g *GCEAlphaRouters) List(ctx context.Context, region string, fl *filter.F, options ...Option) ([]*computealpha.Router, error) { +// List all NetworkEndpointGroup objects. +func (g *GCEAlphaRegionNetworkEndpointGroups) List(ctx context.Context, region string, fl *filter.F, options ...Option) ([]*computealpha.NetworkEndpointGroup, error) { opts := mergeOptions(options) - klog.V(5).Infof("GCEAlphaRouters.List(%v, %v, %v, %v) called", ctx, region, fl, opts) - projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "alpha", "Routers") + klog.V(5).Infof("GCEAlphaRegionNetworkEndpointGroups.List(%v, %v, %v, %v) called", ctx, region, fl, opts) + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "alpha", "RegionNetworkEndpointGroups") ck := &CallContextKey{ ProjectID: projectID, Operation: "List", Version: meta.Version("alpha"), - Service: "Routers", + Service: "RegionNetworkEndpointGroups", } callObserverStart(ctx, ck) if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { return nil, err } - klog.V(5).Infof("GCEAlphaRouters.List(%v, %v, %v): projectID = %v, ck = %+v", ctx, region, fl, projectID, ck) - call := g.s.Alpha.Routers.List(projectID, region) + klog.V(5).Infof("GCEAlphaRegionNetworkEndpointGroups.List(%v, %v, %v): projectID = %v, ck = %+v", ctx, region, fl, projectID, ck) + call := g.s.Alpha.RegionNetworkEndpointGroups.List(projectID, region) if fl != filter.None { call.Filter(fl.String()) } - var all []*computealpha.Router - f := func(l *computealpha.RouterList) error { - klog.V(5).Infof("GCEAlphaRouters.List(%v, ..., %v): page %+v", ctx, fl, l) + var all []*computealpha.NetworkEndpointGroup + f := func(l *computealpha.NetworkEndpointGroupList) error { + klog.V(5).Infof("GCEAlphaRegionNetworkEndpointGroups.List(%v, ..., %v): page %+v", ctx, fl, l) all = append(all, l.Items...) return nil } @@ -30138,7 +29928,7 @@ func (g *GCEAlphaRouters) List(ctx context.Context, region string, fl *filter.F, callObserverEnd(ctx, ck, err) g.s.RateLimiter.Observe(ctx, err, ck) - klog.V(4).Infof("GCEAlphaRouters.List(%v, ..., %v) = %v, %v", ctx, fl, nil, err) + klog.V(4).Infof("GCEAlphaRegionNetworkEndpointGroups.List(%v, ..., %v) = %v, %v", ctx, fl, nil, err) return nil, err } @@ -30146,43 +29936,43 @@ func (g *GCEAlphaRouters) List(ctx context.Context, region string, fl *filter.F, g.s.RateLimiter.Observe(ctx, nil, ck) if kLogEnabled(4) { - klog.V(4).Infof("GCEAlphaRouters.List(%v, ..., %v) = [%v items], %v", ctx, fl, len(all), nil) + klog.V(4).Infof("GCEAlphaRegionNetworkEndpointGroups.List(%v, ..., %v) = [%v items], %v", ctx, fl, len(all), nil) } else if kLogEnabled(5) { var asStr []string for _, o := range all { asStr = append(asStr, fmt.Sprintf("%+v", o)) } - klog.V(5).Infof("GCEAlphaRouters.List(%v, ..., %v) = %v, %v", ctx, fl, asStr, nil) + klog.V(5).Infof("GCEAlphaRegionNetworkEndpointGroups.List(%v, ..., %v) = %v, %v", ctx, fl, asStr, nil) } return all, nil } -// Insert Router with key of value obj. -func (g *GCEAlphaRouters) Insert(ctx context.Context, key *meta.Key, obj *computealpha.Router, options ...Option) error { +// Insert NetworkEndpointGroup with key of value obj. +func (g *GCEAlphaRegionNetworkEndpointGroups) Insert(ctx context.Context, key *meta.Key, obj *computealpha.NetworkEndpointGroup, options ...Option) error { opts := mergeOptions(options) - klog.V(5).Infof("GCEAlphaRouters.Insert(%v, %v, %+v, %v): called", ctx, key, obj, opts) + klog.V(5).Infof("GCEAlphaRegionNetworkEndpointGroups.Insert(%v, %v, %+v, %v): called", ctx, key, obj, opts) if !key.Valid() { - klog.V(2).Infof("GCEAlphaRouters.Insert(%v, %v, ...): key is invalid (%#v)", ctx, key, key) + klog.V(2).Infof("GCEAlphaRegionNetworkEndpointGroups.Insert(%v, %v, ...): key is invalid (%#v)", ctx, key, key) return fmt.Errorf("invalid GCE key (%+v)", key) } - projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "alpha", "Routers") + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "alpha", "RegionNetworkEndpointGroups") ck := &CallContextKey{ ProjectID: projectID, Operation: "Insert", Version: meta.Version("alpha"), - Service: "Routers", + Service: "RegionNetworkEndpointGroups", } - klog.V(5).Infof("GCEAlphaRouters.Insert(%v, %v, ...): projectID = %v, ck = %+v", ctx, key, projectID, ck) + klog.V(5).Infof("GCEAlphaRegionNetworkEndpointGroups.Insert(%v, %v, ...): projectID = %v, ck = %+v", ctx, key, projectID, ck) callObserverStart(ctx, ck) if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { - klog.V(4).Infof("GCEAlphaRouters.Insert(%v, %v, ...): RateLimiter error: %v", ctx, key, err) + klog.V(4).Infof("GCEAlphaRegionNetworkEndpointGroups.Insert(%v, %v, ...): RateLimiter error: %v", ctx, key, err) return err } obj.Name = key.Name - call := g.s.Alpha.Routers.Insert(projectID, key.Region, obj) + call := g.s.Alpha.RegionNetworkEndpointGroups.Insert(projectID, key.Region, obj) call.Context(ctx) op, err := call.Do() @@ -30191,38 +29981,38 @@ func (g *GCEAlphaRouters) Insert(ctx context.Context, key *meta.Key, obj *comput g.s.RateLimiter.Observe(ctx, err, ck) if err != nil { - klog.V(4).Infof("GCEAlphaRouters.Insert(%v, %v, ...) = %+v", ctx, key, err) + klog.V(4).Infof("GCEAlphaRegionNetworkEndpointGroups.Insert(%v, %v, ...) = %+v", ctx, key, err) return err } err = g.s.WaitForCompletion(ctx, op) - klog.V(4).Infof("GCEAlphaRouters.Insert(%v, %v, %+v) = %+v", ctx, key, obj, err) + klog.V(4).Infof("GCEAlphaRegionNetworkEndpointGroups.Insert(%v, %v, %+v) = %+v", ctx, key, obj, err) return err } -// Delete the Router referenced by key. -func (g *GCEAlphaRouters) Delete(ctx context.Context, key *meta.Key, options ...Option) error { +// Delete the NetworkEndpointGroup referenced by key. +func (g *GCEAlphaRegionNetworkEndpointGroups) Delete(ctx context.Context, key *meta.Key, options ...Option) error { opts := mergeOptions(options) - klog.V(5).Infof("GCEAlphaRouters.Delete(%v, %v, %v): called", ctx, key, opts) + klog.V(5).Infof("GCEAlphaRegionNetworkEndpointGroups.Delete(%v, %v, %v): called", ctx, key, opts) if !key.Valid() { - klog.V(2).Infof("GCEAlphaRouters.Delete(%v, %v): key is invalid (%#v)", ctx, key, key) + klog.V(2).Infof("GCEAlphaRegionNetworkEndpointGroups.Delete(%v, %v): key is invalid (%#v)", ctx, key, key) return fmt.Errorf("invalid GCE key (%+v)", key) } - projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "alpha", "Routers") + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "alpha", "RegionNetworkEndpointGroups") ck := &CallContextKey{ ProjectID: projectID, Operation: "Delete", Version: meta.Version("alpha"), - Service: "Routers", + Service: "RegionNetworkEndpointGroups", } - klog.V(5).Infof("GCEAlphaRouters.Delete(%v, %v): projectID = %v, ck = %+v", ctx, key, projectID, ck) + klog.V(5).Infof("GCEAlphaRegionNetworkEndpointGroups.Delete(%v, %v): projectID = %v, ck = %+v", ctx, key, projectID, ck) callObserverStart(ctx, ck) if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { - klog.V(4).Infof("GCEAlphaRouters.Delete(%v, %v): RateLimiter error: %v", ctx, key, err) + klog.V(4).Infof("GCEAlphaRegionNetworkEndpointGroups.Delete(%v, %v): RateLimiter error: %v", ctx, key, err) return err } - call := g.s.Alpha.Routers.Delete(projectID, key.Region, key.Name) + call := g.s.Alpha.RegionNetworkEndpointGroups.Delete(projectID, key.Region, key.Name) call.Context(ctx) @@ -30232,35 +30022,1945 @@ func (g *GCEAlphaRouters) Delete(ctx context.Context, key *meta.Key, options ... g.s.RateLimiter.Observe(ctx, err, ck) if err != nil { - klog.V(4).Infof("GCEAlphaRouters.Delete(%v, %v) = %v", ctx, key, err) + klog.V(4).Infof("GCEAlphaRegionNetworkEndpointGroups.Delete(%v, %v) = %v", ctx, key, err) return err } err = g.s.WaitForCompletion(ctx, op) - klog.V(4).Infof("GCEAlphaRouters.Delete(%v, %v) = %v", ctx, key, err) + klog.V(4).Infof("GCEAlphaRegionNetworkEndpointGroups.Delete(%v, %v) = %v", ctx, key, err) return err } -// AggregatedList lists all resources of the given type across all locations. -func (g *GCEAlphaRouters) AggregatedList(ctx context.Context, fl *filter.F, options ...Option) (map[string][]*computealpha.Router, error) { +// AttachNetworkEndpoints is a method on GCEAlphaRegionNetworkEndpointGroups. +func (g *GCEAlphaRegionNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key *meta.Key, arg0 *computealpha.RegionNetworkEndpointGroupsAttachEndpointsRequest, options ...Option) error { opts := mergeOptions(options) - klog.V(5).Infof("GCEAlphaRouters.AggregatedList(%v, %v) called", ctx, fl) + klog.V(5).Infof("GCEAlphaRegionNetworkEndpointGroups.AttachNetworkEndpoints(%v, %v, %v, ...): called", ctx, key, opts) - projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "alpha", "Routers") + if !key.Valid() { + klog.V(2).Infof("GCEAlphaRegionNetworkEndpointGroups.AttachNetworkEndpoints(%v, %v, %v, ...): key is invalid (%#v)", ctx, key, opts, key) + return fmt.Errorf("invalid GCE key (%+v)", key) + } + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "alpha", "RegionNetworkEndpointGroups") ck := &CallContextKey{ ProjectID: projectID, - Operation: "AggregatedList", + Operation: "AttachNetworkEndpoints", Version: meta.Version("alpha"), - Service: "Routers", + Service: "RegionNetworkEndpointGroups", } - - klog.V(5).Infof("GCEAlphaRouters.AggregatedList(%v, %v): projectID = %v, ck = %+v", ctx, fl, projectID, ck) + klog.V(5).Infof("GCEAlphaRegionNetworkEndpointGroups.AttachNetworkEndpoints(%v, %v, ...): projectID = %v, ck = %+v", ctx, key, projectID, ck) callObserverStart(ctx, ck) if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { - klog.V(5).Infof("GCEAlphaRouters.AggregatedList(%v, %v): RateLimiter error: %v", ctx, fl, err) - return nil, err + klog.V(4).Infof("GCEAlphaRegionNetworkEndpointGroups.AttachNetworkEndpoints(%v, %v, ...): RateLimiter error: %v", ctx, key, err) + return err } - + call := g.s.Alpha.RegionNetworkEndpointGroups.AttachNetworkEndpoints(projectID, key.Region, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + + if err != nil { + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) + + klog.V(4).Infof("GCEAlphaRegionNetworkEndpointGroups.AttachNetworkEndpoints(%v, %v, ...) = %+v", ctx, key, err) + return err + } + + err = g.s.WaitForCompletion(ctx, op) + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) // XXX + + klog.V(4).Infof("GCEAlphaRegionNetworkEndpointGroups.AttachNetworkEndpoints(%v, %v, ...) = %+v", ctx, key, err) + return err +} + +// DetachNetworkEndpoints is a method on GCEAlphaRegionNetworkEndpointGroups. +func (g *GCEAlphaRegionNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key *meta.Key, arg0 *computealpha.RegionNetworkEndpointGroupsDetachEndpointsRequest, options ...Option) error { + opts := mergeOptions(options) + klog.V(5).Infof("GCEAlphaRegionNetworkEndpointGroups.DetachNetworkEndpoints(%v, %v, %v, ...): called", ctx, key, opts) + + if !key.Valid() { + klog.V(2).Infof("GCEAlphaRegionNetworkEndpointGroups.DetachNetworkEndpoints(%v, %v, %v, ...): key is invalid (%#v)", ctx, key, opts, key) + return fmt.Errorf("invalid GCE key (%+v)", key) + } + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "alpha", "RegionNetworkEndpointGroups") + ck := &CallContextKey{ + ProjectID: projectID, + Operation: "DetachNetworkEndpoints", + Version: meta.Version("alpha"), + Service: "RegionNetworkEndpointGroups", + } + klog.V(5).Infof("GCEAlphaRegionNetworkEndpointGroups.DetachNetworkEndpoints(%v, %v, ...): projectID = %v, ck = %+v", ctx, key, projectID, ck) + callObserverStart(ctx, ck) + if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { + klog.V(4).Infof("GCEAlphaRegionNetworkEndpointGroups.DetachNetworkEndpoints(%v, %v, ...): RateLimiter error: %v", ctx, key, err) + return err + } + call := g.s.Alpha.RegionNetworkEndpointGroups.DetachNetworkEndpoints(projectID, key.Region, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + + if err != nil { + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) + + klog.V(4).Infof("GCEAlphaRegionNetworkEndpointGroups.DetachNetworkEndpoints(%v, %v, ...) = %+v", ctx, key, err) + return err + } + + err = g.s.WaitForCompletion(ctx, op) + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) // XXX + + klog.V(4).Infof("GCEAlphaRegionNetworkEndpointGroups.DetachNetworkEndpoints(%v, %v, ...) = %+v", ctx, key, err) + return err +} + +// ListNetworkEndpoints is a method on GCEAlphaRegionNetworkEndpointGroups. +func (g *GCEAlphaRegionNetworkEndpointGroups) ListNetworkEndpoints(ctx context.Context, key *meta.Key, fl *filter.F, options ...Option) ([]*computealpha.NetworkEndpointWithHealthStatus, error) { + opts := mergeOptions(options) + klog.V(5).Infof("GCEAlphaRegionNetworkEndpointGroups.ListNetworkEndpoints(%v, %v, %v, ...): called", ctx, key, opts) + + if !key.Valid() { + klog.V(2).Infof("GCEAlphaRegionNetworkEndpointGroups.ListNetworkEndpoints(%v, %v, %v, ...): key is invalid (%#v)", ctx, key, opts, key) + return nil, fmt.Errorf("invalid GCE key (%+v)", key) + } + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "alpha", "RegionNetworkEndpointGroups") + ck := &CallContextKey{ + ProjectID: projectID, + Operation: "ListNetworkEndpoints", + Version: meta.Version("alpha"), + Service: "RegionNetworkEndpointGroups", + } + klog.V(5).Infof("GCEAlphaRegionNetworkEndpointGroups.ListNetworkEndpoints(%v, %v, ...): projectID = %v, ck = %+v", ctx, key, projectID, ck) + callObserverStart(ctx, ck) + if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { + klog.V(4).Infof("GCEAlphaRegionNetworkEndpointGroups.ListNetworkEndpoints(%v, %v, ...): RateLimiter error: %v", ctx, key, err) + return nil, err + } + call := g.s.Alpha.RegionNetworkEndpointGroups.ListNetworkEndpoints(projectID, key.Region, key.Name) + var all []*computealpha.NetworkEndpointWithHealthStatus + f := func(l *computealpha.NetworkEndpointGroupsListNetworkEndpoints) error { + klog.V(5).Infof("GCEAlphaRegionNetworkEndpointGroups.ListNetworkEndpoints(%v, %v, ...): page %+v", ctx, key, l) + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) + + klog.V(4).Infof("GCEAlphaRegionNetworkEndpointGroups.ListNetworkEndpoints(%v, %v, ...) = %v, %v", ctx, key, nil, err) + return nil, err + } + + callObserverEnd(ctx, ck, nil) + g.s.RateLimiter.Observe(ctx, nil, ck) + + if kLogEnabled(4) { + klog.V(4).Infof("GCEAlphaRegionNetworkEndpointGroups.ListNetworkEndpoints(%v, %v, ...) = [%v items], %v", ctx, key, len(all), nil) + } else if kLogEnabled(5) { + var asStr []string + for _, o := range all { + asStr = append(asStr, fmt.Sprintf("%+v", o)) + } + klog.V(5).Infof("GCEAlphaRegionNetworkEndpointGroups.ListNetworkEndpoints(%v, %v, ...) = %v, %v", ctx, key, asStr, nil) + } + return all, nil +} + +// BetaRegionNetworkEndpointGroups is an interface that allows for mocking of RegionNetworkEndpointGroups. +type BetaRegionNetworkEndpointGroups interface { + Get(ctx context.Context, key *meta.Key, options ...Option) (*computebeta.NetworkEndpointGroup, error) + List(ctx context.Context, region string, fl *filter.F, options ...Option) ([]*computebeta.NetworkEndpointGroup, error) + Insert(ctx context.Context, key *meta.Key, obj *computebeta.NetworkEndpointGroup, options ...Option) error + Delete(ctx context.Context, key *meta.Key, options ...Option) error + AttachNetworkEndpoints(context.Context, *meta.Key, *computebeta.RegionNetworkEndpointGroupsAttachEndpointsRequest, ...Option) error + DetachNetworkEndpoints(context.Context, *meta.Key, *computebeta.RegionNetworkEndpointGroupsDetachEndpointsRequest, ...Option) error + ListNetworkEndpoints(context.Context, *meta.Key, *filter.F, ...Option) ([]*computebeta.NetworkEndpointWithHealthStatus, error) +} + +// NewMockBetaRegionNetworkEndpointGroups returns a new mock for RegionNetworkEndpointGroups. +func NewMockBetaRegionNetworkEndpointGroups(pr ProjectRouter, objs map[meta.Key]*MockRegionNetworkEndpointGroupsObj) *MockBetaRegionNetworkEndpointGroups { + mock := &MockBetaRegionNetworkEndpointGroups{ + ProjectRouter: pr, + + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockBetaRegionNetworkEndpointGroups is the mock for RegionNetworkEndpointGroups. +type MockBetaRegionNetworkEndpointGroups struct { + Lock sync.Mutex + + ProjectRouter ProjectRouter + + // Objects maintained by the mock. + Objects map[meta.Key]*MockRegionNetworkEndpointGroupsObj + + // 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 *MockBetaRegionNetworkEndpointGroups, options ...Option) (bool, *computebeta.NetworkEndpointGroup, error) + ListHook func(ctx context.Context, region string, fl *filter.F, m *MockBetaRegionNetworkEndpointGroups, options ...Option) (bool, []*computebeta.NetworkEndpointGroup, error) + InsertHook func(ctx context.Context, key *meta.Key, obj *computebeta.NetworkEndpointGroup, m *MockBetaRegionNetworkEndpointGroups, options ...Option) (bool, error) + DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaRegionNetworkEndpointGroups, options ...Option) (bool, error) + AttachNetworkEndpointsHook func(context.Context, *meta.Key, *computebeta.RegionNetworkEndpointGroupsAttachEndpointsRequest, *MockBetaRegionNetworkEndpointGroups, ...Option) error + DetachNetworkEndpointsHook func(context.Context, *meta.Key, *computebeta.RegionNetworkEndpointGroupsDetachEndpointsRequest, *MockBetaRegionNetworkEndpointGroups, ...Option) error + ListNetworkEndpointsHook func(context.Context, *meta.Key, *filter.F, *MockBetaRegionNetworkEndpointGroups, ...Option) ([]*computebeta.NetworkEndpointWithHealthStatus, 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 *MockBetaRegionNetworkEndpointGroups) Get(ctx context.Context, key *meta.Key, options ...Option) (*computebeta.NetworkEndpointGroup, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(ctx, key, m, options...); intercept { + klog.V(5).Infof("MockBetaRegionNetworkEndpointGroups.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("MockBetaRegionNetworkEndpointGroups.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("MockBetaRegionNetworkEndpointGroups.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockBetaRegionNetworkEndpointGroups %v not found", key), + } + klog.V(5).Infof("MockBetaRegionNetworkEndpointGroups.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 *MockBetaRegionNetworkEndpointGroups) List(ctx context.Context, region string, fl *filter.F, options ...Option) ([]*computebeta.NetworkEndpointGroup, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(ctx, region, fl, m, options...); intercept { + klog.V(5).Infof("MockBetaRegionNetworkEndpointGroups.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("MockBetaRegionNetworkEndpointGroups.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + + return nil, *m.ListError + } + + var objs []*computebeta.NetworkEndpointGroup + 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("MockBetaRegionNetworkEndpointGroups.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 *MockBetaRegionNetworkEndpointGroups) Insert(ctx context.Context, key *meta.Key, obj *computebeta.NetworkEndpointGroup, options ...Option) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(ctx, key, obj, m, options...); intercept { + klog.V(5).Infof("MockBetaRegionNetworkEndpointGroups.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + opts := mergeOptions(options) + 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("MockBetaRegionNetworkEndpointGroups.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("MockBetaRegionNetworkEndpointGroups %v exists", key), + } + klog.V(5).Infof("MockBetaRegionNetworkEndpointGroups.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + projectID := getProjectID(ctx, m.ProjectRouter, opts, "beta", "networkEndpointGroups") + obj.SelfLink = SelfLinkWithGroup("compute", meta.VersionBeta, projectID, "networkEndpointGroups", key) + + m.Objects[*key] = &MockRegionNetworkEndpointGroupsObj{obj} + klog.V(5).Infof("MockBetaRegionNetworkEndpointGroups.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockBetaRegionNetworkEndpointGroups) Delete(ctx context.Context, key *meta.Key, options ...Option) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(ctx, key, m, options...); intercept { + klog.V(5).Infof("MockBetaRegionNetworkEndpointGroups.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("MockBetaRegionNetworkEndpointGroups.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[*key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockBetaRegionNetworkEndpointGroups %v not found", key), + } + klog.V(5).Infof("MockBetaRegionNetworkEndpointGroups.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, *key) + klog.V(5).Infof("MockBetaRegionNetworkEndpointGroups.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockBetaRegionNetworkEndpointGroups) Obj(o *computebeta.NetworkEndpointGroup) *MockRegionNetworkEndpointGroupsObj { + return &MockRegionNetworkEndpointGroupsObj{o} +} + +// AttachNetworkEndpoints is a mock for the corresponding method. +func (m *MockBetaRegionNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key *meta.Key, arg0 *computebeta.RegionNetworkEndpointGroupsAttachEndpointsRequest, options ...Option) error { + if m.AttachNetworkEndpointsHook != nil { + return m.AttachNetworkEndpointsHook(ctx, key, arg0, m) + } + return nil +} + +// DetachNetworkEndpoints is a mock for the corresponding method. +func (m *MockBetaRegionNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key *meta.Key, arg0 *computebeta.RegionNetworkEndpointGroupsDetachEndpointsRequest, options ...Option) error { + if m.DetachNetworkEndpointsHook != nil { + return m.DetachNetworkEndpointsHook(ctx, key, arg0, m) + } + return nil +} + +// ListNetworkEndpoints is a mock for the corresponding method. +func (m *MockBetaRegionNetworkEndpointGroups) ListNetworkEndpoints(ctx context.Context, key *meta.Key, fl *filter.F, options ...Option) ([]*computebeta.NetworkEndpointWithHealthStatus, error) { + if m.ListNetworkEndpointsHook != nil { + return m.ListNetworkEndpointsHook(ctx, key, fl, m) + } + return nil, nil +} + +// GCEBetaRegionNetworkEndpointGroups is a simplifying adapter for the GCE RegionNetworkEndpointGroups. +type GCEBetaRegionNetworkEndpointGroups struct { + s *Service +} + +// Get the NetworkEndpointGroup named by key. +func (g *GCEBetaRegionNetworkEndpointGroups) Get(ctx context.Context, key *meta.Key, options ...Option) (*computebeta.NetworkEndpointGroup, error) { + opts := mergeOptions(options) + klog.V(5).Infof("GCEBetaRegionNetworkEndpointGroups.Get(%v, %v, %v): called", ctx, key, opts) + + if !key.Valid() { + klog.V(2).Infof("GCEBetaRegionNetworkEndpointGroups.Get(%v, %v): key is invalid (%#v)", ctx, key, key) + return nil, fmt.Errorf("invalid GCE key (%#v)", key) + } + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "beta", "RegionNetworkEndpointGroups") + + ck := &CallContextKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("beta"), + Service: "RegionNetworkEndpointGroups", + } + + klog.V(5).Infof("GCEBetaRegionNetworkEndpointGroups.Get(%v, %v): projectID = %v, ck = %+v", ctx, key, projectID, ck) + callObserverStart(ctx, ck) + if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { + klog.V(4).Infof("GCEBetaRegionNetworkEndpointGroups.Get(%v, %v): RateLimiter error: %v", ctx, key, err) + return nil, err + } + call := g.s.Beta.RegionNetworkEndpointGroups.Get(projectID, key.Region, key.Name) + call.Context(ctx) + v, err := call.Do() + klog.V(4).Infof("GCEBetaRegionNetworkEndpointGroups.Get(%v, %v) = %+v, %v", ctx, key, v, err) + + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) + + return v, err +} + +// List all NetworkEndpointGroup objects. +func (g *GCEBetaRegionNetworkEndpointGroups) List(ctx context.Context, region string, fl *filter.F, options ...Option) ([]*computebeta.NetworkEndpointGroup, error) { + opts := mergeOptions(options) + klog.V(5).Infof("GCEBetaRegionNetworkEndpointGroups.List(%v, %v, %v, %v) called", ctx, region, fl, opts) + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "beta", "RegionNetworkEndpointGroups") + + ck := &CallContextKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("beta"), + Service: "RegionNetworkEndpointGroups", + } + + callObserverStart(ctx, ck) + if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { + return nil, err + } + klog.V(5).Infof("GCEBetaRegionNetworkEndpointGroups.List(%v, %v, %v): projectID = %v, ck = %+v", ctx, region, fl, projectID, ck) + call := g.s.Beta.RegionNetworkEndpointGroups.List(projectID, region) + if fl != filter.None { + call.Filter(fl.String()) + } + + var all []*computebeta.NetworkEndpointGroup + f := func(l *computebeta.NetworkEndpointGroupList) error { + klog.V(5).Infof("GCEBetaRegionNetworkEndpointGroups.List(%v, ..., %v): page %+v", ctx, fl, l) + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) + + klog.V(4).Infof("GCEBetaRegionNetworkEndpointGroups.List(%v, ..., %v) = %v, %v", ctx, fl, nil, err) + return nil, err + } + + callObserverEnd(ctx, ck, nil) + g.s.RateLimiter.Observe(ctx, nil, ck) + + if kLogEnabled(4) { + klog.V(4).Infof("GCEBetaRegionNetworkEndpointGroups.List(%v, ..., %v) = [%v items], %v", ctx, fl, len(all), nil) + } else if kLogEnabled(5) { + var asStr []string + for _, o := range all { + asStr = append(asStr, fmt.Sprintf("%+v", o)) + } + klog.V(5).Infof("GCEBetaRegionNetworkEndpointGroups.List(%v, ..., %v) = %v, %v", ctx, fl, asStr, nil) + } + + return all, nil +} + +// Insert NetworkEndpointGroup with key of value obj. +func (g *GCEBetaRegionNetworkEndpointGroups) Insert(ctx context.Context, key *meta.Key, obj *computebeta.NetworkEndpointGroup, options ...Option) error { + opts := mergeOptions(options) + klog.V(5).Infof("GCEBetaRegionNetworkEndpointGroups.Insert(%v, %v, %+v, %v): called", ctx, key, obj, opts) + if !key.Valid() { + klog.V(2).Infof("GCEBetaRegionNetworkEndpointGroups.Insert(%v, %v, ...): key is invalid (%#v)", ctx, key, key) + return fmt.Errorf("invalid GCE key (%+v)", key) + } + + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "beta", "RegionNetworkEndpointGroups") + + ck := &CallContextKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("beta"), + Service: "RegionNetworkEndpointGroups", + } + klog.V(5).Infof("GCEBetaRegionNetworkEndpointGroups.Insert(%v, %v, ...): projectID = %v, ck = %+v", ctx, key, projectID, ck) + callObserverStart(ctx, ck) + if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { + klog.V(4).Infof("GCEBetaRegionNetworkEndpointGroups.Insert(%v, %v, ...): RateLimiter error: %v", ctx, key, err) + return err + } + obj.Name = key.Name + call := g.s.Beta.RegionNetworkEndpointGroups.Insert(projectID, key.Region, obj) + call.Context(ctx) + + op, err := call.Do() + + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) + + if err != nil { + klog.V(4).Infof("GCEBetaRegionNetworkEndpointGroups.Insert(%v, %v, ...) = %+v", ctx, key, err) + return err + } + + err = g.s.WaitForCompletion(ctx, op) + klog.V(4).Infof("GCEBetaRegionNetworkEndpointGroups.Insert(%v, %v, %+v) = %+v", ctx, key, obj, err) + return err +} + +// Delete the NetworkEndpointGroup referenced by key. +func (g *GCEBetaRegionNetworkEndpointGroups) Delete(ctx context.Context, key *meta.Key, options ...Option) error { + opts := mergeOptions(options) + klog.V(5).Infof("GCEBetaRegionNetworkEndpointGroups.Delete(%v, %v, %v): called", ctx, key, opts) + if !key.Valid() { + klog.V(2).Infof("GCEBetaRegionNetworkEndpointGroups.Delete(%v, %v): key is invalid (%#v)", ctx, key, key) + return fmt.Errorf("invalid GCE key (%+v)", key) + } + + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "beta", "RegionNetworkEndpointGroups") + ck := &CallContextKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("beta"), + Service: "RegionNetworkEndpointGroups", + } + klog.V(5).Infof("GCEBetaRegionNetworkEndpointGroups.Delete(%v, %v): projectID = %v, ck = %+v", ctx, key, projectID, ck) + callObserverStart(ctx, ck) + if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { + klog.V(4).Infof("GCEBetaRegionNetworkEndpointGroups.Delete(%v, %v): RateLimiter error: %v", ctx, key, err) + return err + } + call := g.s.Beta.RegionNetworkEndpointGroups.Delete(projectID, key.Region, key.Name) + + call.Context(ctx) + + op, err := call.Do() + + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) + + if err != nil { + klog.V(4).Infof("GCEBetaRegionNetworkEndpointGroups.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + err = g.s.WaitForCompletion(ctx, op) + klog.V(4).Infof("GCEBetaRegionNetworkEndpointGroups.Delete(%v, %v) = %v", ctx, key, err) + return err +} + +// AttachNetworkEndpoints is a method on GCEBetaRegionNetworkEndpointGroups. +func (g *GCEBetaRegionNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key *meta.Key, arg0 *computebeta.RegionNetworkEndpointGroupsAttachEndpointsRequest, options ...Option) error { + opts := mergeOptions(options) + klog.V(5).Infof("GCEBetaRegionNetworkEndpointGroups.AttachNetworkEndpoints(%v, %v, %v, ...): called", ctx, key, opts) + + if !key.Valid() { + klog.V(2).Infof("GCEBetaRegionNetworkEndpointGroups.AttachNetworkEndpoints(%v, %v, %v, ...): key is invalid (%#v)", ctx, key, opts, key) + return fmt.Errorf("invalid GCE key (%+v)", key) + } + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "beta", "RegionNetworkEndpointGroups") + ck := &CallContextKey{ + ProjectID: projectID, + Operation: "AttachNetworkEndpoints", + Version: meta.Version("beta"), + Service: "RegionNetworkEndpointGroups", + } + klog.V(5).Infof("GCEBetaRegionNetworkEndpointGroups.AttachNetworkEndpoints(%v, %v, ...): projectID = %v, ck = %+v", ctx, key, projectID, ck) + callObserverStart(ctx, ck) + if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { + klog.V(4).Infof("GCEBetaRegionNetworkEndpointGroups.AttachNetworkEndpoints(%v, %v, ...): RateLimiter error: %v", ctx, key, err) + return err + } + call := g.s.Beta.RegionNetworkEndpointGroups.AttachNetworkEndpoints(projectID, key.Region, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + + if err != nil { + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) + + klog.V(4).Infof("GCEBetaRegionNetworkEndpointGroups.AttachNetworkEndpoints(%v, %v, ...) = %+v", ctx, key, err) + return err + } + + err = g.s.WaitForCompletion(ctx, op) + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) // XXX + + klog.V(4).Infof("GCEBetaRegionNetworkEndpointGroups.AttachNetworkEndpoints(%v, %v, ...) = %+v", ctx, key, err) + return err +} + +// DetachNetworkEndpoints is a method on GCEBetaRegionNetworkEndpointGroups. +func (g *GCEBetaRegionNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key *meta.Key, arg0 *computebeta.RegionNetworkEndpointGroupsDetachEndpointsRequest, options ...Option) error { + opts := mergeOptions(options) + klog.V(5).Infof("GCEBetaRegionNetworkEndpointGroups.DetachNetworkEndpoints(%v, %v, %v, ...): called", ctx, key, opts) + + if !key.Valid() { + klog.V(2).Infof("GCEBetaRegionNetworkEndpointGroups.DetachNetworkEndpoints(%v, %v, %v, ...): key is invalid (%#v)", ctx, key, opts, key) + return fmt.Errorf("invalid GCE key (%+v)", key) + } + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "beta", "RegionNetworkEndpointGroups") + ck := &CallContextKey{ + ProjectID: projectID, + Operation: "DetachNetworkEndpoints", + Version: meta.Version("beta"), + Service: "RegionNetworkEndpointGroups", + } + klog.V(5).Infof("GCEBetaRegionNetworkEndpointGroups.DetachNetworkEndpoints(%v, %v, ...): projectID = %v, ck = %+v", ctx, key, projectID, ck) + callObserverStart(ctx, ck) + if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { + klog.V(4).Infof("GCEBetaRegionNetworkEndpointGroups.DetachNetworkEndpoints(%v, %v, ...): RateLimiter error: %v", ctx, key, err) + return err + } + call := g.s.Beta.RegionNetworkEndpointGroups.DetachNetworkEndpoints(projectID, key.Region, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + + if err != nil { + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) + + klog.V(4).Infof("GCEBetaRegionNetworkEndpointGroups.DetachNetworkEndpoints(%v, %v, ...) = %+v", ctx, key, err) + return err + } + + err = g.s.WaitForCompletion(ctx, op) + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) // XXX + + klog.V(4).Infof("GCEBetaRegionNetworkEndpointGroups.DetachNetworkEndpoints(%v, %v, ...) = %+v", ctx, key, err) + return err +} + +// ListNetworkEndpoints is a method on GCEBetaRegionNetworkEndpointGroups. +func (g *GCEBetaRegionNetworkEndpointGroups) ListNetworkEndpoints(ctx context.Context, key *meta.Key, fl *filter.F, options ...Option) ([]*computebeta.NetworkEndpointWithHealthStatus, error) { + opts := mergeOptions(options) + klog.V(5).Infof("GCEBetaRegionNetworkEndpointGroups.ListNetworkEndpoints(%v, %v, %v, ...): called", ctx, key, opts) + + if !key.Valid() { + klog.V(2).Infof("GCEBetaRegionNetworkEndpointGroups.ListNetworkEndpoints(%v, %v, %v, ...): key is invalid (%#v)", ctx, key, opts, key) + return nil, fmt.Errorf("invalid GCE key (%+v)", key) + } + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "beta", "RegionNetworkEndpointGroups") + ck := &CallContextKey{ + ProjectID: projectID, + Operation: "ListNetworkEndpoints", + Version: meta.Version("beta"), + Service: "RegionNetworkEndpointGroups", + } + klog.V(5).Infof("GCEBetaRegionNetworkEndpointGroups.ListNetworkEndpoints(%v, %v, ...): projectID = %v, ck = %+v", ctx, key, projectID, ck) + callObserverStart(ctx, ck) + if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { + klog.V(4).Infof("GCEBetaRegionNetworkEndpointGroups.ListNetworkEndpoints(%v, %v, ...): RateLimiter error: %v", ctx, key, err) + return nil, err + } + call := g.s.Beta.RegionNetworkEndpointGroups.ListNetworkEndpoints(projectID, key.Region, key.Name) + var all []*computebeta.NetworkEndpointWithHealthStatus + f := func(l *computebeta.NetworkEndpointGroupsListNetworkEndpoints) error { + klog.V(5).Infof("GCEBetaRegionNetworkEndpointGroups.ListNetworkEndpoints(%v, %v, ...): page %+v", ctx, key, l) + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) + + klog.V(4).Infof("GCEBetaRegionNetworkEndpointGroups.ListNetworkEndpoints(%v, %v, ...) = %v, %v", ctx, key, nil, err) + return nil, err + } + + callObserverEnd(ctx, ck, nil) + g.s.RateLimiter.Observe(ctx, nil, ck) + + if kLogEnabled(4) { + klog.V(4).Infof("GCEBetaRegionNetworkEndpointGroups.ListNetworkEndpoints(%v, %v, ...) = [%v items], %v", ctx, key, len(all), nil) + } else if kLogEnabled(5) { + var asStr []string + for _, o := range all { + asStr = append(asStr, fmt.Sprintf("%+v", o)) + } + klog.V(5).Infof("GCEBetaRegionNetworkEndpointGroups.ListNetworkEndpoints(%v, %v, ...) = %v, %v", ctx, key, asStr, nil) + } + return all, nil +} + +// RegionNetworkEndpointGroups is an interface that allows for mocking of RegionNetworkEndpointGroups. +type RegionNetworkEndpointGroups interface { + Get(ctx context.Context, key *meta.Key, options ...Option) (*computega.NetworkEndpointGroup, error) + List(ctx context.Context, region string, fl *filter.F, options ...Option) ([]*computega.NetworkEndpointGroup, error) + Insert(ctx context.Context, key *meta.Key, obj *computega.NetworkEndpointGroup, options ...Option) error + Delete(ctx context.Context, key *meta.Key, options ...Option) error + AttachNetworkEndpoints(context.Context, *meta.Key, *computega.RegionNetworkEndpointGroupsAttachEndpointsRequest, ...Option) error + DetachNetworkEndpoints(context.Context, *meta.Key, *computega.RegionNetworkEndpointGroupsDetachEndpointsRequest, ...Option) error + ListNetworkEndpoints(context.Context, *meta.Key, *filter.F, ...Option) ([]*computega.NetworkEndpointWithHealthStatus, error) +} + +// NewMockRegionNetworkEndpointGroups returns a new mock for RegionNetworkEndpointGroups. +func NewMockRegionNetworkEndpointGroups(pr ProjectRouter, objs map[meta.Key]*MockRegionNetworkEndpointGroupsObj) *MockRegionNetworkEndpointGroups { + mock := &MockRegionNetworkEndpointGroups{ + ProjectRouter: pr, + + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockRegionNetworkEndpointGroups is the mock for RegionNetworkEndpointGroups. +type MockRegionNetworkEndpointGroups struct { + Lock sync.Mutex + + ProjectRouter ProjectRouter + + // Objects maintained by the mock. + Objects map[meta.Key]*MockRegionNetworkEndpointGroupsObj + + // 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 *MockRegionNetworkEndpointGroups, options ...Option) (bool, *computega.NetworkEndpointGroup, error) + ListHook func(ctx context.Context, region string, fl *filter.F, m *MockRegionNetworkEndpointGroups, options ...Option) (bool, []*computega.NetworkEndpointGroup, error) + InsertHook func(ctx context.Context, key *meta.Key, obj *computega.NetworkEndpointGroup, m *MockRegionNetworkEndpointGroups, options ...Option) (bool, error) + DeleteHook func(ctx context.Context, key *meta.Key, m *MockRegionNetworkEndpointGroups, options ...Option) (bool, error) + AttachNetworkEndpointsHook func(context.Context, *meta.Key, *computega.RegionNetworkEndpointGroupsAttachEndpointsRequest, *MockRegionNetworkEndpointGroups, ...Option) error + DetachNetworkEndpointsHook func(context.Context, *meta.Key, *computega.RegionNetworkEndpointGroupsDetachEndpointsRequest, *MockRegionNetworkEndpointGroups, ...Option) error + ListNetworkEndpointsHook func(context.Context, *meta.Key, *filter.F, *MockRegionNetworkEndpointGroups, ...Option) ([]*computega.NetworkEndpointWithHealthStatus, 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 *MockRegionNetworkEndpointGroups) Get(ctx context.Context, key *meta.Key, options ...Option) (*computega.NetworkEndpointGroup, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(ctx, key, m, options...); intercept { + klog.V(5).Infof("MockRegionNetworkEndpointGroups.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("MockRegionNetworkEndpointGroups.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[*key]; ok { + typedObj := obj.ToGA() + klog.V(5).Infof("MockRegionNetworkEndpointGroups.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockRegionNetworkEndpointGroups %v not found", key), + } + klog.V(5).Infof("MockRegionNetworkEndpointGroups.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 *MockRegionNetworkEndpointGroups) List(ctx context.Context, region string, fl *filter.F, options ...Option) ([]*computega.NetworkEndpointGroup, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(ctx, region, fl, m, options...); intercept { + klog.V(5).Infof("MockRegionNetworkEndpointGroups.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("MockRegionNetworkEndpointGroups.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + + return nil, *m.ListError + } + + var objs []*computega.NetworkEndpointGroup + for key, obj := range m.Objects { + if key.Region != region { + continue + } + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + klog.V(5).Infof("MockRegionNetworkEndpointGroups.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 *MockRegionNetworkEndpointGroups) Insert(ctx context.Context, key *meta.Key, obj *computega.NetworkEndpointGroup, options ...Option) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(ctx, key, obj, m, options...); intercept { + klog.V(5).Infof("MockRegionNetworkEndpointGroups.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + opts := mergeOptions(options) + 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("MockRegionNetworkEndpointGroups.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("MockRegionNetworkEndpointGroups %v exists", key), + } + klog.V(5).Infof("MockRegionNetworkEndpointGroups.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + projectID := getProjectID(ctx, m.ProjectRouter, opts, "ga", "networkEndpointGroups") + obj.SelfLink = SelfLinkWithGroup("compute", meta.VersionGA, projectID, "networkEndpointGroups", key) + + m.Objects[*key] = &MockRegionNetworkEndpointGroupsObj{obj} + klog.V(5).Infof("MockRegionNetworkEndpointGroups.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockRegionNetworkEndpointGroups) Delete(ctx context.Context, key *meta.Key, options ...Option) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(ctx, key, m, options...); intercept { + klog.V(5).Infof("MockRegionNetworkEndpointGroups.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("MockRegionNetworkEndpointGroups.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[*key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockRegionNetworkEndpointGroups %v not found", key), + } + klog.V(5).Infof("MockRegionNetworkEndpointGroups.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, *key) + klog.V(5).Infof("MockRegionNetworkEndpointGroups.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockRegionNetworkEndpointGroups) Obj(o *computega.NetworkEndpointGroup) *MockRegionNetworkEndpointGroupsObj { + return &MockRegionNetworkEndpointGroupsObj{o} +} + +// AttachNetworkEndpoints is a mock for the corresponding method. +func (m *MockRegionNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key *meta.Key, arg0 *computega.RegionNetworkEndpointGroupsAttachEndpointsRequest, options ...Option) error { + if m.AttachNetworkEndpointsHook != nil { + return m.AttachNetworkEndpointsHook(ctx, key, arg0, m) + } + return nil +} + +// DetachNetworkEndpoints is a mock for the corresponding method. +func (m *MockRegionNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key *meta.Key, arg0 *computega.RegionNetworkEndpointGroupsDetachEndpointsRequest, options ...Option) error { + if m.DetachNetworkEndpointsHook != nil { + return m.DetachNetworkEndpointsHook(ctx, key, arg0, m) + } + return nil +} + +// ListNetworkEndpoints is a mock for the corresponding method. +func (m *MockRegionNetworkEndpointGroups) ListNetworkEndpoints(ctx context.Context, key *meta.Key, fl *filter.F, options ...Option) ([]*computega.NetworkEndpointWithHealthStatus, error) { + if m.ListNetworkEndpointsHook != nil { + return m.ListNetworkEndpointsHook(ctx, key, fl, m) + } + return nil, nil +} + +// GCERegionNetworkEndpointGroups is a simplifying adapter for the GCE RegionNetworkEndpointGroups. +type GCERegionNetworkEndpointGroups struct { + s *Service +} + +// Get the NetworkEndpointGroup named by key. +func (g *GCERegionNetworkEndpointGroups) Get(ctx context.Context, key *meta.Key, options ...Option) (*computega.NetworkEndpointGroup, error) { + opts := mergeOptions(options) + klog.V(5).Infof("GCERegionNetworkEndpointGroups.Get(%v, %v, %v): called", ctx, key, opts) + + if !key.Valid() { + klog.V(2).Infof("GCERegionNetworkEndpointGroups.Get(%v, %v): key is invalid (%#v)", ctx, key, key) + return nil, fmt.Errorf("invalid GCE key (%#v)", key) + } + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "ga", "RegionNetworkEndpointGroups") + + ck := &CallContextKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "RegionNetworkEndpointGroups", + } + + klog.V(5).Infof("GCERegionNetworkEndpointGroups.Get(%v, %v): projectID = %v, ck = %+v", ctx, key, projectID, ck) + callObserverStart(ctx, ck) + if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { + klog.V(4).Infof("GCERegionNetworkEndpointGroups.Get(%v, %v): RateLimiter error: %v", ctx, key, err) + return nil, err + } + call := g.s.GA.RegionNetworkEndpointGroups.Get(projectID, key.Region, key.Name) + call.Context(ctx) + v, err := call.Do() + klog.V(4).Infof("GCERegionNetworkEndpointGroups.Get(%v, %v) = %+v, %v", ctx, key, v, err) + + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) + + return v, err +} + +// List all NetworkEndpointGroup objects. +func (g *GCERegionNetworkEndpointGroups) List(ctx context.Context, region string, fl *filter.F, options ...Option) ([]*computega.NetworkEndpointGroup, error) { + opts := mergeOptions(options) + klog.V(5).Infof("GCERegionNetworkEndpointGroups.List(%v, %v, %v, %v) called", ctx, region, fl, opts) + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "ga", "RegionNetworkEndpointGroups") + + ck := &CallContextKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "RegionNetworkEndpointGroups", + } + + callObserverStart(ctx, ck) + if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { + return nil, err + } + klog.V(5).Infof("GCERegionNetworkEndpointGroups.List(%v, %v, %v): projectID = %v, ck = %+v", ctx, region, fl, projectID, ck) + call := g.s.GA.RegionNetworkEndpointGroups.List(projectID, region) + if fl != filter.None { + call.Filter(fl.String()) + } + + var all []*computega.NetworkEndpointGroup + f := func(l *computega.NetworkEndpointGroupList) error { + klog.V(5).Infof("GCERegionNetworkEndpointGroups.List(%v, ..., %v): page %+v", ctx, fl, l) + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) + + klog.V(4).Infof("GCERegionNetworkEndpointGroups.List(%v, ..., %v) = %v, %v", ctx, fl, nil, err) + return nil, err + } + + callObserverEnd(ctx, ck, nil) + g.s.RateLimiter.Observe(ctx, nil, ck) + + if kLogEnabled(4) { + klog.V(4).Infof("GCERegionNetworkEndpointGroups.List(%v, ..., %v) = [%v items], %v", ctx, fl, len(all), nil) + } else if kLogEnabled(5) { + var asStr []string + for _, o := range all { + asStr = append(asStr, fmt.Sprintf("%+v", o)) + } + klog.V(5).Infof("GCERegionNetworkEndpointGroups.List(%v, ..., %v) = %v, %v", ctx, fl, asStr, nil) + } + + return all, nil +} + +// Insert NetworkEndpointGroup with key of value obj. +func (g *GCERegionNetworkEndpointGroups) Insert(ctx context.Context, key *meta.Key, obj *computega.NetworkEndpointGroup, options ...Option) error { + opts := mergeOptions(options) + klog.V(5).Infof("GCERegionNetworkEndpointGroups.Insert(%v, %v, %+v, %v): called", ctx, key, obj, opts) + if !key.Valid() { + klog.V(2).Infof("GCERegionNetworkEndpointGroups.Insert(%v, %v, ...): key is invalid (%#v)", ctx, key, key) + return fmt.Errorf("invalid GCE key (%+v)", key) + } + + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "ga", "RegionNetworkEndpointGroups") + + ck := &CallContextKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "RegionNetworkEndpointGroups", + } + klog.V(5).Infof("GCERegionNetworkEndpointGroups.Insert(%v, %v, ...): projectID = %v, ck = %+v", ctx, key, projectID, ck) + callObserverStart(ctx, ck) + if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { + klog.V(4).Infof("GCERegionNetworkEndpointGroups.Insert(%v, %v, ...): RateLimiter error: %v", ctx, key, err) + return err + } + obj.Name = key.Name + call := g.s.GA.RegionNetworkEndpointGroups.Insert(projectID, key.Region, obj) + call.Context(ctx) + + op, err := call.Do() + + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) + + if err != nil { + klog.V(4).Infof("GCERegionNetworkEndpointGroups.Insert(%v, %v, ...) = %+v", ctx, key, err) + return err + } + + err = g.s.WaitForCompletion(ctx, op) + klog.V(4).Infof("GCERegionNetworkEndpointGroups.Insert(%v, %v, %+v) = %+v", ctx, key, obj, err) + return err +} + +// Delete the NetworkEndpointGroup referenced by key. +func (g *GCERegionNetworkEndpointGroups) Delete(ctx context.Context, key *meta.Key, options ...Option) error { + opts := mergeOptions(options) + klog.V(5).Infof("GCERegionNetworkEndpointGroups.Delete(%v, %v, %v): called", ctx, key, opts) + if !key.Valid() { + klog.V(2).Infof("GCERegionNetworkEndpointGroups.Delete(%v, %v): key is invalid (%#v)", ctx, key, key) + return fmt.Errorf("invalid GCE key (%+v)", key) + } + + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "ga", "RegionNetworkEndpointGroups") + ck := &CallContextKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "RegionNetworkEndpointGroups", + } + klog.V(5).Infof("GCERegionNetworkEndpointGroups.Delete(%v, %v): projectID = %v, ck = %+v", ctx, key, projectID, ck) + callObserverStart(ctx, ck) + if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { + klog.V(4).Infof("GCERegionNetworkEndpointGroups.Delete(%v, %v): RateLimiter error: %v", ctx, key, err) + return err + } + call := g.s.GA.RegionNetworkEndpointGroups.Delete(projectID, key.Region, key.Name) + + call.Context(ctx) + + op, err := call.Do() + + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) + + if err != nil { + klog.V(4).Infof("GCERegionNetworkEndpointGroups.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + err = g.s.WaitForCompletion(ctx, op) + klog.V(4).Infof("GCERegionNetworkEndpointGroups.Delete(%v, %v) = %v", ctx, key, err) + return err +} + +// AttachNetworkEndpoints is a method on GCERegionNetworkEndpointGroups. +func (g *GCERegionNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key *meta.Key, arg0 *computega.RegionNetworkEndpointGroupsAttachEndpointsRequest, options ...Option) error { + opts := mergeOptions(options) + klog.V(5).Infof("GCERegionNetworkEndpointGroups.AttachNetworkEndpoints(%v, %v, %v, ...): called", ctx, key, opts) + + if !key.Valid() { + klog.V(2).Infof("GCERegionNetworkEndpointGroups.AttachNetworkEndpoints(%v, %v, %v, ...): key is invalid (%#v)", ctx, key, opts, key) + return fmt.Errorf("invalid GCE key (%+v)", key) + } + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "ga", "RegionNetworkEndpointGroups") + ck := &CallContextKey{ + ProjectID: projectID, + Operation: "AttachNetworkEndpoints", + Version: meta.Version("ga"), + Service: "RegionNetworkEndpointGroups", + } + klog.V(5).Infof("GCERegionNetworkEndpointGroups.AttachNetworkEndpoints(%v, %v, ...): projectID = %v, ck = %+v", ctx, key, projectID, ck) + callObserverStart(ctx, ck) + if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { + klog.V(4).Infof("GCERegionNetworkEndpointGroups.AttachNetworkEndpoints(%v, %v, ...): RateLimiter error: %v", ctx, key, err) + return err + } + call := g.s.GA.RegionNetworkEndpointGroups.AttachNetworkEndpoints(projectID, key.Region, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + + if err != nil { + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) + + klog.V(4).Infof("GCERegionNetworkEndpointGroups.AttachNetworkEndpoints(%v, %v, ...) = %+v", ctx, key, err) + return err + } + + err = g.s.WaitForCompletion(ctx, op) + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) // XXX + + klog.V(4).Infof("GCERegionNetworkEndpointGroups.AttachNetworkEndpoints(%v, %v, ...) = %+v", ctx, key, err) + return err +} + +// DetachNetworkEndpoints is a method on GCERegionNetworkEndpointGroups. +func (g *GCERegionNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key *meta.Key, arg0 *computega.RegionNetworkEndpointGroupsDetachEndpointsRequest, options ...Option) error { + opts := mergeOptions(options) + klog.V(5).Infof("GCERegionNetworkEndpointGroups.DetachNetworkEndpoints(%v, %v, %v, ...): called", ctx, key, opts) + + if !key.Valid() { + klog.V(2).Infof("GCERegionNetworkEndpointGroups.DetachNetworkEndpoints(%v, %v, %v, ...): key is invalid (%#v)", ctx, key, opts, key) + return fmt.Errorf("invalid GCE key (%+v)", key) + } + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "ga", "RegionNetworkEndpointGroups") + ck := &CallContextKey{ + ProjectID: projectID, + Operation: "DetachNetworkEndpoints", + Version: meta.Version("ga"), + Service: "RegionNetworkEndpointGroups", + } + klog.V(5).Infof("GCERegionNetworkEndpointGroups.DetachNetworkEndpoints(%v, %v, ...): projectID = %v, ck = %+v", ctx, key, projectID, ck) + callObserverStart(ctx, ck) + if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { + klog.V(4).Infof("GCERegionNetworkEndpointGroups.DetachNetworkEndpoints(%v, %v, ...): RateLimiter error: %v", ctx, key, err) + return err + } + call := g.s.GA.RegionNetworkEndpointGroups.DetachNetworkEndpoints(projectID, key.Region, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + + if err != nil { + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) + + klog.V(4).Infof("GCERegionNetworkEndpointGroups.DetachNetworkEndpoints(%v, %v, ...) = %+v", ctx, key, err) + return err + } + + err = g.s.WaitForCompletion(ctx, op) + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) // XXX + + klog.V(4).Infof("GCERegionNetworkEndpointGroups.DetachNetworkEndpoints(%v, %v, ...) = %+v", ctx, key, err) + return err +} + +// ListNetworkEndpoints is a method on GCERegionNetworkEndpointGroups. +func (g *GCERegionNetworkEndpointGroups) ListNetworkEndpoints(ctx context.Context, key *meta.Key, fl *filter.F, options ...Option) ([]*computega.NetworkEndpointWithHealthStatus, error) { + opts := mergeOptions(options) + klog.V(5).Infof("GCERegionNetworkEndpointGroups.ListNetworkEndpoints(%v, %v, %v, ...): called", ctx, key, opts) + + if !key.Valid() { + klog.V(2).Infof("GCERegionNetworkEndpointGroups.ListNetworkEndpoints(%v, %v, %v, ...): key is invalid (%#v)", ctx, key, opts, key) + return nil, fmt.Errorf("invalid GCE key (%+v)", key) + } + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "ga", "RegionNetworkEndpointGroups") + ck := &CallContextKey{ + ProjectID: projectID, + Operation: "ListNetworkEndpoints", + Version: meta.Version("ga"), + Service: "RegionNetworkEndpointGroups", + } + klog.V(5).Infof("GCERegionNetworkEndpointGroups.ListNetworkEndpoints(%v, %v, ...): projectID = %v, ck = %+v", ctx, key, projectID, ck) + callObserverStart(ctx, ck) + if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { + klog.V(4).Infof("GCERegionNetworkEndpointGroups.ListNetworkEndpoints(%v, %v, ...): RateLimiter error: %v", ctx, key, err) + return nil, err + } + call := g.s.GA.RegionNetworkEndpointGroups.ListNetworkEndpoints(projectID, key.Region, key.Name) + var all []*computega.NetworkEndpointWithHealthStatus + f := func(l *computega.NetworkEndpointGroupsListNetworkEndpoints) error { + klog.V(5).Infof("GCERegionNetworkEndpointGroups.ListNetworkEndpoints(%v, %v, ...): page %+v", ctx, key, l) + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) + + klog.V(4).Infof("GCERegionNetworkEndpointGroups.ListNetworkEndpoints(%v, %v, ...) = %v, %v", ctx, key, nil, err) + return nil, err + } + + callObserverEnd(ctx, ck, nil) + g.s.RateLimiter.Observe(ctx, nil, ck) + + if kLogEnabled(4) { + klog.V(4).Infof("GCERegionNetworkEndpointGroups.ListNetworkEndpoints(%v, %v, ...) = [%v items], %v", ctx, key, len(all), nil) + } else if kLogEnabled(5) { + var asStr []string + for _, o := range all { + asStr = append(asStr, fmt.Sprintf("%+v", o)) + } + klog.V(5).Infof("GCERegionNetworkEndpointGroups.ListNetworkEndpoints(%v, %v, ...) = %v, %v", ctx, key, asStr, nil) + } + return all, nil +} + +// Projects is an interface that allows for mocking of Projects. +type Projects interface { + // ProjectsOps is an interface with additional non-CRUD type methods. + // This interface is expected to be implemented by hand (non-autogenerated). + ProjectsOps +} + +// NewMockProjects returns a new mock for Projects. +func NewMockProjects(pr ProjectRouter, objs map[meta.Key]*MockProjectsObj) *MockProjects { + mock := &MockProjects{ + ProjectRouter: pr, + + Objects: objs, + } + return mock +} + +// MockProjects is the mock for Projects. +type MockProjects struct { + Lock sync.Mutex + + ProjectRouter ProjectRouter + + // Objects maintained by the mock. + Objects map[meta.Key]*MockProjectsObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Obj wraps the object for use in the mock. +func (m *MockProjects) Obj(o *computega.Project) *MockProjectsObj { + return &MockProjectsObj{o} +} + +// GCEProjects is a simplifying adapter for the GCE Projects. +type GCEProjects struct { + s *Service +} + +// Regions is an interface that allows for mocking of Regions. +type Regions interface { + Get(ctx context.Context, key *meta.Key, options ...Option) (*computega.Region, error) + List(ctx context.Context, fl *filter.F, options ...Option) ([]*computega.Region, error) +} + +// NewMockRegions returns a new mock for Regions. +func NewMockRegions(pr ProjectRouter, objs map[meta.Key]*MockRegionsObj) *MockRegions { + mock := &MockRegions{ + ProjectRouter: pr, + + Objects: objs, + GetError: map[meta.Key]error{}, + } + return mock +} + +// MockRegions is the mock for Regions. +type MockRegions struct { + Lock sync.Mutex + + ProjectRouter ProjectRouter + + // Objects maintained by the mock. + Objects map[meta.Key]*MockRegionsObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(ctx context.Context, key *meta.Key, m *MockRegions, options ...Option) (bool, *computega.Region, error) + ListHook func(ctx context.Context, fl *filter.F, m *MockRegions, options ...Option) (bool, []*computega.Region, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockRegions) Get(ctx context.Context, key *meta.Key, options ...Option) (*computega.Region, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(ctx, key, m, options...); intercept { + klog.V(5).Infof("MockRegions.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("MockRegions.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[*key]; ok { + typedObj := obj.ToGA() + klog.V(5).Infof("MockRegions.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockRegions %v not found", key), + } + klog.V(5).Infof("MockRegions.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockRegions) List(ctx context.Context, fl *filter.F, options ...Option) ([]*computega.Region, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(ctx, fl, m, options...); intercept { + klog.V(5).Infof("MockRegions.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + klog.V(5).Infof("MockRegions.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*computega.Region + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + klog.V(5).Infof("MockRegions.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Obj wraps the object for use in the mock. +func (m *MockRegions) Obj(o *computega.Region) *MockRegionsObj { + return &MockRegionsObj{o} +} + +// GCERegions is a simplifying adapter for the GCE Regions. +type GCERegions struct { + s *Service +} + +// Get the Region named by key. +func (g *GCERegions) Get(ctx context.Context, key *meta.Key, options ...Option) (*computega.Region, error) { + opts := mergeOptions(options) + klog.V(5).Infof("GCERegions.Get(%v, %v, %v): called", ctx, key, opts) + + if !key.Valid() { + klog.V(2).Infof("GCERegions.Get(%v, %v): key is invalid (%#v)", ctx, key, key) + return nil, fmt.Errorf("invalid GCE key (%#v)", key) + } + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "ga", "Regions") + + ck := &CallContextKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "Regions", + } + + klog.V(5).Infof("GCERegions.Get(%v, %v): projectID = %v, ck = %+v", ctx, key, projectID, ck) + callObserverStart(ctx, ck) + if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { + klog.V(4).Infof("GCERegions.Get(%v, %v): RateLimiter error: %v", ctx, key, err) + return nil, err + } + call := g.s.GA.Regions.Get(projectID, key.Name) + call.Context(ctx) + v, err := call.Do() + klog.V(4).Infof("GCERegions.Get(%v, %v) = %+v, %v", ctx, key, v, err) + + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) + + return v, err +} + +// List all Region objects. +func (g *GCERegions) List(ctx context.Context, fl *filter.F, options ...Option) ([]*computega.Region, error) { + opts := mergeOptions(options) + klog.V(5).Infof("GCERegions.List(%v, %v, %v) called", ctx, fl, opts) + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "ga", "Regions") + + ck := &CallContextKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "Regions", + } + + callObserverStart(ctx, ck) + if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { + return nil, err + } + klog.V(5).Infof("GCERegions.List(%v, %v): projectID = %v, ck = %+v", ctx, fl, projectID, ck) + call := g.s.GA.Regions.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + + var all []*computega.Region + f := func(l *computega.RegionList) error { + klog.V(5).Infof("GCERegions.List(%v, ..., %v): page %+v", ctx, fl, l) + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) + + klog.V(4).Infof("GCERegions.List(%v, ..., %v) = %v, %v", ctx, fl, nil, err) + return nil, err + } + + callObserverEnd(ctx, ck, nil) + g.s.RateLimiter.Observe(ctx, nil, ck) + + if kLogEnabled(4) { + klog.V(4).Infof("GCERegions.List(%v, ..., %v) = [%v items], %v", ctx, fl, len(all), nil) + } else if kLogEnabled(5) { + var asStr []string + for _, o := range all { + asStr = append(asStr, fmt.Sprintf("%+v", o)) + } + klog.V(5).Infof("GCERegions.List(%v, ..., %v) = %v, %v", ctx, fl, asStr, nil) + } + + return all, nil +} + +// AlphaRouters is an interface that allows for mocking of Routers. +type AlphaRouters interface { + Get(ctx context.Context, key *meta.Key, options ...Option) (*computealpha.Router, error) + List(ctx context.Context, region string, fl *filter.F, options ...Option) ([]*computealpha.Router, error) + Insert(ctx context.Context, key *meta.Key, obj *computealpha.Router, options ...Option) error + Delete(ctx context.Context, key *meta.Key, options ...Option) error + AggregatedList(ctx context.Context, fl *filter.F, options ...Option) (map[string][]*computealpha.Router, error) + GetRouterStatus(context.Context, *meta.Key, ...Option) (*computealpha.RouterStatusResponse, error) + Patch(context.Context, *meta.Key, *computealpha.Router, ...Option) error + Preview(context.Context, *meta.Key, *computealpha.Router, ...Option) (*computealpha.RoutersPreviewResponse, error) + TestIamPermissions(context.Context, *meta.Key, *computealpha.TestPermissionsRequest, ...Option) (*computealpha.TestPermissionsResponse, error) +} + +// NewMockAlphaRouters returns a new mock for Routers. +func NewMockAlphaRouters(pr ProjectRouter, objs map[meta.Key]*MockRoutersObj) *MockAlphaRouters { + mock := &MockAlphaRouters{ + ProjectRouter: pr, + + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockAlphaRouters is the mock for Routers. +type MockAlphaRouters struct { + Lock sync.Mutex + + ProjectRouter ProjectRouter + + // Objects maintained by the mock. + Objects map[meta.Key]*MockRoutersObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + AggregatedListError *error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaRouters, options ...Option) (bool, *computealpha.Router, error) + ListHook func(ctx context.Context, region string, fl *filter.F, m *MockAlphaRouters, options ...Option) (bool, []*computealpha.Router, error) + InsertHook func(ctx context.Context, key *meta.Key, obj *computealpha.Router, m *MockAlphaRouters, options ...Option) (bool, error) + DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaRouters, options ...Option) (bool, error) + AggregatedListHook func(ctx context.Context, fl *filter.F, m *MockAlphaRouters, options ...Option) (bool, map[string][]*computealpha.Router, error) + GetRouterStatusHook func(context.Context, *meta.Key, *MockAlphaRouters, ...Option) (*computealpha.RouterStatusResponse, error) + PatchHook func(context.Context, *meta.Key, *computealpha.Router, *MockAlphaRouters, ...Option) error + PreviewHook func(context.Context, *meta.Key, *computealpha.Router, *MockAlphaRouters, ...Option) (*computealpha.RoutersPreviewResponse, error) + TestIamPermissionsHook func(context.Context, *meta.Key, *computealpha.TestPermissionsRequest, *MockAlphaRouters, ...Option) (*computealpha.TestPermissionsResponse, 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 *MockAlphaRouters) Get(ctx context.Context, key *meta.Key, options ...Option) (*computealpha.Router, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(ctx, key, m, options...); intercept { + klog.V(5).Infof("MockAlphaRouters.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("MockAlphaRouters.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("MockAlphaRouters.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaRouters %v not found", key), + } + klog.V(5).Infof("MockAlphaRouters.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 *MockAlphaRouters) List(ctx context.Context, region string, fl *filter.F, options ...Option) ([]*computealpha.Router, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(ctx, region, fl, m, options...); intercept { + klog.V(5).Infof("MockAlphaRouters.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("MockAlphaRouters.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + + return nil, *m.ListError + } + + var objs []*computealpha.Router + 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("MockAlphaRouters.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 *MockAlphaRouters) Insert(ctx context.Context, key *meta.Key, obj *computealpha.Router, options ...Option) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(ctx, key, obj, m, options...); intercept { + klog.V(5).Infof("MockAlphaRouters.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + opts := mergeOptions(options) + 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("MockAlphaRouters.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("MockAlphaRouters %v exists", key), + } + klog.V(5).Infof("MockAlphaRouters.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + projectID := getProjectID(ctx, m.ProjectRouter, opts, "alpha", "routers") + obj.SelfLink = SelfLinkWithGroup("compute", meta.VersionAlpha, projectID, "routers", key) + + m.Objects[*key] = &MockRoutersObj{obj} + klog.V(5).Infof("MockAlphaRouters.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockAlphaRouters) Delete(ctx context.Context, key *meta.Key, options ...Option) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(ctx, key, m, options...); intercept { + klog.V(5).Infof("MockAlphaRouters.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("MockAlphaRouters.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[*key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaRouters %v not found", key), + } + klog.V(5).Infof("MockAlphaRouters.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, *key) + klog.V(5).Infof("MockAlphaRouters.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// AggregatedList is a mock for AggregatedList. +func (m *MockAlphaRouters) AggregatedList(ctx context.Context, fl *filter.F, options ...Option) (map[string][]*computealpha.Router, error) { + if m.AggregatedListHook != nil { + if intercept, objs, err := m.AggregatedListHook(ctx, fl, m, options...); intercept { + klog.V(5).Infof("MockAlphaRouters.AggregatedList(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.AggregatedListError != nil { + err := *m.AggregatedListError + klog.V(5).Infof("MockAlphaRouters.AggregatedList(%v, %v) = nil, %v", ctx, fl, err) + return nil, err + } + + objs := map[string][]*computealpha.Router{} + for _, obj := range m.Objects { + res, err := ParseResourceURL(obj.ToAlpha().SelfLink) + if err != nil { + klog.V(5).Infof("MockAlphaRouters.AggregatedList(%v, %v) = nil, %v", ctx, fl, err) + return nil, err + } + if !fl.Match(obj.ToAlpha()) { + continue + } + location := aggregatedListKey(res.Key) + objs[location] = append(objs[location], obj.ToAlpha()) + } + klog.V(5).Infof("MockAlphaRouters.AggregatedList(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Obj wraps the object for use in the mock. +func (m *MockAlphaRouters) Obj(o *computealpha.Router) *MockRoutersObj { + return &MockRoutersObj{o} +} + +// GetRouterStatus is a mock for the corresponding method. +func (m *MockAlphaRouters) GetRouterStatus(ctx context.Context, key *meta.Key, options ...Option) (*computealpha.RouterStatusResponse, error) { + if m.GetRouterStatusHook != nil { + return m.GetRouterStatusHook(ctx, key, m) + } + return nil, fmt.Errorf("GetRouterStatusHook must be set") +} + +// Patch is a mock for the corresponding method. +func (m *MockAlphaRouters) Patch(ctx context.Context, key *meta.Key, arg0 *computealpha.Router, options ...Option) error { + if m.PatchHook != nil { + return m.PatchHook(ctx, key, arg0, m) + } + return nil +} + +// Preview is a mock for the corresponding method. +func (m *MockAlphaRouters) Preview(ctx context.Context, key *meta.Key, arg0 *computealpha.Router, options ...Option) (*computealpha.RoutersPreviewResponse, error) { + if m.PreviewHook != nil { + return m.PreviewHook(ctx, key, arg0, m) + } + return nil, fmt.Errorf("PreviewHook must be set") +} + +// TestIamPermissions is a mock for the corresponding method. +func (m *MockAlphaRouters) TestIamPermissions(ctx context.Context, key *meta.Key, arg0 *computealpha.TestPermissionsRequest, options ...Option) (*computealpha.TestPermissionsResponse, error) { + if m.TestIamPermissionsHook != nil { + return m.TestIamPermissionsHook(ctx, key, arg0, m) + } + return nil, fmt.Errorf("TestIamPermissionsHook must be set") +} + +// GCEAlphaRouters is a simplifying adapter for the GCE Routers. +type GCEAlphaRouters struct { + s *Service +} + +// Get the Router named by key. +func (g *GCEAlphaRouters) Get(ctx context.Context, key *meta.Key, options ...Option) (*computealpha.Router, error) { + opts := mergeOptions(options) + klog.V(5).Infof("GCEAlphaRouters.Get(%v, %v, %v): called", ctx, key, opts) + + if !key.Valid() { + klog.V(2).Infof("GCEAlphaRouters.Get(%v, %v): key is invalid (%#v)", ctx, key, key) + return nil, fmt.Errorf("invalid GCE key (%#v)", key) + } + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "alpha", "Routers") + + ck := &CallContextKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("alpha"), + Service: "Routers", + } + + klog.V(5).Infof("GCEAlphaRouters.Get(%v, %v): projectID = %v, ck = %+v", ctx, key, projectID, ck) + callObserverStart(ctx, ck) + if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { + klog.V(4).Infof("GCEAlphaRouters.Get(%v, %v): RateLimiter error: %v", ctx, key, err) + return nil, err + } + call := g.s.Alpha.Routers.Get(projectID, key.Region, key.Name) + call.Context(ctx) + v, err := call.Do() + klog.V(4).Infof("GCEAlphaRouters.Get(%v, %v) = %+v, %v", ctx, key, v, err) + + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) + + return v, err +} + +// List all Router objects. +func (g *GCEAlphaRouters) List(ctx context.Context, region string, fl *filter.F, options ...Option) ([]*computealpha.Router, error) { + opts := mergeOptions(options) + klog.V(5).Infof("GCEAlphaRouters.List(%v, %v, %v, %v) called", ctx, region, fl, opts) + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "alpha", "Routers") + + ck := &CallContextKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("alpha"), + Service: "Routers", + } + + callObserverStart(ctx, ck) + if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { + return nil, err + } + klog.V(5).Infof("GCEAlphaRouters.List(%v, %v, %v): projectID = %v, ck = %+v", ctx, region, fl, projectID, ck) + call := g.s.Alpha.Routers.List(projectID, region) + if fl != filter.None { + call.Filter(fl.String()) + } + + var all []*computealpha.Router + f := func(l *computealpha.RouterList) error { + klog.V(5).Infof("GCEAlphaRouters.List(%v, ..., %v): page %+v", ctx, fl, l) + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) + + klog.V(4).Infof("GCEAlphaRouters.List(%v, ..., %v) = %v, %v", ctx, fl, nil, err) + return nil, err + } + + callObserverEnd(ctx, ck, nil) + g.s.RateLimiter.Observe(ctx, nil, ck) + + if kLogEnabled(4) { + klog.V(4).Infof("GCEAlphaRouters.List(%v, ..., %v) = [%v items], %v", ctx, fl, len(all), nil) + } else if kLogEnabled(5) { + var asStr []string + for _, o := range all { + asStr = append(asStr, fmt.Sprintf("%+v", o)) + } + klog.V(5).Infof("GCEAlphaRouters.List(%v, ..., %v) = %v, %v", ctx, fl, asStr, nil) + } + + return all, nil +} + +// Insert Router with key of value obj. +func (g *GCEAlphaRouters) Insert(ctx context.Context, key *meta.Key, obj *computealpha.Router, options ...Option) error { + opts := mergeOptions(options) + klog.V(5).Infof("GCEAlphaRouters.Insert(%v, %v, %+v, %v): called", ctx, key, obj, opts) + if !key.Valid() { + klog.V(2).Infof("GCEAlphaRouters.Insert(%v, %v, ...): key is invalid (%#v)", ctx, key, key) + return fmt.Errorf("invalid GCE key (%+v)", key) + } + + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "alpha", "Routers") + + ck := &CallContextKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("alpha"), + Service: "Routers", + } + klog.V(5).Infof("GCEAlphaRouters.Insert(%v, %v, ...): projectID = %v, ck = %+v", ctx, key, projectID, ck) + callObserverStart(ctx, ck) + if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { + klog.V(4).Infof("GCEAlphaRouters.Insert(%v, %v, ...): RateLimiter error: %v", ctx, key, err) + return err + } + obj.Name = key.Name + call := g.s.Alpha.Routers.Insert(projectID, key.Region, obj) + call.Context(ctx) + + op, err := call.Do() + + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) + + if err != nil { + klog.V(4).Infof("GCEAlphaRouters.Insert(%v, %v, ...) = %+v", ctx, key, err) + return err + } + + err = g.s.WaitForCompletion(ctx, op) + klog.V(4).Infof("GCEAlphaRouters.Insert(%v, %v, %+v) = %+v", ctx, key, obj, err) + return err +} + +// Delete the Router referenced by key. +func (g *GCEAlphaRouters) Delete(ctx context.Context, key *meta.Key, options ...Option) error { + opts := mergeOptions(options) + klog.V(5).Infof("GCEAlphaRouters.Delete(%v, %v, %v): called", ctx, key, opts) + if !key.Valid() { + klog.V(2).Infof("GCEAlphaRouters.Delete(%v, %v): key is invalid (%#v)", ctx, key, key) + return fmt.Errorf("invalid GCE key (%+v)", key) + } + + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "alpha", "Routers") + ck := &CallContextKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("alpha"), + Service: "Routers", + } + klog.V(5).Infof("GCEAlphaRouters.Delete(%v, %v): projectID = %v, ck = %+v", ctx, key, projectID, ck) + callObserverStart(ctx, ck) + if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { + klog.V(4).Infof("GCEAlphaRouters.Delete(%v, %v): RateLimiter error: %v", ctx, key, err) + return err + } + call := g.s.Alpha.Routers.Delete(projectID, key.Region, key.Name) + + call.Context(ctx) + + op, err := call.Do() + + callObserverEnd(ctx, ck, err) + g.s.RateLimiter.Observe(ctx, err, ck) + + if err != nil { + klog.V(4).Infof("GCEAlphaRouters.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + err = g.s.WaitForCompletion(ctx, op) + klog.V(4).Infof("GCEAlphaRouters.Delete(%v, %v) = %v", ctx, key, err) + return err +} + +// AggregatedList lists all resources of the given type across all locations. +func (g *GCEAlphaRouters) AggregatedList(ctx context.Context, fl *filter.F, options ...Option) (map[string][]*computealpha.Router, error) { + opts := mergeOptions(options) + klog.V(5).Infof("GCEAlphaRouters.AggregatedList(%v, %v) called", ctx, fl) + + projectID := getProjectID(ctx, g.s.ProjectRouter, opts, "alpha", "Routers") + ck := &CallContextKey{ + ProjectID: projectID, + Operation: "AggregatedList", + Version: meta.Version("alpha"), + Service: "Routers", + } + + klog.V(5).Infof("GCEAlphaRouters.AggregatedList(%v, %v): projectID = %v, ck = %+v", ctx, fl, projectID, ck) + callObserverStart(ctx, ck) + if err := g.s.RateLimiter.Accept(ctx, ck); err != nil { + klog.V(5).Infof("GCEAlphaRouters.AggregatedList(%v, %v): RateLimiter error: %v", ctx, fl, err) + return nil, err + } + call := g.s.Alpha.Routers.AggregatedList(projectID) call.Context(ctx) if fl != filter.None { @@ -50353,6 +52053,12 @@ func NewRegionHealthChecksResourceID(project, region, name string) *ResourceID { return &ResourceID{project, "compute", "healthChecks", key} } +// NewRegionNetworkEndpointGroupsResourceID creates a ResourceID for the RegionNetworkEndpointGroups resource. +func NewRegionNetworkEndpointGroupsResourceID(project, region, name string) *ResourceID { + key := meta.RegionalKey(name, region) + return &ResourceID{project, "compute", "networkEndpointGroups", key} +} + // NewRegionNetworkFirewallPoliciesResourceID creates a ResourceID for the RegionNetworkFirewallPolicies resource. func NewRegionNetworkFirewallPoliciesResourceID(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 ea5fe167..e6d7d495 100644 --- a/pkg/cloud/gen_test.go +++ b/pkg/cloud/gen_test.go @@ -2561,6 +2561,141 @@ func TestRegionHealthChecksGroup(t *testing.T) { } } +func TestRegionNetworkEndpointGroupsGroup(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 + keyBeta := meta.RegionalKey("key-beta", "location") + key = keyBeta + keyGA := meta.RegionalKey("key-ga", "location") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaRegionNetworkEndpointGroups().Get(ctx, key); err == nil { + t.Errorf("AlphaRegionNetworkEndpointGroups().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.BetaRegionNetworkEndpointGroups().Get(ctx, key); err == nil { + t.Errorf("BetaRegionNetworkEndpointGroups().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.RegionNetworkEndpointGroups().Get(ctx, key); err == nil { + t.Errorf("RegionNetworkEndpointGroups().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &computealpha.NetworkEndpointGroup{} + if err := mock.AlphaRegionNetworkEndpointGroups().Insert(ctx, keyAlpha, obj); err != nil { + t.Errorf("AlphaRegionNetworkEndpointGroups().Insert(%v, %v, %v) = %v; want nil", ctx, keyAlpha, obj, err) + } + } + { + obj := &computebeta.NetworkEndpointGroup{} + if err := mock.BetaRegionNetworkEndpointGroups().Insert(ctx, keyBeta, obj); err != nil { + t.Errorf("BetaRegionNetworkEndpointGroups().Insert(%v, %v, %v) = %v; want nil", ctx, keyBeta, obj, err) + } + } + { + obj := &computega.NetworkEndpointGroup{} + if err := mock.RegionNetworkEndpointGroups().Insert(ctx, keyGA, obj); err != nil { + t.Errorf("RegionNetworkEndpointGroups().Insert(%v, %v, %v) = %v; want nil", ctx, keyGA, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaRegionNetworkEndpointGroups().Get(ctx, key); err != nil { + t.Errorf("AlphaRegionNetworkEndpointGroups().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.BetaRegionNetworkEndpointGroups().Get(ctx, key); err != nil { + t.Errorf("BetaRegionNetworkEndpointGroups().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.RegionNetworkEndpointGroups().Get(ctx, key); err != nil { + t.Errorf("RegionNetworkEndpointGroups().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaRegionNetworkEndpointGroups.Objects[*keyAlpha] = mock.MockAlphaRegionNetworkEndpointGroups.Obj(&computealpha.NetworkEndpointGroup{Name: keyAlpha.Name}) + mock.MockBetaRegionNetworkEndpointGroups.Objects[*keyBeta] = mock.MockBetaRegionNetworkEndpointGroups.Obj(&computebeta.NetworkEndpointGroup{Name: keyBeta.Name}) + mock.MockRegionNetworkEndpointGroups.Objects[*keyGA] = mock.MockRegionNetworkEndpointGroups.Obj(&computega.NetworkEndpointGroup{Name: keyGA.Name}) + want := map[string]bool{ + "key-alpha": true, + "key-beta": true, + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaRegionNetworkEndpointGroups().List(ctx, location, filter.None) + if err != nil { + t.Errorf("AlphaRegionNetworkEndpointGroups().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("AlphaRegionNetworkEndpointGroups().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.BetaRegionNetworkEndpointGroups().List(ctx, location, filter.None) + if err != nil { + t.Errorf("BetaRegionNetworkEndpointGroups().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("BetaRegionNetworkEndpointGroups().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.RegionNetworkEndpointGroups().List(ctx, location, filter.None) + if err != nil { + t.Errorf("RegionNetworkEndpointGroups().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("RegionNetworkEndpointGroups().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaRegionNetworkEndpointGroups().Delete(ctx, keyAlpha); err != nil { + t.Errorf("AlphaRegionNetworkEndpointGroups().Delete(%v, %v) = %v; want nil", ctx, keyAlpha, err) + } + if err := mock.BetaRegionNetworkEndpointGroups().Delete(ctx, keyBeta); err != nil { + t.Errorf("BetaRegionNetworkEndpointGroups().Delete(%v, %v) = %v; want nil", ctx, keyBeta, err) + } + if err := mock.RegionNetworkEndpointGroups().Delete(ctx, keyGA); err != nil { + t.Errorf("RegionNetworkEndpointGroups().Delete(%v, %v) = %v; want nil", ctx, keyGA, err) + } + + // Delete not found. + if err := mock.AlphaRegionNetworkEndpointGroups().Delete(ctx, keyAlpha); err == nil { + t.Errorf("AlphaRegionNetworkEndpointGroups().Delete(%v, %v) = nil; want error", ctx, keyAlpha) + } + if err := mock.BetaRegionNetworkEndpointGroups().Delete(ctx, keyBeta); err == nil { + t.Errorf("BetaRegionNetworkEndpointGroups().Delete(%v, %v) = nil; want error", ctx, keyBeta) + } + if err := mock.RegionNetworkEndpointGroups().Delete(ctx, keyGA); err == nil { + t.Errorf("RegionNetworkEndpointGroups().Delete(%v, %v) = nil; want error", ctx, keyGA) + } +} + func TestRegionNetworkFirewallPoliciesGroup(t *testing.T) { t.Parallel() @@ -4754,6 +4889,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"), + NewRegionNetworkEndpointGroupsResourceID("some-project", "us-central1", "my-networkEndpointGroups-resource"), NewRegionNetworkFirewallPoliciesResourceID("some-project", "us-central1", "my-regionNetworkFirewallPolicies-resource"), NewRegionSslCertificatesResourceID("some-project", "us-central1", "my-sslCertificates-resource"), NewRegionSslPoliciesResourceID("some-project", "us-central1", "my-sslPolicies-resource"),