diff --git a/pkg/composite/gen.go b/pkg/composite/gen.go index 6563e58813..cf14701a88 100644 --- a/pkg/composite/gen.go +++ b/pkg/composite/gen.go @@ -501,6 +501,13 @@ type BackendServiceLogConfig struct { NullFields []string `json:"-"` } +// BackendServiceReference is a composite type wrapping the Alpha, Beta, and GA methods for its GCE equivalent +type BackendServiceReference struct { + BackendService string `json:"backendService,omitempty"` + ForceSendFields []string `json:"-"` + NullFields []string `json:"-"` +} + // CacheKeyPolicy is a composite type wrapping the Alpha, Beta, and GA methods for its GCE equivalent type CacheKeyPolicy struct { // If true, requests to different hosts will be cached separately. @@ -944,6 +951,13 @@ type ForwardingRule struct { NullFields []string `json:"-"` } +// ForwardingRuleReference is a composite type wrapping the Alpha, Beta, and GA methods for its GCE equivalent +type ForwardingRuleReference struct { + ForwardingRule string `json:"forwardingRule,omitempty"` + ForceSendFields []string `json:"-"` + NullFields []string `json:"-"` +} + // GrpcServiceConfig is a composite type wrapping the Alpha, Beta, and GA methods for its GCE equivalent type GrpcServiceConfig struct { // The call credentials to access the SDS server. @@ -1162,6 +1176,31 @@ type HealthCheck struct { NullFields []string `json:"-"` } +// HealthCheckReference is a composite type wrapping the Alpha, Beta, and GA methods for its GCE equivalent +type HealthCheckReference struct { + HealthCheck string `json:"healthCheck,omitempty"` + ForceSendFields []string `json:"-"` + NullFields []string `json:"-"` +} + +// HealthStatusForNetworkEndpoint is a composite type wrapping the Alpha, Beta, and GA methods for its GCE equivalent +type HealthStatusForNetworkEndpoint struct { + // URL of the backend service associated with the health state of the + // network endpoint. + BackendService *BackendServiceReference `json:"backendService,omitempty"` + // URL of the forwarding rule associated with the health state of the + // network endpoint. + ForwardingRule *ForwardingRuleReference `json:"forwardingRule,omitempty"` + // URL of the health check associated with the health state of the + // network endpoint. + HealthCheck *HealthCheckReference `json:"healthCheck,omitempty"` + // Health state of the network endpoint determined based on the health + // checks configured. + HealthState string `json:"healthState,omitempty"` + ForceSendFields []string `json:"-"` + NullFields []string `json:"-"` +} + // HostRule is a composite type wrapping the Alpha, Beta, and GA methods for its GCE equivalent type HostRule struct { // An optional description of this resource. Provide this property when @@ -1805,6 +1844,55 @@ type NetworkEndpointGroupsDetachEndpointsRequest struct { NullFields []string `json:"-"` } +// NetworkEndpointGroupsListEndpointsRequest is a composite type wrapping the Alpha, Beta, and GA methods for its GCE equivalent +type NetworkEndpointGroupsListEndpointsRequest struct { + // Version keeps track of the intended compute version for this NetworkEndpointGroupsListEndpointsRequest. + // Note that the compute API's do not contain this field. It is for our + // own bookkeeping purposes. + Version meta.Version `json:"-"` + // Scope keeps track of the intended type of the service (e.g. Global) + // This is also an internal field purely for bookkeeping purposes + Scope meta.KeyType `json:"-"` + + // Optional list of endpoints to query. This is a more efficient but + // also limited version of filter parameter. Endpoints in the filter + // must have ip_address and port fields populated, other fields are not + // supported. + EndpointFilters []*NetworkEndpointGroupsListEndpointsRequestNetworkEndpointFilter `json:"endpointFilters,omitempty"` + // Optional query parameter for showing the health status of each + // network endpoint. Valid options are SKIP or SHOW. If you don't + // specifiy this parameter, the health status of network endpoints will + // not be provided. + HealthStatus string `json:"healthStatus,omitempty"` + ForceSendFields []string `json:"-"` + NullFields []string `json:"-"` +} + +// NetworkEndpointGroupsListEndpointsRequestNetworkEndpointFilter is a composite type wrapping the Alpha, Beta, and GA methods for its GCE equivalent +type NetworkEndpointGroupsListEndpointsRequestNetworkEndpointFilter struct { + NetworkEndpoint *NetworkEndpoint `json:"networkEndpoint,omitempty"` + ForceSendFields []string `json:"-"` + NullFields []string `json:"-"` +} + +// NetworkEndpointWithHealthStatus is a composite type wrapping the Alpha, Beta, and GA methods for its GCE equivalent +type NetworkEndpointWithHealthStatus struct { + // Version keeps track of the intended compute version for this NetworkEndpointWithHealthStatus. + // Note that the compute API's do not contain this field. It is for our + // own bookkeeping purposes. + Version meta.Version `json:"-"` + // Scope keeps track of the intended type of the service (e.g. Global) + // This is also an internal field purely for bookkeeping purposes + Scope meta.KeyType `json:"-"` + + // [Output only] The health status of network endpoint; + Healths []*HealthStatusForNetworkEndpoint `json:"healths,omitempty"` + // [Output only] The network endpoint; + NetworkEndpoint *NetworkEndpoint `json:"networkEndpoint,omitempty"` + ForceSendFields []string `json:"-"` + NullFields []string `json:"-"` +} + // OriginAuthenticationMethod is a composite type wrapping the Alpha, Beta, and GA methods for its GCE equivalent type OriginAuthenticationMethod struct { Jwt *Jwt `json:"jwt,omitempty"` @@ -2790,7 +2878,7 @@ func GetBackendService(gceCloud *gce.Cloud, key *meta.Key, version meta.Version) func ListBackendServices(gceCloud *gce.Cloud, key *meta.Key, version meta.Version) ([]*BackendService, error) { ctx, cancel := cloudprovider.ContextWithCallTimeout() defer cancel() - mc := compositemetrics.NewMetricContext("BackendService", "get", key.Region, key.Zone, string(version)) + mc := compositemetrics.NewMetricContext("BackendService", "list", key.Region, key.Zone, string(version)) var gceObjs interface{} var err error @@ -3052,7 +3140,7 @@ func GetForwardingRule(gceCloud *gce.Cloud, key *meta.Key, version meta.Version) func ListForwardingRules(gceCloud *gce.Cloud, key *meta.Key, version meta.Version) ([]*ForwardingRule, error) { ctx, cancel := cloudprovider.ContextWithCallTimeout() defer cancel() - mc := compositemetrics.NewMetricContext("ForwardingRule", "get", key.Region, key.Zone, string(version)) + mc := compositemetrics.NewMetricContext("ForwardingRule", "list", key.Region, key.Zone, string(version)) var gceObjs interface{} var err error @@ -3318,7 +3406,7 @@ func GetHealthCheck(gceCloud *gce.Cloud, key *meta.Key, version meta.Version) (* func ListHealthChecks(gceCloud *gce.Cloud, key *meta.Key, version meta.Version) ([]*HealthCheck, error) { ctx, cancel := cloudprovider.ContextWithCallTimeout() defer cancel() - mc := compositemetrics.NewMetricContext("HealthCheck", "get", key.Region, key.Zone, string(version)) + mc := compositemetrics.NewMetricContext("HealthCheck", "list", key.Region, key.Zone, string(version)) var gceObjs interface{} var err error @@ -3516,7 +3604,7 @@ func GetNetworkEndpointGroup(gceCloud *gce.Cloud, key *meta.Key, version meta.Ve func ListNetworkEndpointGroups(gceCloud *gce.Cloud, key *meta.Key, version meta.Version) ([]*NetworkEndpointGroup, error) { ctx, cancel := cloudprovider.ContextWithCallTimeout() defer cancel() - mc := compositemetrics.NewMetricContext("NetworkEndpointGroup", "get", key.Region, key.Zone, string(version)) + mc := compositemetrics.NewMetricContext("NetworkEndpointGroup", "list", key.Region, key.Zone, string(version)) var gceObjs interface{} var err error @@ -3589,7 +3677,7 @@ func AttachNetworkEndpoints(gceCloud *gce.Cloud, key *meta.Key, version meta.Ver func DetachNetworkEndpoints(gceCloud *gce.Cloud, key *meta.Key, version meta.Version, req *NetworkEndpointGroupsDetachEndpointsRequest) error { ctx, cancel := cloudprovider.ContextWithCallTimeout() defer cancel() - mc := compositemetrics.NewMetricContext("NetworkEndpointGroup", "attach", key.Region, key.Zone, string(version)) + mc := compositemetrics.NewMetricContext("NetworkEndpointGroup", "detach", key.Region, key.Zone, string(version)) switch key.Type() { case meta.Zonal: @@ -3622,6 +3710,97 @@ func DetachNetworkEndpoints(gceCloud *gce.Cloud, key *meta.Key, version meta.Ver } } +func ListNetworkEndpoints(gceCloud *gce.Cloud, key *meta.Key, version meta.Version, req *NetworkEndpointGroupsListEndpointsRequest) ([]*NetworkEndpointWithHealthStatus, error) { + ctx, cancel := cloudprovider.ContextWithCallTimeout() + defer cancel() + mc := compositemetrics.NewMetricContext("NetworkEndpointGroup", "list", key.Region, key.Zone, string(version)) + + var gceObjs interface{} + var err error + + switch key.Type() { + case meta.Zonal: + default: + return nil, fmt.Errorf("Key %v not valid for zonal resource NetworkEndpointGroup %v", key, key.Name) + } + + switch version { + case meta.VersionAlpha: + alphareq, err := req.ToAlpha() + if err != nil { + return nil, err + } + klog.V(3).Infof("Listing alpha zonal NetworkEndpointGroup %v", key.Name) + gceObjs, err = gceCloud.Compute().AlphaNetworkEndpointGroups().ListNetworkEndpoints(ctx, key, alphareq, filter.None) + case meta.VersionBeta: + betareq, err := req.ToBeta() + if err != nil { + return nil, err + } + klog.V(3).Infof("Listing beta zonal NetworkEndpointGroup %v", key.Name) + gceObjs, err = gceCloud.Compute().BetaNetworkEndpointGroups().ListNetworkEndpoints(ctx, key, betareq, filter.None) + default: + gareq, err := req.ToGA() + if err != nil { + return nil, err + } + klog.V(3).Infof("Listing ga zonal NetworkEndpointGroup %v", key.Name) + gceObjs, err = gceCloud.Compute().NetworkEndpointGroups().ListNetworkEndpoints(ctx, key, gareq, filter.None) + } + if err != nil { + return nil, mc.Observe(err) + } + + compositeObjs, err := ToNetworkEndpointWithHealthStatusList(gceObjs) + if err != nil { + return nil, err + } + for _, obj := range compositeObjs { + obj.Version = version + } + return compositeObjs, nil +} + +func AggregatedListNetworkEndpointGroup(gceCloud *gce.Cloud, version meta.Version) (map[string][]*NetworkEndpointGroup, error) { + ctx, cancel := cloudprovider.ContextWithCallTimeout() + defer cancel() + mc := compositemetrics.NewMetricContext("NetworkEndpointGroup", "aggregateList", "", "", string(version)) + + var gceObjs interface{} + compositeMap := make(map[string][]*NetworkEndpointGroup) + var err error + + switch version { + case meta.VersionAlpha: + klog.V(3).Infof("Aggregate List of alpha zonal NetworkEndpointGroup") + gceObjs, err = gceCloud.Compute().AlphaNetworkEndpointGroups().AggregatedList(ctx, filter.None) + case meta.VersionBeta: + klog.V(3).Infof("Aggregate List of beta zonal NetworkEndpointGroup") + gceObjs, err = gceCloud.Compute().BetaNetworkEndpointGroups().AggregatedList(ctx, filter.None) + default: + klog.V(3).Infof("Aggregate List of ga zonal NetworkEndpointGroup") + gceObjs, err = gceCloud.Compute().NetworkEndpointGroups().AggregatedList(ctx, filter.None) + } + if err != nil { + return nil, mc.Observe(err) + } + gceMap, ok := gceObjs.(map[string]interface{}) + if !ok { + return nil, fmt.Errorf("Failed to convert gceObj to map[string]interface{}") + } + for keyStr, obj := range gceMap { + compositeObjs, err := ToNetworkEndpointGroupList(obj) + if err != nil { + return nil, err + } + for _, o := range compositeObjs { + o.Version = version + } + compositeMap[keyStr] = compositeObjs + } + return compositeMap, nil +} + // ToNetworkEndpointGroupList converts a list of compute alpha, beta or GA // NetworkEndpointGroup into a list of our composite type. func ToNetworkEndpointGroupList(objs interface{}) ([]*NetworkEndpointGroup, error) { @@ -3682,6 +3861,18 @@ func (networkEndpointGroup *NetworkEndpointGroup) ToGA() (*compute.NetworkEndpoi return ga, nil } +// ToNetworkEndpointGroupsAttachEndpointsRequestList converts a list of compute alpha, beta or GA +// NetworkEndpointGroupsAttachEndpointsRequest into a list of our composite type. +func ToNetworkEndpointGroupsAttachEndpointsRequestList(objs interface{}) ([]*NetworkEndpointGroupsAttachEndpointsRequest, error) { + result := []*NetworkEndpointGroupsAttachEndpointsRequest{} + + err := copyViaJSON(&result, objs) + if err != nil { + return nil, fmt.Errorf("could not copy object %v to %T via JSON: %v", objs, result, err) + } + return result, nil +} + // ToNetworkEndpointGroupsAttachEndpointsRequest converts a compute alpha, beta or GA // NetworkEndpointGroupsAttachEndpointsRequest into our composite type. func ToNetworkEndpointGroupsAttachEndpointsRequest(obj interface{}) (*NetworkEndpointGroupsAttachEndpointsRequest, error) { @@ -3730,6 +3921,18 @@ func (networkEndpointGroupsAttachEndpointsRequest *NetworkEndpointGroupsAttachEn return ga, nil } +// ToNetworkEndpointGroupsDetachEndpointsRequestList converts a list of compute alpha, beta or GA +// NetworkEndpointGroupsDetachEndpointsRequest into a list of our composite type. +func ToNetworkEndpointGroupsDetachEndpointsRequestList(objs interface{}) ([]*NetworkEndpointGroupsDetachEndpointsRequest, error) { + result := []*NetworkEndpointGroupsDetachEndpointsRequest{} + + err := copyViaJSON(&result, objs) + if err != nil { + return nil, fmt.Errorf("could not copy object %v to %T via JSON: %v", objs, result, err) + } + return result, nil +} + // ToNetworkEndpointGroupsDetachEndpointsRequest converts a compute alpha, beta or GA // NetworkEndpointGroupsDetachEndpointsRequest into our composite type. func ToNetworkEndpointGroupsDetachEndpointsRequest(obj interface{}) (*NetworkEndpointGroupsDetachEndpointsRequest, error) { @@ -3778,6 +3981,126 @@ func (networkEndpointGroupsDetachEndpointsRequest *NetworkEndpointGroupsDetachEn return ga, nil } +// ToNetworkEndpointGroupsListEndpointsRequestList converts a list of compute alpha, beta or GA +// NetworkEndpointGroupsListEndpointsRequest into a list of our composite type. +func ToNetworkEndpointGroupsListEndpointsRequestList(objs interface{}) ([]*NetworkEndpointGroupsListEndpointsRequest, error) { + result := []*NetworkEndpointGroupsListEndpointsRequest{} + + err := copyViaJSON(&result, objs) + if err != nil { + return nil, fmt.Errorf("could not copy object %v to %T via JSON: %v", objs, result, err) + } + return result, nil +} + +// ToNetworkEndpointGroupsListEndpointsRequest converts a compute alpha, beta or GA +// NetworkEndpointGroupsListEndpointsRequest into our composite type. +func ToNetworkEndpointGroupsListEndpointsRequest(obj interface{}) (*NetworkEndpointGroupsListEndpointsRequest, error) { + networkEndpointGroupsListEndpointsRequest := &NetworkEndpointGroupsListEndpointsRequest{} + err := copyViaJSON(networkEndpointGroupsListEndpointsRequest, obj) + if err != nil { + return nil, fmt.Errorf("could not copy object %+v to %T via JSON: %v", obj, networkEndpointGroupsListEndpointsRequest, err) + } + + return networkEndpointGroupsListEndpointsRequest, nil +} + +// ToAlpha converts our composite type into an alpha type. +// This alpha type can be used in GCE API calls. +func (networkEndpointGroupsListEndpointsRequest *NetworkEndpointGroupsListEndpointsRequest) ToAlpha() (*computealpha.NetworkEndpointGroupsListEndpointsRequest, error) { + alpha := &computealpha.NetworkEndpointGroupsListEndpointsRequest{} + err := copyViaJSON(alpha, networkEndpointGroupsListEndpointsRequest) + if err != nil { + return nil, fmt.Errorf("error converting %T to compute alpha type via JSON: %v", networkEndpointGroupsListEndpointsRequest, err) + } + + return alpha, nil +} + +// ToBeta converts our composite type into an beta type. +// This beta type can be used in GCE API calls. +func (networkEndpointGroupsListEndpointsRequest *NetworkEndpointGroupsListEndpointsRequest) ToBeta() (*computebeta.NetworkEndpointGroupsListEndpointsRequest, error) { + beta := &computebeta.NetworkEndpointGroupsListEndpointsRequest{} + err := copyViaJSON(beta, networkEndpointGroupsListEndpointsRequest) + if err != nil { + return nil, fmt.Errorf("error converting %T to compute beta type via JSON: %v", networkEndpointGroupsListEndpointsRequest, err) + } + + return beta, nil +} + +// ToGA converts our composite type into an ga type. +// This ga type can be used in GCE API calls. +func (networkEndpointGroupsListEndpointsRequest *NetworkEndpointGroupsListEndpointsRequest) ToGA() (*compute.NetworkEndpointGroupsListEndpointsRequest, error) { + ga := &compute.NetworkEndpointGroupsListEndpointsRequest{} + err := copyViaJSON(ga, networkEndpointGroupsListEndpointsRequest) + if err != nil { + return nil, fmt.Errorf("error converting %T to compute ga type via JSON: %v", networkEndpointGroupsListEndpointsRequest, err) + } + + return ga, nil +} + +// ToNetworkEndpointWithHealthStatusList converts a list of compute alpha, beta or GA +// NetworkEndpointWithHealthStatus into a list of our composite type. +func ToNetworkEndpointWithHealthStatusList(objs interface{}) ([]*NetworkEndpointWithHealthStatus, error) { + result := []*NetworkEndpointWithHealthStatus{} + + err := copyViaJSON(&result, objs) + if err != nil { + return nil, fmt.Errorf("could not copy object %v to %T via JSON: %v", objs, result, err) + } + return result, nil +} + +// ToNetworkEndpointWithHealthStatus converts a compute alpha, beta or GA +// NetworkEndpointWithHealthStatus into our composite type. +func ToNetworkEndpointWithHealthStatus(obj interface{}) (*NetworkEndpointWithHealthStatus, error) { + networkEndpointWithHealthStatus := &NetworkEndpointWithHealthStatus{} + err := copyViaJSON(networkEndpointWithHealthStatus, obj) + if err != nil { + return nil, fmt.Errorf("could not copy object %+v to %T via JSON: %v", obj, networkEndpointWithHealthStatus, err) + } + + return networkEndpointWithHealthStatus, nil +} + +// ToAlpha converts our composite type into an alpha type. +// This alpha type can be used in GCE API calls. +func (networkEndpointWithHealthStatus *NetworkEndpointWithHealthStatus) ToAlpha() (*computealpha.NetworkEndpointWithHealthStatus, error) { + alpha := &computealpha.NetworkEndpointWithHealthStatus{} + err := copyViaJSON(alpha, networkEndpointWithHealthStatus) + if err != nil { + return nil, fmt.Errorf("error converting %T to compute alpha type via JSON: %v", networkEndpointWithHealthStatus, err) + } + + return alpha, nil +} + +// ToBeta converts our composite type into an beta type. +// This beta type can be used in GCE API calls. +func (networkEndpointWithHealthStatus *NetworkEndpointWithHealthStatus) ToBeta() (*computebeta.NetworkEndpointWithHealthStatus, error) { + beta := &computebeta.NetworkEndpointWithHealthStatus{} + err := copyViaJSON(beta, networkEndpointWithHealthStatus) + if err != nil { + return nil, fmt.Errorf("error converting %T to compute beta type via JSON: %v", networkEndpointWithHealthStatus, err) + } + + return beta, nil +} + +// ToGA converts our composite type into an ga type. +// This ga type can be used in GCE API calls. +func (networkEndpointWithHealthStatus *NetworkEndpointWithHealthStatus) ToGA() (*compute.NetworkEndpointWithHealthStatus, error) { + ga := &compute.NetworkEndpointWithHealthStatus{} + err := copyViaJSON(ga, networkEndpointWithHealthStatus) + if err != nil { + return nil, fmt.Errorf("error converting %T to compute ga type via JSON: %v", networkEndpointWithHealthStatus, err) + } + + return ga, nil +} + func CreateSslCertificate(gceCloud *gce.Cloud, key *meta.Key, sslCertificate *SslCertificate) error { ctx, cancel := cloudprovider.ContextWithCallTimeout() defer cancel() @@ -3896,7 +4219,7 @@ func GetSslCertificate(gceCloud *gce.Cloud, key *meta.Key, version meta.Version) func ListSslCertificates(gceCloud *gce.Cloud, key *meta.Key, version meta.Version) ([]*SslCertificate, error) { ctx, cancel := cloudprovider.ContextWithCallTimeout() defer cancel() - mc := compositemetrics.NewMetricContext("SslCertificate", "get", key.Region, key.Zone, string(version)) + mc := compositemetrics.NewMetricContext("SslCertificate", "list", key.Region, key.Zone, string(version)) var gceObjs interface{} var err error @@ -4115,7 +4438,7 @@ func GetTargetHttpProxy(gceCloud *gce.Cloud, key *meta.Key, version meta.Version func ListTargetHttpProxies(gceCloud *gce.Cloud, key *meta.Key, version meta.Version) ([]*TargetHttpProxy, error) { ctx, cancel := cloudprovider.ContextWithCallTimeout() defer cancel() - mc := compositemetrics.NewMetricContext("TargetHttpProxy", "get", key.Region, key.Zone, string(version)) + mc := compositemetrics.NewMetricContext("TargetHttpProxy", "list", key.Region, key.Zone, string(version)) var gceObjs interface{} var err error @@ -4334,7 +4657,7 @@ func GetTargetHttpsProxy(gceCloud *gce.Cloud, key *meta.Key, version meta.Versio func ListTargetHttpsProxies(gceCloud *gce.Cloud, key *meta.Key, version meta.Version) ([]*TargetHttpsProxy, error) { ctx, cancel := cloudprovider.ContextWithCallTimeout() defer cancel() - mc := compositemetrics.NewMetricContext("TargetHttpsProxy", "get", key.Region, key.Zone, string(version)) + mc := compositemetrics.NewMetricContext("TargetHttpsProxy", "list", key.Region, key.Zone, string(version)) var gceObjs interface{} var err error @@ -4594,7 +4917,7 @@ func GetUrlMap(gceCloud *gce.Cloud, key *meta.Key, version meta.Version) (*UrlMa func ListUrlMaps(gceCloud *gce.Cloud, key *meta.Key, version meta.Version) ([]*UrlMap, error) { ctx, cancel := cloudprovider.ContextWithCallTimeout() defer cancel() - mc := compositemetrics.NewMetricContext("UrlMap", "get", key.Region, key.Zone, string(version)) + mc := compositemetrics.NewMetricContext("UrlMap", "list", key.Region, key.Zone, string(version)) var gceObjs interface{} var err error diff --git a/pkg/composite/gen_test.go b/pkg/composite/gen_test.go index 97fad6f782..13d0893ce2 100644 --- a/pkg/composite/gen_test.go +++ b/pkg/composite/gen_test.go @@ -208,6 +208,14 @@ func TestBackendServiceLogConfig(t *testing.T) { } } +func TestBackendServiceReference(t *testing.T) { + compositeType := reflect.TypeOf(BackendServiceReference{}) + alphaType := reflect.TypeOf(computealpha.BackendServiceReference{}) + if err := typeEquality(compositeType, alphaType, true); err != nil { + t.Fatal(err) + } +} + func TestCacheKeyPolicy(t *testing.T) { compositeType := reflect.TypeOf(CacheKeyPolicy{}) alphaType := reflect.TypeOf(computealpha.CacheKeyPolicy{}) @@ -387,6 +395,14 @@ func TestForwardingRuleToGA(t *testing.T) { } } +func TestForwardingRuleReference(t *testing.T) { + compositeType := reflect.TypeOf(ForwardingRuleReference{}) + alphaType := reflect.TypeOf(computealpha.ForwardingRuleReference{}) + if err := typeEquality(compositeType, alphaType, true); err != nil { + t.Fatal(err) + } +} + func TestGrpcServiceConfig(t *testing.T) { compositeType := reflect.TypeOf(GrpcServiceConfig{}) alphaType := reflect.TypeOf(computealpha.GrpcServiceConfig{}) @@ -518,6 +534,22 @@ func TestHealthCheckToGA(t *testing.T) { } } +func TestHealthCheckReference(t *testing.T) { + compositeType := reflect.TypeOf(HealthCheckReference{}) + alphaType := reflect.TypeOf(computealpha.HealthCheckReference{}) + if err := typeEquality(compositeType, alphaType, true); err != nil { + t.Fatal(err) + } +} + +func TestHealthStatusForNetworkEndpoint(t *testing.T) { + compositeType := reflect.TypeOf(HealthStatusForNetworkEndpoint{}) + alphaType := reflect.TypeOf(computealpha.HealthStatusForNetworkEndpoint{}) + if err := typeEquality(compositeType, alphaType, true); err != nil { + t.Fatal(err) + } +} + func TestHostRule(t *testing.T) { compositeType := reflect.TypeOf(HostRule{}) alphaType := reflect.TypeOf(computealpha.HostRule{}) @@ -990,6 +1022,212 @@ func TestNetworkEndpointGroupsDetachEndpointsRequestToGA(t *testing.T) { t.Fatalf("NetworkEndpointGroupsDetachEndpointsRequest.ToGA() = \ninput = %s\n%s\nwant = \n%s", pretty.Sprint(composite), pretty.Sprint(result), pretty.Sprint(expected)) } } +func TestNetworkEndpointGroupsListEndpointsRequest(t *testing.T) { + // Use reflection to verify that our composite type contains all the + // same fields as the alpha type. + compositeType := reflect.TypeOf(NetworkEndpointGroupsListEndpointsRequest{}) + alphaType := reflect.TypeOf(computealpha.NetworkEndpointGroupsListEndpointsRequest{}) + betaType := reflect.TypeOf(computebeta.NetworkEndpointGroupsListEndpointsRequest{}) + gaType := reflect.TypeOf(compute.NetworkEndpointGroupsListEndpointsRequest{}) + + // For the composite type, remove the Version field from consideration + compositeTypeNumFields := compositeType.NumField() - 2 + if compositeTypeNumFields != alphaType.NumField() { + t.Fatalf("%v should contain %v fields. Got %v", alphaType.Name(), alphaType.NumField(), compositeTypeNumFields) + } + + // Compare all the fields by doing a lookup since we can't guarantee that they'll be in the same order + // Make sure that composite type is strictly alpha fields + internal bookkeeping + for i := 2; i < compositeType.NumField(); i++ { + lookupField, found := alphaType.FieldByName(compositeType.Field(i).Name) + if !found { + t.Fatal(fmt.Errorf("Field %v not present in alpha type %v", compositeType.Field(i), alphaType)) + } + if err := compareFields(compositeType.Field(i), lookupField); err != nil { + t.Fatal(err) + } + } + + // Verify that all beta fields are in composite type + if err := typeEquality(betaType, compositeType, false); err != nil { + t.Fatal(err) + } + + // Verify that all GA fields are in composite type + if err := typeEquality(gaType, compositeType, false); err != nil { + t.Fatal(err) + } +} + +func TestToNetworkEndpointGroupsListEndpointsRequest(t *testing.T) { + testCases := []struct { + input interface{} + expected *NetworkEndpointGroupsListEndpointsRequest + }{ + { + computealpha.NetworkEndpointGroupsListEndpointsRequest{}, + &NetworkEndpointGroupsListEndpointsRequest{}, + }, + { + computebeta.NetworkEndpointGroupsListEndpointsRequest{}, + &NetworkEndpointGroupsListEndpointsRequest{}, + }, + { + compute.NetworkEndpointGroupsListEndpointsRequest{}, + &NetworkEndpointGroupsListEndpointsRequest{}, + }, + } + for _, testCase := range testCases { + result, _ := ToNetworkEndpointGroupsListEndpointsRequest(testCase.input) + if !reflect.DeepEqual(result, testCase.expected) { + t.Fatalf("ToNetworkEndpointGroupsListEndpointsRequest(input) = \ninput = %s\n%s\nwant = \n%s", pretty.Sprint(testCase.input), pretty.Sprint(result), pretty.Sprint(testCase.expected)) + } + } +} + +func TestNetworkEndpointGroupsListEndpointsRequestToAlpha(t *testing.T) { + composite := NetworkEndpointGroupsListEndpointsRequest{} + expected := &computealpha.NetworkEndpointGroupsListEndpointsRequest{} + result, err := composite.ToAlpha() + if err != nil { + t.Fatalf("NetworkEndpointGroupsListEndpointsRequest.ToAlpha() error: %v", err) + } + + if !reflect.DeepEqual(result, expected) { + t.Fatalf("NetworkEndpointGroupsListEndpointsRequest.ToAlpha() = \ninput = %s\n%s\nwant = \n%s", pretty.Sprint(composite), pretty.Sprint(result), pretty.Sprint(expected)) + } +} +func TestNetworkEndpointGroupsListEndpointsRequestToBeta(t *testing.T) { + composite := NetworkEndpointGroupsListEndpointsRequest{} + expected := &computebeta.NetworkEndpointGroupsListEndpointsRequest{} + result, err := composite.ToBeta() + if err != nil { + t.Fatalf("NetworkEndpointGroupsListEndpointsRequest.ToBeta() error: %v", err) + } + + if !reflect.DeepEqual(result, expected) { + t.Fatalf("NetworkEndpointGroupsListEndpointsRequest.ToBeta() = \ninput = %s\n%s\nwant = \n%s", pretty.Sprint(composite), pretty.Sprint(result), pretty.Sprint(expected)) + } +} +func TestNetworkEndpointGroupsListEndpointsRequestToGA(t *testing.T) { + composite := NetworkEndpointGroupsListEndpointsRequest{} + expected := &compute.NetworkEndpointGroupsListEndpointsRequest{} + result, err := composite.ToGA() + if err != nil { + t.Fatalf("NetworkEndpointGroupsListEndpointsRequest.ToGA() error: %v", err) + } + + if !reflect.DeepEqual(result, expected) { + t.Fatalf("NetworkEndpointGroupsListEndpointsRequest.ToGA() = \ninput = %s\n%s\nwant = \n%s", pretty.Sprint(composite), pretty.Sprint(result), pretty.Sprint(expected)) + } +} + +func TestNetworkEndpointGroupsListEndpointsRequestNetworkEndpointFilter(t *testing.T) { + compositeType := reflect.TypeOf(NetworkEndpointGroupsListEndpointsRequestNetworkEndpointFilter{}) + alphaType := reflect.TypeOf(computealpha.NetworkEndpointGroupsListEndpointsRequestNetworkEndpointFilter{}) + if err := typeEquality(compositeType, alphaType, true); err != nil { + t.Fatal(err) + } +} +func TestNetworkEndpointWithHealthStatus(t *testing.T) { + // Use reflection to verify that our composite type contains all the + // same fields as the alpha type. + compositeType := reflect.TypeOf(NetworkEndpointWithHealthStatus{}) + alphaType := reflect.TypeOf(computealpha.NetworkEndpointWithHealthStatus{}) + betaType := reflect.TypeOf(computebeta.NetworkEndpointWithHealthStatus{}) + gaType := reflect.TypeOf(compute.NetworkEndpointWithHealthStatus{}) + + // For the composite type, remove the Version field from consideration + compositeTypeNumFields := compositeType.NumField() - 2 + if compositeTypeNumFields != alphaType.NumField() { + t.Fatalf("%v should contain %v fields. Got %v", alphaType.Name(), alphaType.NumField(), compositeTypeNumFields) + } + + // Compare all the fields by doing a lookup since we can't guarantee that they'll be in the same order + // Make sure that composite type is strictly alpha fields + internal bookkeeping + for i := 2; i < compositeType.NumField(); i++ { + lookupField, found := alphaType.FieldByName(compositeType.Field(i).Name) + if !found { + t.Fatal(fmt.Errorf("Field %v not present in alpha type %v", compositeType.Field(i), alphaType)) + } + if err := compareFields(compositeType.Field(i), lookupField); err != nil { + t.Fatal(err) + } + } + + // Verify that all beta fields are in composite type + if err := typeEquality(betaType, compositeType, false); err != nil { + t.Fatal(err) + } + + // Verify that all GA fields are in composite type + if err := typeEquality(gaType, compositeType, false); err != nil { + t.Fatal(err) + } +} + +func TestToNetworkEndpointWithHealthStatus(t *testing.T) { + testCases := []struct { + input interface{} + expected *NetworkEndpointWithHealthStatus + }{ + { + computealpha.NetworkEndpointWithHealthStatus{}, + &NetworkEndpointWithHealthStatus{}, + }, + { + computebeta.NetworkEndpointWithHealthStatus{}, + &NetworkEndpointWithHealthStatus{}, + }, + { + compute.NetworkEndpointWithHealthStatus{}, + &NetworkEndpointWithHealthStatus{}, + }, + } + for _, testCase := range testCases { + result, _ := ToNetworkEndpointWithHealthStatus(testCase.input) + if !reflect.DeepEqual(result, testCase.expected) { + t.Fatalf("ToNetworkEndpointWithHealthStatus(input) = \ninput = %s\n%s\nwant = \n%s", pretty.Sprint(testCase.input), pretty.Sprint(result), pretty.Sprint(testCase.expected)) + } + } +} + +func TestNetworkEndpointWithHealthStatusToAlpha(t *testing.T) { + composite := NetworkEndpointWithHealthStatus{} + expected := &computealpha.NetworkEndpointWithHealthStatus{} + result, err := composite.ToAlpha() + if err != nil { + t.Fatalf("NetworkEndpointWithHealthStatus.ToAlpha() error: %v", err) + } + + if !reflect.DeepEqual(result, expected) { + t.Fatalf("NetworkEndpointWithHealthStatus.ToAlpha() = \ninput = %s\n%s\nwant = \n%s", pretty.Sprint(composite), pretty.Sprint(result), pretty.Sprint(expected)) + } +} +func TestNetworkEndpointWithHealthStatusToBeta(t *testing.T) { + composite := NetworkEndpointWithHealthStatus{} + expected := &computebeta.NetworkEndpointWithHealthStatus{} + result, err := composite.ToBeta() + if err != nil { + t.Fatalf("NetworkEndpointWithHealthStatus.ToBeta() error: %v", err) + } + + if !reflect.DeepEqual(result, expected) { + t.Fatalf("NetworkEndpointWithHealthStatus.ToBeta() = \ninput = %s\n%s\nwant = \n%s", pretty.Sprint(composite), pretty.Sprint(result), pretty.Sprint(expected)) + } +} +func TestNetworkEndpointWithHealthStatusToGA(t *testing.T) { + composite := NetworkEndpointWithHealthStatus{} + expected := &compute.NetworkEndpointWithHealthStatus{} + result, err := composite.ToGA() + if err != nil { + t.Fatalf("NetworkEndpointWithHealthStatus.ToGA() error: %v", err) + } + + if !reflect.DeepEqual(result, expected) { + t.Fatalf("NetworkEndpointWithHealthStatus.ToGA() = \ninput = %s\n%s\nwant = \n%s", pretty.Sprint(composite), pretty.Sprint(result), pretty.Sprint(expected)) + } +} func TestOriginAuthenticationMethod(t *testing.T) { compositeType := reflect.TypeOf(OriginAuthenticationMethod{})