Skip to content

K
k3s
Unverified Commit fa094e66 authored by Kubernetes Submit Queue's avatar Kubernetes Submit Queue Committed by GitHub
Browse files
Options

Merge pull request #58435 from bowei/cp-gen-method-pages

Automatic merge from submit-queue (batch tested with PRs 58422, 58229, 58421, 58435, 58475). If you want to cherry-pick this change to another branch, please follow the instructions <a href="https://github.com/kubernetes/community/blob/master/contributors/devel/cherry-picks.md">here</a>. Add handling for method that use Pages() to retrieve results - Add handling for method that use Pages() to retrieve results - Make functions take in *Key rather than value type. ```release-note NONE ```
parents df76ee22 d3a1b4b2
Hide whitespace changes
Inline Side-by-side
Showing with 506 additions and 356 deletions
pkg/cloudprovider/providers/gce/cloud/gen.go
View file @ fa094e66
This source diff could not be displayed because it is too large. You can view the blob instead.
pkg/cloudprovider/providers/gce/cloud/gen/main.go
View file @ fa094e66
......@@ -276,7 +276,7 @@ type {{.WrapType}} interface {
{{.WrapTypeOps}}
{{- end}}
{{- if .GenerateGet}}
Get(ctx context.Context, key meta.Key) (*{{.FQObjectType}}, error)
Get(ctx context.Context, key *meta.Key) (*{{.FQObjectType}}, error)
{{- end -}}
{{- if .GenerateList}}
{{- if .KeyIsGlobal}}
......@@ -290,10 +290,10 @@ type {{.WrapType}} interface {
{{- end -}}
{{- end -}}
{{- if .GenerateInsert}}
Insert(ctx context.Context, key meta.Key, obj *{{.FQObjectType}}) error
Insert(ctx context.Context, key *meta.Key, obj *{{.FQObjectType}}) error
{{- end -}}
{{- if .GenerateDelete}}
Delete(ctx context.Context, key meta.Key) error
Delete(ctx context.Context, key *meta.Key) error
{{- end -}}
{{- if .AggregatedList}}
AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*{{.FQObjectType}}, error)
......@@ -352,7 +352,7 @@ type {{.MockWrapType}} struct {
// execution flow of the mock. Return (false, nil, nil) to continue with
// normal mock behavior/ after the hook function executes.
{{- if .GenerateGet}}
GetHook func(m *{{.MockWrapType}}, ctx context.Context, key meta.Key) (bool, *{{.FQObjectType}}, error)
GetHook func(m *{{.MockWrapType}}, ctx context.Context, key *meta.Key) (bool, *{{.FQObjectType}}, error)
{{- end -}}
{{- if .GenerateList}}
{{- if .KeyIsGlobal}}
......@@ -366,10 +366,10 @@ type {{.MockWrapType}} struct {
{{- end}}
{{- end -}}
{{- if .GenerateInsert}}
InsertHook func(m *{{.MockWrapType}}, ctx context.Context, key meta.Key, obj *{{.FQObjectType}}) (bool, error)
InsertHook func(m *{{.MockWrapType}}, ctx context.Context, key *meta.Key, obj *{{.FQObjectType}}) (bool, error)
{{- end -}}
{{- if .GenerateDelete}}
DeleteHook func(m *{{.MockWrapType}}, ctx context.Context, key meta.Key) (bool, error)
DeleteHook func(m *{{.MockWrapType}}, ctx context.Context, key *meta.Key) (bool, error)
{{- end -}}
{{- if .AggregatedList}}
AggregatedListHook func(m *{{.MockWrapType}}, ctx context.Context, fl *filter.F) (bool, map[string][]*{{.FQObjectType}}, error)
......@@ -388,7 +388,7 @@ type {{.MockWrapType}} struct {
{{- if .GenerateGet}}
// Get returns the object from the mock.
func (m *{{.MockWrapType}}) Get(ctx context.Context, key meta.Key) (*{{.FQObjectType}}, error) {
func (m *{{.MockWrapType}}) Get(ctx context.Context, key *meta.Key) (*{{.FQObjectType}}, error) {
if m.GetHook != nil {
if intercept, obj, err := m.GetHook(m, ctx, key); intercept {
glog.V(5).Infof("{{.MockWrapType}}.Get(%v, %s) = %+v, %v", ctx, key, obj ,err)
......@@ -399,11 +399,11 @@ func (m *{{.MockWrapType}}) Get(ctx context.Context, key meta.Key) (*{{.FQObject
m.Lock.Lock()
defer m.Lock.Unlock()
if err, ok := m.GetError[key]; ok {
if err, ok := m.GetError[*key]; ok {
glog.V(5).Infof("{{.MockWrapType}}.Get(%v, %s) = nil, %v", ctx, key, err)
return nil, err
}
if obj, ok := m.Objects[key]; ok {
if obj, ok := m.Objects[*key]; ok {
typedObj := obj.To{{.VersionTitle}}()
glog.V(5).Infof("{{.MockWrapType}}.Get(%v, %s) = %+v, nil", ctx, key, typedObj)
return typedObj, nil
......@@ -503,7 +503,7 @@ func (m *{{.MockWrapType}}) List(ctx context.Context, zone string, fl *filter.F)
{{- if .GenerateInsert}}
// Insert is a mock for inserting/creating a new object.
func (m *{{.MockWrapType}}) Insert(ctx context.Context, key meta.Key, obj *{{.FQObjectType}}) error {
func (m *{{.MockWrapType}}) Insert(ctx context.Context, key *meta.Key, obj *{{.FQObjectType}}) error {
if m.InsertHook != nil {
if intercept, err := m.InsertHook(m, ctx, key, obj); intercept {
glog.V(5).Infof("{{.MockWrapType}}.Insert(%v, %v, %+v) = %v", ctx, key, obj, err)
......@@ -514,11 +514,11 @@ func (m *{{.MockWrapType}}) Insert(ctx context.Context, key meta.Key, obj *{{.FQ
m.Lock.Lock()
defer m.Lock.Unlock()
if err, ok := m.InsertError[key]; ok {
if err, ok := m.InsertError[*key]; ok {
glog.V(5).Infof("{{.MockWrapType}}.Insert(%v, %v, %+v) = %v", ctx, key, obj, err)
return err
}
if _, ok := m.Objects[key]; ok {
if _, ok := m.Objects[*key]; ok {
err := &googleapi.Error{
Code: http.StatusConflict,
Message: fmt.Sprintf("{{.MockWrapType}} %v exists", key),
......@@ -532,7 +532,7 @@ func (m *{{.MockWrapType}}) Insert(ctx context.Context, key meta.Key, obj *{{.FQ
obj.SelfLink = SelfLink(meta.Version{{.VersionTitle}}, "mock-project", "{{.Resource}}", key)
}
m.Objects[key] = &Mock{{.Service}}Obj{obj}
m.Objects[*key] = &Mock{{.Service}}Obj{obj}
glog.V(5).Infof("{{.MockWrapType}}.Insert(%v, %v, %+v) = nil", ctx, key, obj)
return nil
}
......@@ -540,7 +540,7 @@ func (m *{{.MockWrapType}}) Insert(ctx context.Context, key meta.Key, obj *{{.FQ
{{- if .GenerateDelete}}
// Delete is a mock for deleting the object.
func (m *{{.MockWrapType}}) Delete(ctx context.Context, key meta.Key) error {
func (m *{{.MockWrapType}}) Delete(ctx context.Context, key *meta.Key) error {
if m.DeleteHook != nil {
if intercept, err := m.DeleteHook(m, ctx, key); intercept {
glog.V(5).Infof("{{.MockWrapType}}.Delete(%v, %v) = %v", ctx, key, err)
......@@ -551,11 +551,11 @@ func (m *{{.MockWrapType}}) Delete(ctx context.Context, key meta.Key) error {
m.Lock.Lock()
defer m.Lock.Unlock()
if err, ok := m.DeleteError[key]; ok {
if err, ok := m.DeleteError[*key]; ok {
glog.V(5).Infof("{{.MockWrapType}}.Delete(%v, %v) = %v", ctx, key, err)
return err
}
if _, ok := m.Objects[key]; !ok {
if _, ok := m.Objects[*key]; !ok {
err := &googleapi.Error{
Code: http.StatusNotFound,
Message: fmt.Sprintf("{{.MockWrapType}} %v not found", key),
......@@ -564,7 +564,7 @@ func (m *{{.MockWrapType}}) Delete(ctx context.Context, key meta.Key) error {
return err
}
delete(m.Objects, key)
delete(m.Objects, *key)
glog.V(5).Infof("{{.MockWrapType}}.Delete(%v, %v) = nil", ctx, key)
return nil
}
......@@ -621,16 +621,21 @@ func (m *{{.MockWrapType}}) Obj(o *{{.FQObjectType}}) *Mock{{.Service}}Obj {
{{- range .}}
// {{.Name}} is a mock for the corresponding method.
func (m *{{.MockWrapType}}) {{.FcnArgs}} {
{{- if eq .ReturnType "Operation"}}
{{- if .IsOperation }}
if m.{{.MockHookName}} != nil {
return m.{{.MockHookName}}(m, ctx, key {{.CallArgs}})
}
return nil
{{- else}}
{{- else if .IsGet}}
if m.{{.MockHookName}} != nil {
return m.{{.MockHookName}}(m, ctx, key {{.CallArgs}})
}
return nil, fmt.Errorf("{{.MockHookName}} must be set")
{{- else if .IsPaged}}
if m.{{.MockHookName}} != nil {
return m.{{.MockHookName}}(m, ctx, key {{.CallArgs}}, fl)
}
return nil, nil
{{- end}}
}
{{end -}}
......@@ -642,7 +647,7 @@ type {{.GCEWrapType}} struct {
{{- if .GenerateGet}}
// Get the {{.Object}} named by key.
func (g *{{.GCEWrapType}}) Get(ctx context.Context, key meta.Key) (*{{.FQObjectType}}, error) {
func (g *{{.GCEWrapType}}) Get(ctx context.Context, key *meta.Key) (*{{.FQObjectType}}, error) {
projectID := g.s.ProjectRouter.ProjectID(ctx, "{{.Version}}", "{{.Service}}")
rk := &RateLimitKey{
ProjectID: projectID,
......@@ -714,7 +719,7 @@ rk := &RateLimitKey{
{{- if .GenerateInsert}}
// Insert {{.Object}} with key of value obj.
func (g *{{.GCEWrapType}}) Insert(ctx context.Context, key meta.Key, obj *{{.FQObjectType}}) error {
func (g *{{.GCEWrapType}}) Insert(ctx context.Context, key *meta.Key, obj *{{.FQObjectType}}) error {
projectID := g.s.ProjectRouter.ProjectID(ctx, "{{.Version}}", "{{.Service}}")
rk := &RateLimitKey{
ProjectID: projectID,
......@@ -747,7 +752,7 @@ func (g *{{.GCEWrapType}}) Insert(ctx context.Context, key meta.Key, obj *{{.FQO
{{- if .GenerateDelete}}
// Delete the {{.Object}} referenced by key.
func (g *{{.GCEWrapType}}) Delete(ctx context.Context, key meta.Key) error {
func (g *{{.GCEWrapType}}) Delete(ctx context.Context, key *meta.Key) error {
projectID := g.s.ProjectRouter.ProjectID(ctx, "{{.Version}}", "{{.Service}}")
rk := &RateLimitKey{
ProjectID: projectID,
......@@ -823,7 +828,7 @@ func (g *{{.GCEWrapType}}) {{.FcnArgs}} {
Service: "{{.Service}}",
}
if err := g.s.RateLimiter.Accept(ctx, rk); err != nil {
{{- if eq .ReturnType "Operation"}}
{{- if .IsOperation}}
return err
{{- else}}
return nil, err
......@@ -838,15 +843,26 @@ func (g *{{.GCEWrapType}}) {{.FcnArgs}} {
{{- if .KeyIsZonal}}
call := g.s.{{.VersionTitle}}.{{.Service}}.{{.Name}}(projectID, key.Zone, key.Name {{.CallArgs}})
{{- end}}
{{- if .IsOperation}}
call.Context(ctx)
{{- if eq .ReturnType "Operation"}}
op, err := call.Do()
if err != nil {
return err
}
return g.s.WaitForCompletion(ctx, op)
{{- else}}
{{- else if .IsGet}}
call.Context(ctx)
return call.Do()
{{- else if .IsPaged}}
var all []*{{.Version}}.{{.ItemType}}
f := func(l *{{.Version}}.{{.ReturnType}}) error {
all = append(all, l.Items...)
return nil
}
if err := call.Pages(ctx, f); err != nil {
return nil, err
}
return all, nil
{{- end}}
}
{{end -}}
......@@ -933,17 +949,17 @@ func Test{{.Service}}Group(t *testing.T) {
// Get not found.
{{- if .HasAlpha}}{{- if .Alpha.GenerateGet}}
if _, err := mock.Alpha{{.Service}}().Get(ctx, *key); err == nil {
if _, err := mock.Alpha{{.Service}}().Get(ctx, key); err == nil {
t.Errorf("Alpha{{.Service}}().Get(%v, %v) = _, nil; want error", ctx, key)
}
{{- end}}{{- end}}
{{- if .HasBeta}}{{- if .Beta.GenerateGet}}
if _, err := mock.Beta{{.Service}}().Get(ctx, *key); err == nil {
if _, err := mock.Beta{{.Service}}().Get(ctx, key); err == nil {
t.Errorf("Beta{{.Service}}().Get(%v, %v) = _, nil; want error", ctx, key)
}
{{- end}}{{- end}}
{{- if .HasGA}}{{- if .GA.GenerateGet}}
if _, err := mock.{{.Service}}().Get(ctx, *key); err == nil {
if _, err := mock.{{.Service}}().Get(ctx, key); err == nil {
t.Errorf("{{.Service}}().Get(%v, %v) = _, nil; want error", ctx, key)
}
{{- end}}{{- end}}
......@@ -952,41 +968,41 @@ func Test{{.Service}}Group(t *testing.T) {
{{- if .HasAlpha}}{{- if .Alpha.GenerateInsert}}
{
obj := &alpha.{{.Alpha.Object}}{}
if err := mock.Alpha{{.Service}}().Insert(ctx, *keyAlpha, obj); err != nil {
t.Errorf("Alpha{{.Service}}().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.Alpha{{.Service}}().Insert(ctx, keyAlpha, obj); err != nil {
t.Errorf("Alpha{{.Service}}().Insert(%v, %v, %v) = %v; want nil", ctx, keyAlpha, obj, err)
}
}
{{- end}}{{- end}}
{{- if .HasBeta}}{{- if .Beta.GenerateInsert}}
{
obj := &beta.{{.Beta.Object}}{}
if err := mock.Beta{{.Service}}().Insert(ctx, *keyBeta, obj); err != nil {
t.Errorf("Beta{{.Service}}().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.Beta{{.Service}}().Insert(ctx, keyBeta, obj); err != nil {
t.Errorf("Beta{{.Service}}().Insert(%v, %v, %v) = %v; want nil", ctx, keyBeta, obj, err)
}
}
{{- end}}{{- end}}
{{- if .HasGA}}{{- if .GA.GenerateInsert}}
{
obj := &ga.{{.GA.Object}}{}
if err := mock.{{.Service}}().Insert(ctx, *keyGA, obj); err != nil {
t.Errorf("{{.Service}}().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.{{.Service}}().Insert(ctx, keyGA, obj); err != nil {
t.Errorf("{{.Service}}().Insert(%v, %v, %v) = %v; want nil", ctx, keyGA, obj, err)
}
}
{{- end}}{{- end}}
// Get across versions.
{{- if .HasAlpha}}{{- if .Alpha.GenerateInsert}}
if obj, err := mock.Alpha{{.Service}}().Get(ctx, *key); err != nil {
if obj, err := mock.Alpha{{.Service}}().Get(ctx, key); err != nil {
t.Errorf("Alpha{{.Service}}().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
{{- end}}{{- end}}
{{- if .HasBeta}}{{- if .Beta.GenerateInsert}}
if obj, err := mock.Beta{{.Service}}().Get(ctx, *key); err != nil {
if obj, err := mock.Beta{{.Service}}().Get(ctx, key); err != nil {
t.Errorf("Beta{{.Service}}().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
{{- end}}{{- end}}
{{- if .HasGA}}{{- if .GA.GenerateInsert}}
if obj, err := mock.{{.Service}}().Get(ctx, *key); err != nil {
if obj, err := mock.{{.Service}}().Get(ctx, key); err != nil {
t.Errorf("{{.Service}}().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
{{- end}}{{- end}}
......@@ -1077,35 +1093,35 @@ func Test{{.Service}}Group(t *testing.T) {
// Delete across versions.
{{- if .HasAlpha}}{{- if .Alpha.GenerateDelete}}
if err := mock.Alpha{{.Service}}().Delete(ctx, *keyAlpha); err != nil {
t.Errorf("Alpha{{.Service}}().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.Alpha{{.Service}}().Delete(ctx, keyAlpha); err != nil {
t.Errorf("Alpha{{.Service}}().Delete(%v, %v) = %v; want nil", ctx, keyAlpha, err)
}
{{- end}}{{- end}}
{{- if .HasBeta}}{{- if .Beta.GenerateDelete}}
if err := mock.Beta{{.Service}}().Delete(ctx, *keyBeta); err != nil {
t.Errorf("Beta{{.Service}}().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.Beta{{.Service}}().Delete(ctx, keyBeta); err != nil {
t.Errorf("Beta{{.Service}}().Delete(%v, %v) = %v; want nil", ctx, keyBeta, err)
}
{{- end}}{{- end}}
{{- if .HasGA}}{{- if .GA.GenerateDelete}}
if err := mock.{{.Service}}().Delete(ctx, *keyGA); err != nil {
t.Errorf("{{.Service}}().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.{{.Service}}().Delete(ctx, keyGA); err != nil {
t.Errorf("{{.Service}}().Delete(%v, %v) = %v; want nil", ctx, keyGA, err)
}
{{- end}}{{- end}}
// Delete not found.
{{- if .HasAlpha}}{{- if .Alpha.GenerateDelete}}
if err := mock.Alpha{{.Service}}().Delete(ctx, *keyAlpha); err == nil {
t.Errorf("Alpha{{.Service}}().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.Alpha{{.Service}}().Delete(ctx, keyAlpha); err == nil {
t.Errorf("Alpha{{.Service}}().Delete(%v, %v) = nil; want error", ctx, keyAlpha)
}
{{- end}}{{- end}}
{{- if .HasBeta}}{{- if .Beta.GenerateDelete}}
if err := mock.Beta{{.Service}}().Delete(ctx, *keyBeta); err == nil {
t.Errorf("Beta{{.Service}}().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.Beta{{.Service}}().Delete(ctx, keyBeta); err == nil {
t.Errorf("Beta{{.Service}}().Delete(%v, %v) = nil; want error", ctx, keyBeta)
}
{{- end}}{{- end}}
{{- if .HasGA}}{{- if .GA.GenerateDelete}}
if err := mock.{{.Service}}().Delete(ctx, *keyGA); err == nil {
t.Errorf("{{.Service}}().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.{{.Service}}().Delete(ctx, keyGA); err == nil {
t.Errorf("{{.Service}}().Delete(%v, %v) = nil; want error", ctx, keyGA)
}
{{- end}}{{- end}}
}
......
pkg/cloudprovider/providers/gce/cloud/gen_test.go
View file @ fa094e66
......@@ -51,44 +51,44 @@ func TestAddressesGroup(t *testing.T) {
_, _, _ = ctx, mock, key
// Get not found.
if _, err := mock.AlphaAddresses().Get(ctx, *key); err == nil {
if _, err := mock.AlphaAddresses().Get(ctx, key); err == nil {
t.Errorf("AlphaAddresses().Get(%v, %v) = _, nil; want error", ctx, key)
}
if _, err := mock.BetaAddresses().Get(ctx, *key); err == nil {
if _, err := mock.BetaAddresses().Get(ctx, key); err == nil {
t.Errorf("BetaAddresses().Get(%v, %v) = _, nil; want error", ctx, key)
}
if _, err := mock.Addresses().Get(ctx, *key); err == nil {
if _, err := mock.Addresses().Get(ctx, key); err == nil {
t.Errorf("Addresses().Get(%v, %v) = _, nil; want error", ctx, key)
}
// Insert.
{
obj := &alpha.Address{}
if err := mock.AlphaAddresses().Insert(ctx, *keyAlpha, obj); err != nil {
t.Errorf("AlphaAddresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.AlphaAddresses().Insert(ctx, keyAlpha, obj); err != nil {
t.Errorf("AlphaAddresses().Insert(%v, %v, %v) = %v; want nil", ctx, keyAlpha, obj, err)
}
}
{
obj := &beta.Address{}
if err := mock.BetaAddresses().Insert(ctx, *keyBeta, obj); err != nil {
t.Errorf("BetaAddresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.BetaAddresses().Insert(ctx, keyBeta, obj); err != nil {
t.Errorf("BetaAddresses().Insert(%v, %v, %v) = %v; want nil", ctx, keyBeta, obj, err)
}
}
{
obj := &ga.Address{}
if err := mock.Addresses().Insert(ctx, *keyGA, obj); err != nil {
t.Errorf("Addresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.Addresses().Insert(ctx, keyGA, obj); err != nil {
t.Errorf("Addresses().Insert(%v, %v, %v) = %v; want nil", ctx, keyGA, obj, err)
}
}
// Get across versions.
if obj, err := mock.AlphaAddresses().Get(ctx, *key); err != nil {
if obj, err := mock.AlphaAddresses().Get(ctx, key); err != nil {
t.Errorf("AlphaAddresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
if obj, err := mock.BetaAddresses().Get(ctx, *key); err != nil {
if obj, err := mock.BetaAddresses().Get(ctx, key); err != nil {
t.Errorf("BetaAddresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
if obj, err := mock.Addresses().Get(ctx, *key); err != nil {
if obj, err := mock.Addresses().Get(ctx, key); err != nil {
t.Errorf("Addresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
......@@ -146,25 +146,25 @@ func TestAddressesGroup(t *testing.T) {
}
// Delete across versions.
if err := mock.AlphaAddresses().Delete(ctx, *keyAlpha); err != nil {
t.Errorf("AlphaAddresses().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.AlphaAddresses().Delete(ctx, keyAlpha); err != nil {
t.Errorf("AlphaAddresses().Delete(%v, %v) = %v; want nil", ctx, keyAlpha, err)
}
if err := mock.BetaAddresses().Delete(ctx, *keyBeta); err != nil {
t.Errorf("BetaAddresses().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.BetaAddresses().Delete(ctx, keyBeta); err != nil {
t.Errorf("BetaAddresses().Delete(%v, %v) = %v; want nil", ctx, keyBeta, err)
}
if err := mock.Addresses().Delete(ctx, *keyGA); err != nil {
t.Errorf("Addresses().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.Addresses().Delete(ctx, keyGA); err != nil {
t.Errorf("Addresses().Delete(%v, %v) = %v; want nil", ctx, keyGA, err)
}
// Delete not found.
if err := mock.AlphaAddresses().Delete(ctx, *keyAlpha); err == nil {
t.Errorf("AlphaAddresses().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.AlphaAddresses().Delete(ctx, keyAlpha); err == nil {
t.Errorf("AlphaAddresses().Delete(%v, %v) = nil; want error", ctx, keyAlpha)
}
if err := mock.BetaAddresses().Delete(ctx, *keyBeta); err == nil {
t.Errorf("BetaAddresses().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.BetaAddresses().Delete(ctx, keyBeta); err == nil {
t.Errorf("BetaAddresses().Delete(%v, %v) = nil; want error", ctx, keyBeta)
}
if err := mock.Addresses().Delete(ctx, *keyGA); err == nil {
t.Errorf("Addresses().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.Addresses().Delete(ctx, keyGA); err == nil {
t.Errorf("Addresses().Delete(%v, %v) = nil; want error", ctx, keyGA)
}
}
......@@ -183,32 +183,32 @@ func TestBackendServicesGroup(t *testing.T) {
_, _, _ = ctx, mock, key
// Get not found.
if _, err := mock.AlphaBackendServices().Get(ctx, *key); err == nil {
if _, err := mock.AlphaBackendServices().Get(ctx, key); err == nil {
t.Errorf("AlphaBackendServices().Get(%v, %v) = _, nil; want error", ctx, key)
}
if _, err := mock.BackendServices().Get(ctx, *key); err == nil {
if _, err := mock.BackendServices().Get(ctx, key); err == nil {
t.Errorf("BackendServices().Get(%v, %v) = _, nil; want error", ctx, key)
}
// Insert.
{
obj := &alpha.BackendService{}
if err := mock.AlphaBackendServices().Insert(ctx, *keyAlpha, obj); err != nil {
t.Errorf("AlphaBackendServices().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.AlphaBackendServices().Insert(ctx, keyAlpha, obj); err != nil {
t.Errorf("AlphaBackendServices().Insert(%v, %v, %v) = %v; want nil", ctx, keyAlpha, obj, err)
}
}
{
obj := &ga.BackendService{}
if err := mock.BackendServices().Insert(ctx, *keyGA, obj); err != nil {
t.Errorf("BackendServices().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.BackendServices().Insert(ctx, keyGA, obj); err != nil {
t.Errorf("BackendServices().Insert(%v, %v, %v) = %v; want nil", ctx, keyGA, obj, err)
}
}
// Get across versions.
if obj, err := mock.AlphaBackendServices().Get(ctx, *key); err != nil {
if obj, err := mock.AlphaBackendServices().Get(ctx, key); err != nil {
t.Errorf("AlphaBackendServices().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
if obj, err := mock.BackendServices().Get(ctx, *key); err != nil {
if obj, err := mock.BackendServices().Get(ctx, key); err != nil {
t.Errorf("BackendServices().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
......@@ -250,19 +250,19 @@ func TestBackendServicesGroup(t *testing.T) {
}
// Delete across versions.
if err := mock.AlphaBackendServices().Delete(ctx, *keyAlpha); err != nil {
t.Errorf("AlphaBackendServices().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.AlphaBackendServices().Delete(ctx, keyAlpha); err != nil {
t.Errorf("AlphaBackendServices().Delete(%v, %v) = %v; want nil", ctx, keyAlpha, err)
}
if err := mock.BackendServices().Delete(ctx, *keyGA); err != nil {
t.Errorf("BackendServices().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.BackendServices().Delete(ctx, keyGA); err != nil {
t.Errorf("BackendServices().Delete(%v, %v) = %v; want nil", ctx, keyGA, err)
}
// Delete not found.
if err := mock.AlphaBackendServices().Delete(ctx, *keyAlpha); err == nil {
t.Errorf("AlphaBackendServices().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.AlphaBackendServices().Delete(ctx, keyAlpha); err == nil {
t.Errorf("AlphaBackendServices().Delete(%v, %v) = nil; want error", ctx, keyAlpha)
}
if err := mock.BackendServices().Delete(ctx, *keyGA); err == nil {
t.Errorf("BackendServices().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.BackendServices().Delete(ctx, keyGA); err == nil {
t.Errorf("BackendServices().Delete(%v, %v) = nil; want error", ctx, keyGA)
}
}
......@@ -281,32 +281,32 @@ func TestDisksGroup(t *testing.T) {
_, _, _ = ctx, mock, key
// Get not found.
if _, err := mock.AlphaDisks().Get(ctx, *key); err == nil {
if _, err := mock.AlphaDisks().Get(ctx, key); err == nil {
t.Errorf("AlphaDisks().Get(%v, %v) = _, nil; want error", ctx, key)
}
if _, err := mock.Disks().Get(ctx, *key); err == nil {
if _, err := mock.Disks().Get(ctx, key); err == nil {
t.Errorf("Disks().Get(%v, %v) = _, nil; want error", ctx, key)
}
// Insert.
{
obj := &alpha.Disk{}
if err := mock.AlphaDisks().Insert(ctx, *keyAlpha, obj); err != nil {
t.Errorf("AlphaDisks().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.AlphaDisks().Insert(ctx, keyAlpha, obj); err != nil {
t.Errorf("AlphaDisks().Insert(%v, %v, %v) = %v; want nil", ctx, keyAlpha, obj, err)
}
}
{
obj := &ga.Disk{}
if err := mock.Disks().Insert(ctx, *keyGA, obj); err != nil {
t.Errorf("Disks().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.Disks().Insert(ctx, keyGA, obj); err != nil {
t.Errorf("Disks().Insert(%v, %v, %v) = %v; want nil", ctx, keyGA, obj, err)
}
}
// Get across versions.
if obj, err := mock.AlphaDisks().Get(ctx, *key); err != nil {
if obj, err := mock.AlphaDisks().Get(ctx, key); err != nil {
t.Errorf("AlphaDisks().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
if obj, err := mock.Disks().Get(ctx, *key); err != nil {
if obj, err := mock.Disks().Get(ctx, key); err != nil {
t.Errorf("Disks().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
......@@ -348,19 +348,19 @@ func TestDisksGroup(t *testing.T) {
}
// Delete across versions.
if err := mock.AlphaDisks().Delete(ctx, *keyAlpha); err != nil {
t.Errorf("AlphaDisks().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.AlphaDisks().Delete(ctx, keyAlpha); err != nil {
t.Errorf("AlphaDisks().Delete(%v, %v) = %v; want nil", ctx, keyAlpha, err)
}
if err := mock.Disks().Delete(ctx, *keyGA); err != nil {
t.Errorf("Disks().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.Disks().Delete(ctx, keyGA); err != nil {
t.Errorf("Disks().Delete(%v, %v) = %v; want nil", ctx, keyGA, err)
}
// Delete not found.
if err := mock.AlphaDisks().Delete(ctx, *keyAlpha); err == nil {
t.Errorf("AlphaDisks().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.AlphaDisks().Delete(ctx, keyAlpha); err == nil {
t.Errorf("AlphaDisks().Delete(%v, %v) = nil; want error", ctx, keyAlpha)
}
if err := mock.Disks().Delete(ctx, *keyGA); err == nil {
t.Errorf("Disks().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.Disks().Delete(ctx, keyGA); err == nil {
t.Errorf("Disks().Delete(%v, %v) = nil; want error", ctx, keyGA)
}
}
......@@ -377,20 +377,20 @@ func TestFirewallsGroup(t *testing.T) {
_, _, _ = ctx, mock, key
// Get not found.
if _, err := mock.Firewalls().Get(ctx, *key); err == nil {
if _, err := mock.Firewalls().Get(ctx, key); err == nil {
t.Errorf("Firewalls().Get(%v, %v) = _, nil; want error", ctx, key)
}
// Insert.
{
obj := &ga.Firewall{}
if err := mock.Firewalls().Insert(ctx, *keyGA, obj); err != nil {
t.Errorf("Firewalls().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.Firewalls().Insert(ctx, keyGA, obj); err != nil {
t.Errorf("Firewalls().Insert(%v, %v, %v) = %v; want nil", ctx, keyGA, obj, err)
}
}
// Get across versions.
if obj, err := mock.Firewalls().Get(ctx, *key); err != nil {
if obj, err := mock.Firewalls().Get(ctx, key); err != nil {
t.Errorf("Firewalls().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
......@@ -416,13 +416,13 @@ func TestFirewallsGroup(t *testing.T) {
}
// Delete across versions.
if err := mock.Firewalls().Delete(ctx, *keyGA); err != nil {
t.Errorf("Firewalls().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.Firewalls().Delete(ctx, keyGA); err != nil {
t.Errorf("Firewalls().Delete(%v, %v) = %v; want nil", ctx, keyGA, err)
}
// Delete not found.
if err := mock.Firewalls().Delete(ctx, *keyGA); err == nil {
t.Errorf("Firewalls().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.Firewalls().Delete(ctx, keyGA); err == nil {
t.Errorf("Firewalls().Delete(%v, %v) = nil; want error", ctx, keyGA)
}
}
......@@ -441,32 +441,32 @@ func TestForwardingRulesGroup(t *testing.T) {
_, _, _ = ctx, mock, key
// Get not found.
if _, err := mock.AlphaForwardingRules().Get(ctx, *key); err == nil {
if _, err := mock.AlphaForwardingRules().Get(ctx, key); err == nil {
t.Errorf("AlphaForwardingRules().Get(%v, %v) = _, nil; want error", ctx, key)
}
if _, err := mock.ForwardingRules().Get(ctx, *key); err == nil {
if _, err := mock.ForwardingRules().Get(ctx, key); err == nil {
t.Errorf("ForwardingRules().Get(%v, %v) = _, nil; want error", ctx, key)
}
// Insert.
{
obj := &alpha.ForwardingRule{}
if err := mock.AlphaForwardingRules().Insert(ctx, *keyAlpha, obj); err != nil {
t.Errorf("AlphaForwardingRules().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.AlphaForwardingRules().Insert(ctx, keyAlpha, obj); err != nil {
t.Errorf("AlphaForwardingRules().Insert(%v, %v, %v) = %v; want nil", ctx, keyAlpha, obj, err)
}
}
{
obj := &ga.ForwardingRule{}
if err := mock.ForwardingRules().Insert(ctx, *keyGA, obj); err != nil {
t.Errorf("ForwardingRules().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.ForwardingRules().Insert(ctx, keyGA, obj); err != nil {
t.Errorf("ForwardingRules().Insert(%v, %v, %v) = %v; want nil", ctx, keyGA, obj, err)
}
}
// Get across versions.
if obj, err := mock.AlphaForwardingRules().Get(ctx, *key); err != nil {
if obj, err := mock.AlphaForwardingRules().Get(ctx, key); err != nil {
t.Errorf("AlphaForwardingRules().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
if obj, err := mock.ForwardingRules().Get(ctx, *key); err != nil {
if obj, err := mock.ForwardingRules().Get(ctx, key); err != nil {
t.Errorf("ForwardingRules().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
......@@ -508,19 +508,19 @@ func TestForwardingRulesGroup(t *testing.T) {
}
// Delete across versions.
if err := mock.AlphaForwardingRules().Delete(ctx, *keyAlpha); err != nil {
t.Errorf("AlphaForwardingRules().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.AlphaForwardingRules().Delete(ctx, keyAlpha); err != nil {
t.Errorf("AlphaForwardingRules().Delete(%v, %v) = %v; want nil", ctx, keyAlpha, err)
}
if err := mock.ForwardingRules().Delete(ctx, *keyGA); err != nil {
t.Errorf("ForwardingRules().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.ForwardingRules().Delete(ctx, keyGA); err != nil {
t.Errorf("ForwardingRules().Delete(%v, %v) = %v; want nil", ctx, keyGA, err)
}
// Delete not found.
if err := mock.AlphaForwardingRules().Delete(ctx, *keyAlpha); err == nil {
t.Errorf("AlphaForwardingRules().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.AlphaForwardingRules().Delete(ctx, keyAlpha); err == nil {
t.Errorf("AlphaForwardingRules().Delete(%v, %v) = nil; want error", ctx, keyAlpha)
}
if err := mock.ForwardingRules().Delete(ctx, *keyGA); err == nil {
t.Errorf("ForwardingRules().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.ForwardingRules().Delete(ctx, keyGA); err == nil {
t.Errorf("ForwardingRules().Delete(%v, %v) = nil; want error", ctx, keyGA)
}
}
......@@ -537,20 +537,20 @@ func TestGlobalAddressesGroup(t *testing.T) {
_, _, _ = ctx, mock, key
// Get not found.
if _, err := mock.GlobalAddresses().Get(ctx, *key); err == nil {
if _, err := mock.GlobalAddresses().Get(ctx, key); err == nil {
t.Errorf("GlobalAddresses().Get(%v, %v) = _, nil; want error", ctx, key)
}
// Insert.
{
obj := &ga.Address{}
if err := mock.GlobalAddresses().Insert(ctx, *keyGA, obj); err != nil {
t.Errorf("GlobalAddresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.GlobalAddresses().Insert(ctx, keyGA, obj); err != nil {
t.Errorf("GlobalAddresses().Insert(%v, %v, %v) = %v; want nil", ctx, keyGA, obj, err)
}
}
// Get across versions.
if obj, err := mock.GlobalAddresses().Get(ctx, *key); err != nil {
if obj, err := mock.GlobalAddresses().Get(ctx, key); err != nil {
t.Errorf("GlobalAddresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
......@@ -576,13 +576,13 @@ func TestGlobalAddressesGroup(t *testing.T) {
}
// Delete across versions.
if err := mock.GlobalAddresses().Delete(ctx, *keyGA); err != nil {
t.Errorf("GlobalAddresses().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.GlobalAddresses().Delete(ctx, keyGA); err != nil {
t.Errorf("GlobalAddresses().Delete(%v, %v) = %v; want nil", ctx, keyGA, err)
}
// Delete not found.
if err := mock.GlobalAddresses().Delete(ctx, *keyGA); err == nil {
t.Errorf("GlobalAddresses().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.GlobalAddresses().Delete(ctx, keyGA); err == nil {
t.Errorf("GlobalAddresses().Delete(%v, %v) = nil; want error", ctx, keyGA)
}
}
......@@ -599,20 +599,20 @@ func TestGlobalForwardingRulesGroup(t *testing.T) {
_, _, _ = ctx, mock, key
// Get not found.
if _, err := mock.GlobalForwardingRules().Get(ctx, *key); err == nil {
if _, err := mock.GlobalForwardingRules().Get(ctx, key); err == nil {
t.Errorf("GlobalForwardingRules().Get(%v, %v) = _, nil; want error", ctx, key)
}
// Insert.
{
obj := &ga.ForwardingRule{}
if err := mock.GlobalForwardingRules().Insert(ctx, *keyGA, obj); err != nil {
t.Errorf("GlobalForwardingRules().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.GlobalForwardingRules().Insert(ctx, keyGA, obj); err != nil {
t.Errorf("GlobalForwardingRules().Insert(%v, %v, %v) = %v; want nil", ctx, keyGA, obj, err)
}
}
// Get across versions.
if obj, err := mock.GlobalForwardingRules().Get(ctx, *key); err != nil {
if obj, err := mock.GlobalForwardingRules().Get(ctx, key); err != nil {
t.Errorf("GlobalForwardingRules().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
......@@ -638,13 +638,13 @@ func TestGlobalForwardingRulesGroup(t *testing.T) {
}
// Delete across versions.
if err := mock.GlobalForwardingRules().Delete(ctx, *keyGA); err != nil {
t.Errorf("GlobalForwardingRules().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.GlobalForwardingRules().Delete(ctx, keyGA); err != nil {
t.Errorf("GlobalForwardingRules().Delete(%v, %v) = %v; want nil", ctx, keyGA, err)
}
// Delete not found.
if err := mock.GlobalForwardingRules().Delete(ctx, *keyGA); err == nil {
t.Errorf("GlobalForwardingRules().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.GlobalForwardingRules().Delete(ctx, keyGA); err == nil {
t.Errorf("GlobalForwardingRules().Delete(%v, %v) = nil; want error", ctx, keyGA)
}
}
......@@ -663,32 +663,32 @@ func TestHealthChecksGroup(t *testing.T) {
_, _, _ = ctx, mock, key
// Get not found.
if _, err := mock.AlphaHealthChecks().Get(ctx, *key); err == nil {
if _, err := mock.AlphaHealthChecks().Get(ctx, key); err == nil {
t.Errorf("AlphaHealthChecks().Get(%v, %v) = _, nil; want error", ctx, key)
}
if _, err := mock.HealthChecks().Get(ctx, *key); err == nil {
if _, err := mock.HealthChecks().Get(ctx, key); err == nil {
t.Errorf("HealthChecks().Get(%v, %v) = _, nil; want error", ctx, key)
}
// Insert.
{
obj := &alpha.HealthCheck{}
if err := mock.AlphaHealthChecks().Insert(ctx, *keyAlpha, obj); err != nil {
t.Errorf("AlphaHealthChecks().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.AlphaHealthChecks().Insert(ctx, keyAlpha, obj); err != nil {
t.Errorf("AlphaHealthChecks().Insert(%v, %v, %v) = %v; want nil", ctx, keyAlpha, obj, err)
}
}
{
obj := &ga.HealthCheck{}
if err := mock.HealthChecks().Insert(ctx, *keyGA, obj); err != nil {
t.Errorf("HealthChecks().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.HealthChecks().Insert(ctx, keyGA, obj); err != nil {
t.Errorf("HealthChecks().Insert(%v, %v, %v) = %v; want nil", ctx, keyGA, obj, err)
}
}
// Get across versions.
if obj, err := mock.AlphaHealthChecks().Get(ctx, *key); err != nil {
if obj, err := mock.AlphaHealthChecks().Get(ctx, key); err != nil {
t.Errorf("AlphaHealthChecks().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
if obj, err := mock.HealthChecks().Get(ctx, *key); err != nil {
if obj, err := mock.HealthChecks().Get(ctx, key); err != nil {
t.Errorf("HealthChecks().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
......@@ -730,19 +730,19 @@ func TestHealthChecksGroup(t *testing.T) {
}
// Delete across versions.
if err := mock.AlphaHealthChecks().Delete(ctx, *keyAlpha); err != nil {
t.Errorf("AlphaHealthChecks().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.AlphaHealthChecks().Delete(ctx, keyAlpha); err != nil {
t.Errorf("AlphaHealthChecks().Delete(%v, %v) = %v; want nil", ctx, keyAlpha, err)
}
if err := mock.HealthChecks().Delete(ctx, *keyGA); err != nil {
t.Errorf("HealthChecks().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.HealthChecks().Delete(ctx, keyGA); err != nil {
t.Errorf("HealthChecks().Delete(%v, %v) = %v; want nil", ctx, keyGA, err)
}
// Delete not found.
if err := mock.AlphaHealthChecks().Delete(ctx, *keyAlpha); err == nil {
t.Errorf("AlphaHealthChecks().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.AlphaHealthChecks().Delete(ctx, keyAlpha); err == nil {
t.Errorf("AlphaHealthChecks().Delete(%v, %v) = nil; want error", ctx, keyAlpha)
}
if err := mock.HealthChecks().Delete(ctx, *keyGA); err == nil {
t.Errorf("HealthChecks().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.HealthChecks().Delete(ctx, keyGA); err == nil {
t.Errorf("HealthChecks().Delete(%v, %v) = nil; want error", ctx, keyGA)
}
}
......@@ -759,20 +759,20 @@ func TestHttpHealthChecksGroup(t *testing.T) {
_, _, _ = ctx, mock, key
// Get not found.
if _, err := mock.HttpHealthChecks().Get(ctx, *key); err == nil {
if _, err := mock.HttpHealthChecks().Get(ctx, key); err == nil {
t.Errorf("HttpHealthChecks().Get(%v, %v) = _, nil; want error", ctx, key)
}
// Insert.
{
obj := &ga.HttpHealthCheck{}
if err := mock.HttpHealthChecks().Insert(ctx, *keyGA, obj); err != nil {
t.Errorf("HttpHealthChecks().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.HttpHealthChecks().Insert(ctx, keyGA, obj); err != nil {
t.Errorf("HttpHealthChecks().Insert(%v, %v, %v) = %v; want nil", ctx, keyGA, obj, err)
}
}
// Get across versions.
if obj, err := mock.HttpHealthChecks().Get(ctx, *key); err != nil {
if obj, err := mock.HttpHealthChecks().Get(ctx, key); err != nil {
t.Errorf("HttpHealthChecks().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
......@@ -798,13 +798,13 @@ func TestHttpHealthChecksGroup(t *testing.T) {
}
// Delete across versions.
if err := mock.HttpHealthChecks().Delete(ctx, *keyGA); err != nil {
t.Errorf("HttpHealthChecks().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.HttpHealthChecks().Delete(ctx, keyGA); err != nil {
t.Errorf("HttpHealthChecks().Delete(%v, %v) = %v; want nil", ctx, keyGA, err)
}
// Delete not found.
if err := mock.HttpHealthChecks().Delete(ctx, *keyGA); err == nil {
t.Errorf("HttpHealthChecks().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.HttpHealthChecks().Delete(ctx, keyGA); err == nil {
t.Errorf("HttpHealthChecks().Delete(%v, %v) = nil; want error", ctx, keyGA)
}
}
......@@ -821,20 +821,20 @@ func TestHttpsHealthChecksGroup(t *testing.T) {
_, _, _ = ctx, mock, key
// Get not found.
if _, err := mock.HttpsHealthChecks().Get(ctx, *key); err == nil {
if _, err := mock.HttpsHealthChecks().Get(ctx, key); err == nil {
t.Errorf("HttpsHealthChecks().Get(%v, %v) = _, nil; want error", ctx, key)
}
// Insert.
{
obj := &ga.HttpsHealthCheck{}
if err := mock.HttpsHealthChecks().Insert(ctx, *keyGA, obj); err != nil {
t.Errorf("HttpsHealthChecks().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.HttpsHealthChecks().Insert(ctx, keyGA, obj); err != nil {
t.Errorf("HttpsHealthChecks().Insert(%v, %v, %v) = %v; want nil", ctx, keyGA, obj, err)
}
}
// Get across versions.
if obj, err := mock.HttpsHealthChecks().Get(ctx, *key); err != nil {
if obj, err := mock.HttpsHealthChecks().Get(ctx, key); err != nil {
t.Errorf("HttpsHealthChecks().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
......@@ -860,13 +860,13 @@ func TestHttpsHealthChecksGroup(t *testing.T) {
}
// Delete across versions.
if err := mock.HttpsHealthChecks().Delete(ctx, *keyGA); err != nil {
t.Errorf("HttpsHealthChecks().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.HttpsHealthChecks().Delete(ctx, keyGA); err != nil {
t.Errorf("HttpsHealthChecks().Delete(%v, %v) = %v; want nil", ctx, keyGA, err)
}
// Delete not found.
if err := mock.HttpsHealthChecks().Delete(ctx, *keyGA); err == nil {
t.Errorf("HttpsHealthChecks().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.HttpsHealthChecks().Delete(ctx, keyGA); err == nil {
t.Errorf("HttpsHealthChecks().Delete(%v, %v) = nil; want error", ctx, keyGA)
}
}
......@@ -883,20 +883,20 @@ func TestInstanceGroupsGroup(t *testing.T) {
_, _, _ = ctx, mock, key
// Get not found.
if _, err := mock.InstanceGroups().Get(ctx, *key); err == nil {
if _, err := mock.InstanceGroups().Get(ctx, key); err == nil {
t.Errorf("InstanceGroups().Get(%v, %v) = _, nil; want error", ctx, key)
}
// Insert.
{
obj := &ga.InstanceGroup{}
if err := mock.InstanceGroups().Insert(ctx, *keyGA, obj); err != nil {
t.Errorf("InstanceGroups().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.InstanceGroups().Insert(ctx, keyGA, obj); err != nil {
t.Errorf("InstanceGroups().Insert(%v, %v, %v) = %v; want nil", ctx, keyGA, obj, err)
}
}
// Get across versions.
if obj, err := mock.InstanceGroups().Get(ctx, *key); err != nil {
if obj, err := mock.InstanceGroups().Get(ctx, key); err != nil {
t.Errorf("InstanceGroups().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
......@@ -922,13 +922,13 @@ func TestInstanceGroupsGroup(t *testing.T) {
}
// Delete across versions.
if err := mock.InstanceGroups().Delete(ctx, *keyGA); err != nil {
t.Errorf("InstanceGroups().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.InstanceGroups().Delete(ctx, keyGA); err != nil {
t.Errorf("InstanceGroups().Delete(%v, %v) = %v; want nil", ctx, keyGA, err)
}
// Delete not found.
if err := mock.InstanceGroups().Delete(ctx, *keyGA); err == nil {
t.Errorf("InstanceGroups().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.InstanceGroups().Delete(ctx, keyGA); err == nil {
t.Errorf("InstanceGroups().Delete(%v, %v) = nil; want error", ctx, keyGA)
}
}
......@@ -949,44 +949,44 @@ func TestInstancesGroup(t *testing.T) {
_, _, _ = ctx, mock, key
// Get not found.
if _, err := mock.AlphaInstances().Get(ctx, *key); err == nil {
if _, err := mock.AlphaInstances().Get(ctx, key); err == nil {
t.Errorf("AlphaInstances().Get(%v, %v) = _, nil; want error", ctx, key)
}
if _, err := mock.BetaInstances().Get(ctx, *key); err == nil {
if _, err := mock.BetaInstances().Get(ctx, key); err == nil {
t.Errorf("BetaInstances().Get(%v, %v) = _, nil; want error", ctx, key)
}
if _, err := mock.Instances().Get(ctx, *key); err == nil {
if _, err := mock.Instances().Get(ctx, key); err == nil {
t.Errorf("Instances().Get(%v, %v) = _, nil; want error", ctx, key)
}
// Insert.
{
obj := &alpha.Instance{}
if err := mock.AlphaInstances().Insert(ctx, *keyAlpha, obj); err != nil {
t.Errorf("AlphaInstances().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.AlphaInstances().Insert(ctx, keyAlpha, obj); err != nil {
t.Errorf("AlphaInstances().Insert(%v, %v, %v) = %v; want nil", ctx, keyAlpha, obj, err)
}
}
{
obj := &beta.Instance{}
if err := mock.BetaInstances().Insert(ctx, *keyBeta, obj); err != nil {
t.Errorf("BetaInstances().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.BetaInstances().Insert(ctx, keyBeta, obj); err != nil {
t.Errorf("BetaInstances().Insert(%v, %v, %v) = %v; want nil", ctx, keyBeta, obj, err)
}
}
{
obj := &ga.Instance{}
if err := mock.Instances().Insert(ctx, *keyGA, obj); err != nil {
t.Errorf("Instances().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.Instances().Insert(ctx, keyGA, obj); err != nil {
t.Errorf("Instances().Insert(%v, %v, %v) = %v; want nil", ctx, keyGA, obj, err)
}
}
// Get across versions.
if obj, err := mock.AlphaInstances().Get(ctx, *key); err != nil {
if obj, err := mock.AlphaInstances().Get(ctx, key); err != nil {
t.Errorf("AlphaInstances().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
if obj, err := mock.BetaInstances().Get(ctx, *key); err != nil {
if obj, err := mock.BetaInstances().Get(ctx, key); err != nil {
t.Errorf("BetaInstances().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
if obj, err := mock.Instances().Get(ctx, *key); err != nil {
if obj, err := mock.Instances().Get(ctx, key); err != nil {
t.Errorf("Instances().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
......@@ -1044,25 +1044,25 @@ func TestInstancesGroup(t *testing.T) {
}
// Delete across versions.
if err := mock.AlphaInstances().Delete(ctx, *keyAlpha); err != nil {
t.Errorf("AlphaInstances().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.AlphaInstances().Delete(ctx, keyAlpha); err != nil {
t.Errorf("AlphaInstances().Delete(%v, %v) = %v; want nil", ctx, keyAlpha, err)
}
if err := mock.BetaInstances().Delete(ctx, *keyBeta); err != nil {
t.Errorf("BetaInstances().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.BetaInstances().Delete(ctx, keyBeta); err != nil {
t.Errorf("BetaInstances().Delete(%v, %v) = %v; want nil", ctx, keyBeta, err)
}
if err := mock.Instances().Delete(ctx, *keyGA); err != nil {
t.Errorf("Instances().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.Instances().Delete(ctx, keyGA); err != nil {
t.Errorf("Instances().Delete(%v, %v) = %v; want nil", ctx, keyGA, err)
}
// Delete not found.
if err := mock.AlphaInstances().Delete(ctx, *keyAlpha); err == nil {
t.Errorf("AlphaInstances().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.AlphaInstances().Delete(ctx, keyAlpha); err == nil {
t.Errorf("AlphaInstances().Delete(%v, %v) = nil; want error", ctx, keyAlpha)
}
if err := mock.BetaInstances().Delete(ctx, *keyBeta); err == nil {
t.Errorf("BetaInstances().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.BetaInstances().Delete(ctx, keyBeta); err == nil {
t.Errorf("BetaInstances().Delete(%v, %v) = nil; want error", ctx, keyBeta)
}
if err := mock.Instances().Delete(ctx, *keyGA); err == nil {
t.Errorf("Instances().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.Instances().Delete(ctx, keyGA); err == nil {
t.Errorf("Instances().Delete(%v, %v) = nil; want error", ctx, keyGA)
}
}
......@@ -1079,20 +1079,20 @@ func TestNetworkEndpointGroupsGroup(t *testing.T) {
_, _, _ = ctx, mock, key
// Get not found.
if _, err := mock.AlphaNetworkEndpointGroups().Get(ctx, *key); err == nil {
if _, err := mock.AlphaNetworkEndpointGroups().Get(ctx, key); err == nil {
t.Errorf("AlphaNetworkEndpointGroups().Get(%v, %v) = _, nil; want error", ctx, key)
}
// Insert.
{
obj := &alpha.NetworkEndpointGroup{}
if err := mock.AlphaNetworkEndpointGroups().Insert(ctx, *keyAlpha, obj); err != nil {
t.Errorf("AlphaNetworkEndpointGroups().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.AlphaNetworkEndpointGroups().Insert(ctx, keyAlpha, obj); err != nil {
t.Errorf("AlphaNetworkEndpointGroups().Insert(%v, %v, %v) = %v; want nil", ctx, keyAlpha, obj, err)
}
}
// Get across versions.
if obj, err := mock.AlphaNetworkEndpointGroups().Get(ctx, *key); err != nil {
if obj, err := mock.AlphaNetworkEndpointGroups().Get(ctx, key); err != nil {
t.Errorf("AlphaNetworkEndpointGroups().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
......@@ -1118,13 +1118,13 @@ func TestNetworkEndpointGroupsGroup(t *testing.T) {
}
// Delete across versions.
if err := mock.AlphaNetworkEndpointGroups().Delete(ctx, *keyAlpha); err != nil {
t.Errorf("AlphaNetworkEndpointGroups().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.AlphaNetworkEndpointGroups().Delete(ctx, keyAlpha); err != nil {
t.Errorf("AlphaNetworkEndpointGroups().Delete(%v, %v) = %v; want nil", ctx, keyAlpha, err)
}
// Delete not found.
if err := mock.AlphaNetworkEndpointGroups().Delete(ctx, *keyAlpha); err == nil {
t.Errorf("AlphaNetworkEndpointGroups().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.AlphaNetworkEndpointGroups().Delete(ctx, keyAlpha); err == nil {
t.Errorf("AlphaNetworkEndpointGroups().Delete(%v, %v) = nil; want error", ctx, keyAlpha)
}
}
......@@ -1167,31 +1167,47 @@ func TestRegionBackendServicesGroup(t *testing.T) {
var key *meta.Key
keyAlpha := meta.RegionalKey("key-alpha", "location")
key = keyAlpha
keyGA := meta.RegionalKey("key-ga", "location")
key = keyGA
// Ignore unused variables.
_, _, _ = ctx, mock, key
// Get not found.
if _, err := mock.AlphaRegionBackendServices().Get(ctx, *key); err == nil {
if _, err := mock.AlphaRegionBackendServices().Get(ctx, key); err == nil {
t.Errorf("AlphaRegionBackendServices().Get(%v, %v) = _, nil; want error", ctx, key)
}
if _, err := mock.RegionBackendServices().Get(ctx, key); err == nil {
t.Errorf("RegionBackendServices().Get(%v, %v) = _, nil; want error", ctx, key)
}
// Insert.
{
obj := &alpha.BackendService{}
if err := mock.AlphaRegionBackendServices().Insert(ctx, *keyAlpha, obj); err != nil {
t.Errorf("AlphaRegionBackendServices().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.AlphaRegionBackendServices().Insert(ctx, keyAlpha, obj); err != nil {
t.Errorf("AlphaRegionBackendServices().Insert(%v, %v, %v) = %v; want nil", ctx, keyAlpha, obj, err)
}
}
{
obj := &ga.BackendService{}
if err := mock.RegionBackendServices().Insert(ctx, keyGA, obj); err != nil {
t.Errorf("RegionBackendServices().Insert(%v, %v, %v) = %v; want nil", ctx, keyGA, obj, err)
}
}
// Get across versions.
if obj, err := mock.AlphaRegionBackendServices().Get(ctx, *key); err != nil {
if obj, err := mock.AlphaRegionBackendServices().Get(ctx, key); err != nil {
t.Errorf("AlphaRegionBackendServices().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
if obj, err := mock.RegionBackendServices().Get(ctx, key); err != nil {
t.Errorf("RegionBackendServices().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
// List.
mock.MockAlphaRegionBackendServices.Objects[*keyAlpha] = mock.MockAlphaRegionBackendServices.Obj(&alpha.BackendService{Name: keyAlpha.Name})
mock.MockRegionBackendServices.Objects[*keyGA] = mock.MockRegionBackendServices.Obj(&ga.BackendService{Name: keyGA.Name})
want := map[string]bool{
"key-alpha": true,
"key-ga": true,
}
_ = want // ignore unused variables.
{
......@@ -1208,15 +1224,35 @@ func TestRegionBackendServicesGroup(t *testing.T) {
}
}
}
{
objs, err := mock.RegionBackendServices().List(ctx, location, filter.None)
if err != nil {
t.Errorf("RegionBackendServices().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err)
} else {
got := map[string]bool{}
for _, obj := range objs {
got[obj.Name] = true
}
if !reflect.DeepEqual(got, want) {
t.Errorf("AlphaRegionBackendServices().List(); got %+v, want %+v", got, want)
}
}
}
// Delete across versions.
if err := mock.AlphaRegionBackendServices().Delete(ctx, *keyAlpha); err != nil {
t.Errorf("AlphaRegionBackendServices().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.AlphaRegionBackendServices().Delete(ctx, keyAlpha); err != nil {
t.Errorf("AlphaRegionBackendServices().Delete(%v, %v) = %v; want nil", ctx, keyAlpha, err)
}
if err := mock.RegionBackendServices().Delete(ctx, keyGA); err != nil {
t.Errorf("RegionBackendServices().Delete(%v, %v) = %v; want nil", ctx, keyGA, err)
}
// Delete not found.
if err := mock.AlphaRegionBackendServices().Delete(ctx, *keyAlpha); err == nil {
t.Errorf("AlphaRegionBackendServices().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.AlphaRegionBackendServices().Delete(ctx, keyAlpha); err == nil {
t.Errorf("AlphaRegionBackendServices().Delete(%v, %v) = nil; want error", ctx, keyAlpha)
}
if err := mock.RegionBackendServices().Delete(ctx, keyGA); err == nil {
t.Errorf("RegionBackendServices().Delete(%v, %v) = nil; want error", ctx, keyGA)
}
}
......@@ -1233,20 +1269,20 @@ func TestRegionDisksGroup(t *testing.T) {
_, _, _ = ctx, mock, key
// Get not found.
if _, err := mock.AlphaRegionDisks().Get(ctx, *key); err == nil {
if _, err := mock.AlphaRegionDisks().Get(ctx, key); err == nil {
t.Errorf("AlphaRegionDisks().Get(%v, %v) = _, nil; want error", ctx, key)
}
// Insert.
{
obj := &alpha.Disk{}
if err := mock.AlphaRegionDisks().Insert(ctx, *keyAlpha, obj); err != nil {
t.Errorf("AlphaRegionDisks().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.AlphaRegionDisks().Insert(ctx, keyAlpha, obj); err != nil {
t.Errorf("AlphaRegionDisks().Insert(%v, %v, %v) = %v; want nil", ctx, keyAlpha, obj, err)
}
}
// Get across versions.
if obj, err := mock.AlphaRegionDisks().Get(ctx, *key); err != nil {
if obj, err := mock.AlphaRegionDisks().Get(ctx, key); err != nil {
t.Errorf("AlphaRegionDisks().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
......@@ -1272,13 +1308,13 @@ func TestRegionDisksGroup(t *testing.T) {
}
// Delete across versions.
if err := mock.AlphaRegionDisks().Delete(ctx, *keyAlpha); err != nil {
t.Errorf("AlphaRegionDisks().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.AlphaRegionDisks().Delete(ctx, keyAlpha); err != nil {
t.Errorf("AlphaRegionDisks().Delete(%v, %v) = %v; want nil", ctx, keyAlpha, err)
}
// Delete not found.
if err := mock.AlphaRegionDisks().Delete(ctx, *keyAlpha); err == nil {
t.Errorf("AlphaRegionDisks().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.AlphaRegionDisks().Delete(ctx, keyAlpha); err == nil {
t.Errorf("AlphaRegionDisks().Delete(%v, %v) = nil; want error", ctx, keyAlpha)
}
}
......@@ -1295,7 +1331,7 @@ func TestRegionsGroup(t *testing.T) {
_, _, _ = ctx, mock, key
// Get not found.
if _, err := mock.Regions().Get(ctx, *key); err == nil {
if _, err := mock.Regions().Get(ctx, key); err == nil {
t.Errorf("Regions().Get(%v, %v) = _, nil; want error", ctx, key)
}
......@@ -1342,20 +1378,20 @@ func TestRoutesGroup(t *testing.T) {
_, _, _ = ctx, mock, key
// Get not found.
if _, err := mock.Routes().Get(ctx, *key); err == nil {
if _, err := mock.Routes().Get(ctx, key); err == nil {
t.Errorf("Routes().Get(%v, %v) = _, nil; want error", ctx, key)
}
// Insert.
{
obj := &ga.Route{}
if err := mock.Routes().Insert(ctx, *keyGA, obj); err != nil {
t.Errorf("Routes().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.Routes().Insert(ctx, keyGA, obj); err != nil {
t.Errorf("Routes().Insert(%v, %v, %v) = %v; want nil", ctx, keyGA, obj, err)
}
}
// Get across versions.
if obj, err := mock.Routes().Get(ctx, *key); err != nil {
if obj, err := mock.Routes().Get(ctx, key); err != nil {
t.Errorf("Routes().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
......@@ -1381,13 +1417,13 @@ func TestRoutesGroup(t *testing.T) {
}
// Delete across versions.
if err := mock.Routes().Delete(ctx, *keyGA); err != nil {
t.Errorf("Routes().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.Routes().Delete(ctx, keyGA); err != nil {
t.Errorf("Routes().Delete(%v, %v) = %v; want nil", ctx, keyGA, err)
}
// Delete not found.
if err := mock.Routes().Delete(ctx, *keyGA); err == nil {
t.Errorf("Routes().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.Routes().Delete(ctx, keyGA); err == nil {
t.Errorf("Routes().Delete(%v, %v) = nil; want error", ctx, keyGA)
}
}
......@@ -1404,20 +1440,20 @@ func TestSslCertificatesGroup(t *testing.T) {
_, _, _ = ctx, mock, key
// Get not found.
if _, err := mock.SslCertificates().Get(ctx, *key); err == nil {
if _, err := mock.SslCertificates().Get(ctx, key); err == nil {
t.Errorf("SslCertificates().Get(%v, %v) = _, nil; want error", ctx, key)
}
// Insert.
{
obj := &ga.SslCertificate{}
if err := mock.SslCertificates().Insert(ctx, *keyGA, obj); err != nil {
t.Errorf("SslCertificates().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.SslCertificates().Insert(ctx, keyGA, obj); err != nil {
t.Errorf("SslCertificates().Insert(%v, %v, %v) = %v; want nil", ctx, keyGA, obj, err)
}
}
// Get across versions.
if obj, err := mock.SslCertificates().Get(ctx, *key); err != nil {
if obj, err := mock.SslCertificates().Get(ctx, key); err != nil {
t.Errorf("SslCertificates().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
......@@ -1443,13 +1479,13 @@ func TestSslCertificatesGroup(t *testing.T) {
}
// Delete across versions.
if err := mock.SslCertificates().Delete(ctx, *keyGA); err != nil {
t.Errorf("SslCertificates().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.SslCertificates().Delete(ctx, keyGA); err != nil {
t.Errorf("SslCertificates().Delete(%v, %v) = %v; want nil", ctx, keyGA, err)
}
// Delete not found.
if err := mock.SslCertificates().Delete(ctx, *keyGA); err == nil {
t.Errorf("SslCertificates().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.SslCertificates().Delete(ctx, keyGA); err == nil {
t.Errorf("SslCertificates().Delete(%v, %v) = nil; want error", ctx, keyGA)
}
}
......@@ -1466,20 +1502,20 @@ func TestTargetHttpProxiesGroup(t *testing.T) {
_, _, _ = ctx, mock, key
// Get not found.
if _, err := mock.TargetHttpProxies().Get(ctx, *key); err == nil {
if _, err := mock.TargetHttpProxies().Get(ctx, key); err == nil {
t.Errorf("TargetHttpProxies().Get(%v, %v) = _, nil; want error", ctx, key)
}
// Insert.
{
obj := &ga.TargetHttpProxy{}
if err := mock.TargetHttpProxies().Insert(ctx, *keyGA, obj); err != nil {
t.Errorf("TargetHttpProxies().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.TargetHttpProxies().Insert(ctx, keyGA, obj); err != nil {
t.Errorf("TargetHttpProxies().Insert(%v, %v, %v) = %v; want nil", ctx, keyGA, obj, err)
}
}
// Get across versions.
if obj, err := mock.TargetHttpProxies().Get(ctx, *key); err != nil {
if obj, err := mock.TargetHttpProxies().Get(ctx, key); err != nil {
t.Errorf("TargetHttpProxies().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
......@@ -1505,13 +1541,13 @@ func TestTargetHttpProxiesGroup(t *testing.T) {
}
// Delete across versions.
if err := mock.TargetHttpProxies().Delete(ctx, *keyGA); err != nil {
t.Errorf("TargetHttpProxies().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.TargetHttpProxies().Delete(ctx, keyGA); err != nil {
t.Errorf("TargetHttpProxies().Delete(%v, %v) = %v; want nil", ctx, keyGA, err)
}
// Delete not found.
if err := mock.TargetHttpProxies().Delete(ctx, *keyGA); err == nil {
t.Errorf("TargetHttpProxies().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.TargetHttpProxies().Delete(ctx, keyGA); err == nil {
t.Errorf("TargetHttpProxies().Delete(%v, %v) = nil; want error", ctx, keyGA)
}
}
......@@ -1528,20 +1564,20 @@ func TestTargetHttpsProxiesGroup(t *testing.T) {
_, _, _ = ctx, mock, key
// Get not found.
if _, err := mock.TargetHttpsProxies().Get(ctx, *key); err == nil {
if _, err := mock.TargetHttpsProxies().Get(ctx, key); err == nil {
t.Errorf("TargetHttpsProxies().Get(%v, %v) = _, nil; want error", ctx, key)
}
// Insert.
{
obj := &ga.TargetHttpsProxy{}
if err := mock.TargetHttpsProxies().Insert(ctx, *keyGA, obj); err != nil {
t.Errorf("TargetHttpsProxies().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.TargetHttpsProxies().Insert(ctx, keyGA, obj); err != nil {
t.Errorf("TargetHttpsProxies().Insert(%v, %v, %v) = %v; want nil", ctx, keyGA, obj, err)
}
}
// Get across versions.
if obj, err := mock.TargetHttpsProxies().Get(ctx, *key); err != nil {
if obj, err := mock.TargetHttpsProxies().Get(ctx, key); err != nil {
t.Errorf("TargetHttpsProxies().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
......@@ -1567,13 +1603,13 @@ func TestTargetHttpsProxiesGroup(t *testing.T) {
}
// Delete across versions.
if err := mock.TargetHttpsProxies().Delete(ctx, *keyGA); err != nil {
t.Errorf("TargetHttpsProxies().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.TargetHttpsProxies().Delete(ctx, keyGA); err != nil {
t.Errorf("TargetHttpsProxies().Delete(%v, %v) = %v; want nil", ctx, keyGA, err)
}
// Delete not found.
if err := mock.TargetHttpsProxies().Delete(ctx, *keyGA); err == nil {
t.Errorf("TargetHttpsProxies().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.TargetHttpsProxies().Delete(ctx, keyGA); err == nil {
t.Errorf("TargetHttpsProxies().Delete(%v, %v) = nil; want error", ctx, keyGA)
}
}
......@@ -1590,20 +1626,20 @@ func TestTargetPoolsGroup(t *testing.T) {
_, _, _ = ctx, mock, key
// Get not found.
if _, err := mock.TargetPools().Get(ctx, *key); err == nil {
if _, err := mock.TargetPools().Get(ctx, key); err == nil {
t.Errorf("TargetPools().Get(%v, %v) = _, nil; want error", ctx, key)
}
// Insert.
{
obj := &ga.TargetPool{}
if err := mock.TargetPools().Insert(ctx, *keyGA, obj); err != nil {
t.Errorf("TargetPools().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.TargetPools().Insert(ctx, keyGA, obj); err != nil {
t.Errorf("TargetPools().Insert(%v, %v, %v) = %v; want nil", ctx, keyGA, obj, err)
}
}
// Get across versions.
if obj, err := mock.TargetPools().Get(ctx, *key); err != nil {
if obj, err := mock.TargetPools().Get(ctx, key); err != nil {
t.Errorf("TargetPools().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
......@@ -1629,13 +1665,13 @@ func TestTargetPoolsGroup(t *testing.T) {
}
// Delete across versions.
if err := mock.TargetPools().Delete(ctx, *keyGA); err != nil {
t.Errorf("TargetPools().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.TargetPools().Delete(ctx, keyGA); err != nil {
t.Errorf("TargetPools().Delete(%v, %v) = %v; want nil", ctx, keyGA, err)
}
// Delete not found.
if err := mock.TargetPools().Delete(ctx, *keyGA); err == nil {
t.Errorf("TargetPools().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.TargetPools().Delete(ctx, keyGA); err == nil {
t.Errorf("TargetPools().Delete(%v, %v) = nil; want error", ctx, keyGA)
}
}
......@@ -1652,20 +1688,20 @@ func TestUrlMapsGroup(t *testing.T) {
_, _, _ = ctx, mock, key
// Get not found.
if _, err := mock.UrlMaps().Get(ctx, *key); err == nil {
if _, err := mock.UrlMaps().Get(ctx, key); err == nil {
t.Errorf("UrlMaps().Get(%v, %v) = _, nil; want error", ctx, key)
}
// Insert.
{
obj := &ga.UrlMap{}
if err := mock.UrlMaps().Insert(ctx, *keyGA, obj); err != nil {
t.Errorf("UrlMaps().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
if err := mock.UrlMaps().Insert(ctx, keyGA, obj); err != nil {
t.Errorf("UrlMaps().Insert(%v, %v, %v) = %v; want nil", ctx, keyGA, obj, err)
}
}
// Get across versions.
if obj, err := mock.UrlMaps().Get(ctx, *key); err != nil {
if obj, err := mock.UrlMaps().Get(ctx, key); err != nil {
t.Errorf("UrlMaps().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
......@@ -1691,13 +1727,13 @@ func TestUrlMapsGroup(t *testing.T) {
}
// Delete across versions.
if err := mock.UrlMaps().Delete(ctx, *keyGA); err != nil {
t.Errorf("UrlMaps().Delete(%v, %v) = %v; want nil", ctx, key, err)
if err := mock.UrlMaps().Delete(ctx, keyGA); err != nil {
t.Errorf("UrlMaps().Delete(%v, %v) = %v; want nil", ctx, keyGA, err)
}
// Delete not found.
if err := mock.UrlMaps().Delete(ctx, *keyGA); err == nil {
t.Errorf("UrlMaps().Delete(%v, %v) = nil; want error", ctx, key)
if err := mock.UrlMaps().Delete(ctx, keyGA); err == nil {
t.Errorf("UrlMaps().Delete(%v, %v) = nil; want error", ctx, keyGA)
}
}
......@@ -1714,7 +1750,7 @@ func TestZonesGroup(t *testing.T) {
_, _, _ = ctx, mock, key
// Get not found.
if _, err := mock.Zones().Get(ctx, *key); err == nil {
if _, err := mock.Zones().Get(ctx, key); err == nil {
t.Errorf("Zones().Get(%v, %v) = _, nil; want error", ctx, key)
}
......
pkg/cloudprovider/providers/gce/cloud/meta/BUILD
View file @ fa094e66
......@@ -12,7 +12,6 @@ go_library(
importpath = "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta",
visibility = ["//visibility:public"],
deps = [
"//vendor/github.com/golang/glog:go_default_library",
"//vendor/google.golang.org/api/compute/v0.alpha:go_default_library",
"//vendor/google.golang.org/api/compute/v0.beta:go_default_library",
"//vendor/google.golang.org/api/compute/v1:go_default_library",
......
pkg/cloudprovider/providers/gce/cloud/meta/meta.go
View file @ fa094e66
......@@ -119,6 +119,18 @@ var AllServices = []*ServiceInfo{
Object: "BackendService",
Service: "RegionBackendServices",
Resource: "backendServices",
version: VersionGA,
keyType: Regional,
serviceType: reflect.TypeOf(&ga.RegionBackendServicesService{}),
additionalMethods: []string{
"GetHealth",
"Update",
},
},
{
Object: "BackendService",
Service: "RegionBackendServices",
Resource: "backendServices",
version: VersionAlpha,
keyType: Regional,
serviceType: reflect.TypeOf(&alpha.RegionBackendServicesService{}),
......@@ -285,6 +297,7 @@ var AllServices = []*ServiceInfo{
additionalMethods: []string{
"AttachNetworkEndpoints",
"DetachNetworkEndpoints",
"ListNetworkEndpoints",
},
options: AggregatedList,
},
......
pkg/cloudprovider/providers/gce/cloud/meta/method.go
View file @ fa094e66
......@@ -20,8 +20,6 @@ import (
"fmt"
"reflect"
"strings"
"github.com/golang/glog"
)
func newArg(t reflect.Type) *arg {
......@@ -86,23 +84,60 @@ func (a *arg) String() string {
// newMethod returns a newly initialized method.
func newMethod(s *ServiceInfo, m reflect.Method) *Method {
ret := &Method{s, m, ""}
ret := &Method{
ServiceInfo: s,
m: m,
kind: MethodOperation,
ReturnType: "",
}
ret.init()
return ret
}
// MethodKind is the type of method that we are generated code for.
type MethodKind int
const (
// MethodOperation is a long running method that returns an operation.
MethodOperation MethodKind = iota
// MethodGet is a method that immediately returns some data.
MethodGet MethodKind = iota
// MethodPaged is a method that returns a paged set of data.
MethodPaged MethodKind = iota
)
// Method is used to generate the calling code for non-standard methods.
type Method struct {
*ServiceInfo
m reflect.Method
kind MethodKind
// ReturnType is the return type for the method.
ReturnType string
// ItemType is the type of the individual elements returns from a
// Pages() call. This is only applicable for MethodPaged kind.
ItemType string
}
// IsOperation is true if the method is an Operation.
func (m *Method) IsOperation() bool {
return m.kind == MethodOperation
}
// IsPaged is true if the method paged.
func (m *Method) IsPaged() bool {
return m.kind == MethodPaged
}
// IsGet is true if the method simple get.
func (m *Method) IsGet() bool {
return m.kind == MethodGet
}
// argsSkip is the number of arguments to skip when generating the
// synthesized method.
func (mr *Method) argsSkip() int {
switch mr.keyType {
func (m *Method) argsSkip() int {
switch m.keyType {
case Zonal:
return 4
case Regional:
......@@ -110,15 +145,15 @@ func (mr *Method) argsSkip() int {
case Global:
return 3
}
panic(fmt.Errorf("invalid KeyType %v", mr.keyType))
panic(fmt.Errorf("invalid KeyType %v", m.keyType))
}
// args return a list of arguments to the method, skipping the first skip
// elements. If nameArgs is true, then the arguments will include a generated
// parameter name (arg<N>). prefix will be added to the parameters.
func (mr *Method) args(skip int, nameArgs bool, prefix []string) []string {
func (m *Method) args(skip int, nameArgs bool, prefix []string) []string {
var args []*arg
fType := mr.m.Func.Type()
fType := m.m.Func.Type()
for i := 0; i < fType.NumIn(); i++ {
t := fType.In(i)
args = append(args, newArg(t))
......@@ -135,24 +170,26 @@ func (mr *Method) args(skip int, nameArgs bool, prefix []string) []string {
return append(prefix, a...)
}
// init the method, preforming some rudimentary static checking.
func (mr *Method) init() {
fType := mr.m.Func.Type()
if fType.NumIn() < mr.argsSkip() {
// init the method. This performs some rudimentary static checking as well as
// determines the kind of method by looking at the shape (method signature) of
// the object.
func (m *Method) init() {
fType := m.m.Func.Type()
if fType.NumIn() < m.argsSkip() {
err := fmt.Errorf("method %q.%q, arity = %d which is less than required (< %d)",
mr.Service, mr.Name(), fType.NumIn(), mr.argsSkip())
m.Service, m.Name(), fType.NumIn(), m.argsSkip())
panic(err)
}
// Skipped args should all be string (they will be projectID, zone, region etc).
for i := 1; i < mr.argsSkip(); i++ {
for i := 1; i < m.argsSkip(); i++ {
if fType.In(i).Kind() != reflect.String {
panic(fmt.Errorf("method %q.%q: skipped args can only be strings", mr.Service, mr.Name()))
panic(fmt.Errorf("method %q.%q: skipped args can only be strings", m.Service, m.Name()))
}
}
// Return of the method must return a single value of type *xxxCall.
if fType.NumOut() != 1 || fType.Out(0).Kind() != reflect.Ptr || !strings.HasSuffix(fType.Out(0).Elem().Name(), "Call") {
panic(fmt.Errorf("method %q.%q: generator only supports methods returning an *xxxCall object",
mr.Service, mr.Name()))
m.Service, m.Name()))
}
returnType := fType.Out(0)
returnTypeName := fType.Out(0).Elem().Name()
......@@ -160,48 +197,64 @@ func (mr *Method) init() {
doMethod, ok := returnType.MethodByName("Do")
if !ok {
panic(fmt.Errorf("method %q.%q: return type %q does not have a Do() method",
mr.Service, mr.Name(), returnTypeName))
m.Service, m.Name(), returnTypeName))
}
_, hasPages := returnType.MethodByName("Pages")
// Do() method must return (*T, error).
switch doMethod.Func.Type().NumOut() {
case 2:
glog.Infof("Method %q.%q: return type %q of Do() = %v, %v",
mr.Service, mr.Name(), returnTypeName, doMethod.Func.Type().Out(0), doMethod.Func.Type().Out(1))
out0 := doMethod.Func.Type().Out(0)
if out0.Kind() != reflect.Ptr {
panic(fmt.Errorf("method %q.%q: return type %q of Do() = S, _; S must be pointer type (%v)",
mr.Service, mr.Name(), returnTypeName, out0))
m.Service, m.Name(), returnTypeName, out0))
}
mr.ReturnType = out0.Elem().Name()
if out0.Elem().Name() == "Operation" {
glog.Infof("Method %q.%q is an *Operation", mr.Service, mr.Name())
} else {
glog.Infof("Method %q.%q returns %v", mr.Service, mr.Name(), out0)
m.ReturnType = out0.Elem().Name()
switch {
case out0.Elem().Name() == "Operation":
m.kind = MethodOperation
case hasPages:
m.kind = MethodPaged
// Pages() returns a xxxList that has the actual list
// of objects in the xxxList.Items field.
listType := out0.Elem()
itemsField, ok := listType.FieldByName("Items")
if !ok {
panic(fmt.Errorf("method %q.%q: paged return type %q does not have a .Items field", m.Service, m.Name(), listType.Name()))
}
// itemsField will be a []*ItemType. Dereference to
// extract the ItemType.
itemsType := itemsField.Type
if itemsType.Kind() != reflect.Slice && itemsType.Elem().Kind() != reflect.Ptr {
panic(fmt.Errorf("method %q.%q: paged return type %q.Items is not an array of pointers", m.Service, m.Name(), listType.Name()))
}
m.ItemType = itemsType.Elem().Elem().Name()
default:
m.kind = MethodGet
}
// Second argument must be "error".
if doMethod.Func.Type().Out(1).Name() != "error" {
panic(fmt.Errorf("method %q.%q: return type %q of Do() = S, T; T must be 'error'",
mr.Service, mr.Name(), returnTypeName))
m.Service, m.Name(), returnTypeName))
}
break
default:
panic(fmt.Errorf("method %q.%q: %q Do() return type is not handled by the generator",
mr.Service, mr.Name(), returnTypeName))
m.Service, m.Name(), returnTypeName))
}
}
// Name is the name of the method.
func (mr *Method) Name() string {
return mr.m.Name
func (m *Method) Name() string {
return m.m.Name
}
// CallArgs is a list of comma separated "argN" used for calling the method.
// For example, if the method has two additional arguments, this will return
// "arg0, arg1".
func (mr *Method) CallArgs() string {
func (m *Method) CallArgs() string {
var args []string
for i := mr.argsSkip(); i < mr.m.Func.Type().NumIn(); i++ {
args = append(args, fmt.Sprintf("arg%d", i-mr.argsSkip()))
for i := m.argsSkip(); i < m.m.Func.Type().NumIn(); i++ {
args = append(args, fmt.Sprintf("arg%d", i-m.argsSkip()))
}
if len(args) == 0 {
return ""
......@@ -210,41 +263,74 @@ func (mr *Method) CallArgs() string {
}
// MockHookName is the name of the hook function in the mock.
func (mr *Method) MockHookName() string {
return mr.m.Name + "Hook"
func (m *Method) MockHookName() string {
return m.m.Name + "Hook"
}
// MockHook is the definition of the hook function.
func (mr *Method) MockHook() string {
args := mr.args(mr.argsSkip(), false, []string{
fmt.Sprintf("*%s", mr.MockWrapType()),
func (m *Method) MockHook() string {
args := m.args(m.argsSkip(), false, []string{
fmt.Sprintf("*%s", m.MockWrapType()),
"context.Context",
"meta.Key",
"*meta.Key",
})
if mr.ReturnType == "Operation" {
return fmt.Sprintf("%v func(%v) error", mr.MockHookName(), strings.Join(args, ", "))
if m.kind == MethodPaged {
args = append(args, "*filter.F")
}
switch m.kind {
case MethodOperation:
return fmt.Sprintf("%v func(%v) error", m.MockHookName(), strings.Join(args, ", "))
case MethodGet:
return fmt.Sprintf("%v func(%v) (*%v.%v, error)", m.MockHookName(), strings.Join(args, ", "), m.Version(), m.ReturnType)
case MethodPaged:
return fmt.Sprintf("%v func(%v) ([]*%v.%v, error)", m.MockHookName(), strings.Join(args, ", "), m.Version(), m.ItemType)
default:
panic(fmt.Errorf("invalid method kind: %v", m.kind))
}
return fmt.Sprintf("%v func(%v) (*%v.%v, error)", mr.MockHookName(), strings.Join(args, ", "), mr.Version(), mr.ReturnType)
}
// FcnArgs is the function signature for the definition of the method.
func (mr *Method) FcnArgs() string {
args := mr.args(mr.argsSkip(), true, []string{
func (m *Method) FcnArgs() string {
args := m.args(m.argsSkip(), true, []string{
"ctx context.Context",
"key meta.Key",
"key *meta.Key",
})
if m.kind == MethodPaged {
args = append(args, "fl *filter.F")
}
if mr.ReturnType == "Operation" {
return fmt.Sprintf("%v(%v) error", mr.m.Name, strings.Join(args, ", "))
switch m.kind {
case MethodOperation:
return fmt.Sprintf("%v(%v) error", m.m.Name, strings.Join(args, ", "))
case MethodGet:
return fmt.Sprintf("%v(%v) (*%v.%v, error)", m.m.Name, strings.Join(args, ", "), m.Version(), m.ReturnType)
case MethodPaged:
return fmt.Sprintf("%v(%v) ([]*%v.%v, error)", m.m.Name, strings.Join(args, ", "), m.Version(), m.ItemType)
default:
panic(fmt.Errorf("invalid method kind: %v", m.kind))
}
return fmt.Sprintf("%v(%v) (*%v.%v, error)", mr.m.Name, strings.Join(args, ", "), mr.Version(), mr.ReturnType)
}
// InterfaceFunc is the function declaration of the method in the interface.
func (mr *Method) InterfaceFunc() string {
args := mr.args(mr.argsSkip(), false, []string{"context.Context", "meta.Key"})
if mr.ReturnType == "Operation" {
return fmt.Sprintf("%v(%v) error", mr.m.Name, strings.Join(args, ", "))
func (m *Method) InterfaceFunc() string {
args := []string{
"context.Context",
"*meta.Key",
}
args = m.args(m.argsSkip(), false, args)
if m.kind == MethodPaged {
args = append(args, "*filter.F")
}
switch m.kind {
case MethodOperation:
return fmt.Sprintf("%v(%v) error", m.m.Name, strings.Join(args, ", "))
case MethodGet:
return fmt.Sprintf("%v(%v) (*%v.%v, error)", m.m.Name, strings.Join(args, ", "), m.Version(), m.ReturnType)
case MethodPaged:
return fmt.Sprintf("%v(%v) ([]*%v.%v, error)", m.m.Name, strings.Join(args, ", "), m.Version(), m.ItemType)
default:
panic(fmt.Errorf("invalid method kind: %v", m.kind))
}
return fmt.Sprintf("%v(%v) (*%v.%v, error)", mr.m.Name, strings.Join(args, ", "), mr.Version(), mr.ReturnType)
}
pkg/cloudprovider/providers/gce/cloud/mock_test.go
View file @ fa094e66
......@@ -45,42 +45,42 @@ func TestMocks(t *testing.T) {
key := keyAlpha
// Get not found.
if _, err := mock.AlphaAddresses().Get(ctx, *key); err == nil {
if _, err := mock.AlphaAddresses().Get(ctx, key); err == nil {
t.Errorf("AlphaAddresses().Get(%v, %v) = _, nil; want error", ctx, key)
}
if _, err := mock.BetaAddresses().Get(ctx, *key); err == nil {
if _, err := mock.BetaAddresses().Get(ctx, key); err == nil {
t.Errorf("BetaAddresses().Get(%v, %v) = _, nil; want error", ctx, key)
}
if _, err := mock.Addresses().Get(ctx, *key); err == nil {
if _, err := mock.Addresses().Get(ctx, key); err == nil {
t.Errorf("Addresses().Get(%v, %v) = _, nil; want error", ctx, key)
}
// Insert.
{
obj := &alpha.Address{}
if err := mock.AlphaAddresses().Insert(ctx, *keyAlpha, obj); err != nil {
if err := mock.AlphaAddresses().Insert(ctx, keyAlpha, obj); err != nil {
t.Errorf("AlphaAddresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
}
}
{
obj := &beta.Address{}
if err := mock.BetaAddresses().Insert(ctx, *keyBeta, obj); err != nil {
if err := mock.BetaAddresses().Insert(ctx, keyBeta, obj); err != nil {
t.Errorf("BetaAddresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
}
}
{
obj := &ga.Address{}
if err := mock.Addresses().Insert(ctx, *keyGA, &ga.Address{Name: "ga"}); err != nil {
if err := mock.Addresses().Insert(ctx, keyGA, &ga.Address{Name: "ga"}); err != nil {
t.Errorf("Addresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err)
}
}
// Get across versions.
if obj, err := mock.AlphaAddresses().Get(ctx, *key); err != nil {
if obj, err := mock.AlphaAddresses().Get(ctx, key); err != nil {
t.Errorf("AlphaAddresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
if obj, err := mock.BetaAddresses().Get(ctx, *key); err != nil {
if obj, err := mock.BetaAddresses().Get(ctx, key); err != nil {
t.Errorf("BetaAddresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
if obj, err := mock.Addresses().Get(ctx, *key); err != nil {
if obj, err := mock.Addresses().Get(ctx, key); err != nil {
t.Errorf("Addresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err)
}
// List across versions.
......@@ -128,23 +128,23 @@ func TestMocks(t *testing.T) {
}
}
// Delete across versions.
if err := mock.AlphaAddresses().Delete(ctx, *keyAlpha); err != nil {
if err := mock.AlphaAddresses().Delete(ctx, keyAlpha); err != nil {
t.Errorf("AlphaAddresses().Delete(%v, %v) = %v; want nil", ctx, key, err)
}
if err := mock.BetaAddresses().Delete(ctx, *keyBeta); err != nil {
if err := mock.BetaAddresses().Delete(ctx, keyBeta); err != nil {
t.Errorf("BetaAddresses().Delete(%v, %v) = %v; want nil", ctx, key, err)
}
if err := mock.Addresses().Delete(ctx, *keyGA); err != nil {
if err := mock.Addresses().Delete(ctx, keyGA); err != nil {
t.Errorf("Addresses().Delete(%v, %v) = %v; want nil", ctx, key, err)
}
// Delete not found.
if err := mock.AlphaAddresses().Delete(ctx, *keyAlpha); err == nil {
if err := mock.AlphaAddresses().Delete(ctx, keyAlpha); err == nil {
t.Errorf("AlphaAddresses().Delete(%v, %v) = nil; want error", ctx, key)
}
if err := mock.BetaAddresses().Delete(ctx, *keyBeta); err == nil {
if err := mock.BetaAddresses().Delete(ctx, keyBeta); err == nil {
t.Errorf("BetaAddresses().Delete(%v, %v) = nil; want error", ctx, key)
}
if err := mock.Addresses().Delete(ctx, *keyGA); err == nil {
if err := mock.Addresses().Delete(ctx, keyGA); err == nil {
t.Errorf("Addresses().Delete(%v, %v) = nil; want error", ctx, key)
}
}
pkg/cloudprovider/providers/gce/cloud/utils.go
View file @ fa094e66
......@@ -142,7 +142,7 @@ func copyViaJSON(dest, src interface{}) error {
}
// SelfLink returns the self link URL for the given object.
func SelfLink(ver meta.Version, project, resource string, key meta.Key) string {
func SelfLink(ver meta.Version, project, resource string, key *meta.Key) string {
var prefix string
switch ver {
case meta.VersionAlpha:
......
pkg/cloudprovider/providers/gce/cloud/utils_test.go
View file @ fa094e66
......@@ -165,28 +165,28 @@ func TestSelfLink(t *testing.T) {
ver meta.Version
project string
resource string
key meta.Key
key *meta.Key
want string
}{
{
meta.VersionAlpha,
"proj1",
"addresses",
*meta.RegionalKey("key1", "us-central1"),
meta.RegionalKey("key1", "us-central1"),
"https://www.googleapis.com/compute/alpha/projects/proj1/regions/us-central1/addresses/key1",
},
{
meta.VersionBeta,
"proj3",
"disks",
*meta.ZonalKey("key2", "us-central1-b"),
meta.ZonalKey("key2", "us-central1-b"),
"https://www.googleapis.com/compute/beta/projects/proj3/zones/us-central1-b/disks/key2",
},
{
meta.VersionGA,
"proj4",
"urlMaps",
*meta.GlobalKey("key3"),
meta.GlobalKey("key3"),
"https://www.googleapis.com/compute/v1/projects/proj4/urlMaps/key3",
},
} {
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment