Update vendor k8s-cloud-provider and google API

Ran commands:
hack/pin-dependency.sh github.com/GoogleCloudPlatform/k8s-cloud-provider 27a4ced34534a6c32b63159b100ac0efaa1d37b3
hack/update-vendor.sh

hack/pin-dependency.sh google.golang.org/api 5213b809086156e6e2b262a41394993fcff97439
hack/update-vendor.sh

hack/verify-vendor.sh

merge conflicts

vendor/github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud/filter/filter.go

@@ -43,32 +43,32 @@ var (
 	None *F
 )
 
-// Regexp returns a filter for fieldName matches regexp v.
+// Regexp returns a filter for fieldName eq regexp v.
 func Regexp(fieldName, v string) *F {
 	return (&F{}).AndRegexp(fieldName, v)
 }
 
-// NotRegexp returns a filter for fieldName not matches regexp v.
+// NotRegexp returns a filter for fieldName ne regexp v.
 func NotRegexp(fieldName, v string) *F {
 	return (&F{}).AndNotRegexp(fieldName, v)
 }
 
-// EqualInt returns a filter for fieldName ~ v.
+// EqualInt returns a filter for fieldName eq v.
 func EqualInt(fieldName string, v int) *F {
 	return (&F{}).AndEqualInt(fieldName, v)
 }
 
-// NotEqualInt returns a filter for fieldName != v.
+// NotEqualInt returns a filter for fieldName ne v.
 func NotEqualInt(fieldName string, v int) *F {
 	return (&F{}).AndNotEqualInt(fieldName, v)
 }
 
-// EqualBool returns a filter for fieldName == v.
+// EqualBool returns a filter for fieldName eq v.
 func EqualBool(fieldName string, v bool) *F {
 	return (&F{}).AndEqualBool(fieldName, v)
 }
 
-// NotEqualBool returns a filter for fieldName != v.
+// NotEqualBool returns a filter for fieldName ne v.
 func NotEqualBool(fieldName string, v bool) *F {
 	return (&F{}).AndNotEqualBool(fieldName, v)
 }
@@ -104,25 +104,27 @@ type F struct {
 	predicates []filterPredicate
 }
 
+// TODO(rramkumar): Support logical OR
+
 // And joins two filters together.
 func (fl *F) And(rest *F) *F {
 	fl.predicates = append(fl.predicates, rest.predicates...)
 	return fl
 }
 
-// AndRegexp adds a field match string predicate.
+// AndRegexp adds a field ~ string predicate.
 func (fl *F) AndRegexp(fieldName, v string) *F {
-	fl.predicates = append(fl.predicates, filterPredicate{fieldName: fieldName, op: equals, s: &v})
+	fl.predicates = append(fl.predicates, filterPredicate{fieldName: fieldName, op: regexpEquals, s: &v})
 	return fl
 }
 
-// AndNotRegexp adds a field not match string predicate.
+// AndNotRegexp adds a field !~ string predicate.
 func (fl *F) AndNotRegexp(fieldName, v string) *F {
-	fl.predicates = append(fl.predicates, filterPredicate{fieldName: fieldName, op: notEquals, s: &v})
+	fl.predicates = append(fl.predicates, filterPredicate{fieldName: fieldName, op: regexpNotEquals, s: &v})
 	return fl
 }
 
-// AndEqualInt adds a field == int predicate.
+// AndEqualInt adds a field = int predicate.
 func (fl *F) AndEqualInt(fieldName string, v int) *F {
 	fl.predicates = append(fl.predicates, filterPredicate{fieldName: fieldName, op: equals, i: &v})
 	return fl
@@ -134,7 +136,7 @@ func (fl *F) AndNotEqualInt(fieldName string, v int) *F {
 	return fl
 }
 
-// AndEqualBool adds a field == bool predicate.
+// AndEqualBool adds a field = bool predicate.
 func (fl *F) AndEqualBool(fieldName string, v bool) *F {
 	fl.predicates = append(fl.predicates, filterPredicate{fieldName: fieldName, op: equals, b: &v})
 	return fl
@@ -177,8 +179,10 @@ func (fl *F) Match(obj interface{}) bool {
 type filterOp int
 
 const (
-	equals    filterOp = iota
-	notEquals filterOp = iota
+	regexpEquals    filterOp = iota
+	regexpNotEquals filterOp = iota
+	equals          filterOp = iota
+	notEquals       filterOp = iota
 )
 
 // filterPredicate is an individual predicate for a fieldName and value.
@@ -194,6 +198,13 @@ type filterPredicate struct {
 func (fp *filterPredicate) String() string {
 	var op string
 	switch fp.op {
+	case regexpEquals:
+		// GCE API maps regexp comparison to 'eq'
+		op = "eq"
+	case regexpNotEquals:
+		op = "ne"
+	// Since GCE API does not allow using a mix of 'eq' and '=' operators,
+	// we use 'eq' everywhere
 	case equals:
 		op = "eq"
 	case notEquals:
@@ -237,7 +248,10 @@ func (fp *filterPredicate) match(o interface{}) bool {
 			klog.Errorf("Match regexp %q is invalid: %v", *fp.s, err)
 			return false
 		}
-		match = re.Match([]byte(x))
+		match = x == *fp.s
+		if fp.op < regexpNotEquals {
+			match = re.Match([]byte(x))
+		}
 	case int:
 		if fp.i == nil {
 			return false
@@ -251,6 +265,10 @@ func (fp *filterPredicate) match(o interface{}) bool {
 	}
 
 	switch fp.op {
+	case regexpEquals:
+		return match
+	case regexpNotEquals:
+		return !match
 	case equals:
 		return match
 	case notEquals:

vendor/github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud/meta/meta.go

@@ -71,6 +71,7 @@ var AllServices = []*ServiceInfo{
 		Resource:    "addresses",
 		keyType:     Regional,
 		serviceType: reflect.TypeOf(&ga.AddressesService{}),
+		options:     AggregatedList,
 	},
 	{
 		Object:      "Address",
@@ -79,6 +80,7 @@ var AllServices = []*ServiceInfo{
 		version:     VersionAlpha,
 		keyType:     Regional,
 		serviceType: reflect.TypeOf(&alpha.AddressesService{}),
+		options:     AggregatedList,
 	},
 	{
 		Object:      "Address",
@@ -87,6 +89,15 @@ var AllServices = []*ServiceInfo{
 		version:     VersionBeta,
 		keyType:     Regional,
 		serviceType: reflect.TypeOf(&beta.AddressesService{}),
+		options:     AggregatedList,
+	},
+	{
+		Object:      "Address",
+		Service:     "GlobalAddresses",
+		Resource:    "addresses",
+		version:     VersionAlpha,
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&alpha.GlobalAddressesService{}),
 	},
 	{
 		Object:      "Address",
@@ -155,6 +166,18 @@ var AllServices = []*ServiceInfo{
 			"Update",
 		},
 	},
+	{
+		Object:      "BackendService",
+		Service:     "RegionBackendServices",
+		Resource:    "backendServices",
+		version:     VersionBeta,
+		keyType:     Regional,
+		serviceType: reflect.TypeOf(&beta.RegionBackendServicesService{}),
+		additionalMethods: []string{
+			"GetHealth",
+			"Update",
+		},
+	},
 	{
 		Object:      "Disk",
 		Service:     "Disks",
@@ -192,6 +215,9 @@ var AllServices = []*ServiceInfo{
 		Resource:    "forwardingRules",
 		keyType:     Regional,
 		serviceType: reflect.TypeOf(&ga.ForwardingRulesService{}),
+		additionalMethods: []string{
+			"SetTarget",
+		},
 	},
 	{
 		Object:      "ForwardingRule",
@@ -200,6 +226,42 @@ var AllServices = []*ServiceInfo{
 		version:     VersionAlpha,
 		keyType:     Regional,
 		serviceType: reflect.TypeOf(&alpha.ForwardingRulesService{}),
+		additionalMethods: []string{
+			"SetTarget",
+		},
+	},
+	{
+		Object:      "ForwardingRule",
+		Service:     "ForwardingRules",
+		Resource:    "forwardingRules",
+		version:     VersionBeta,
+		keyType:     Regional,
+		serviceType: reflect.TypeOf(&beta.ForwardingRulesService{}),
+		additionalMethods: []string{
+			"SetTarget",
+		},
+	},
+	{
+		Object:      "ForwardingRule",
+		Service:     "GlobalForwardingRules",
+		Resource:    "forwardingRules",
+		version:     VersionAlpha,
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&alpha.GlobalForwardingRulesService{}),
+		additionalMethods: []string{
+			"SetTarget",
+		},
+	},
+	{
+		Object:      "ForwardingRule",
+		Service:     "GlobalForwardingRules",
+		Resource:    "forwardingRules",
+		version:     VersionBeta,
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&beta.GlobalForwardingRulesService{}),
+		additionalMethods: []string{
+			"SetTarget",
+		},
 	},
 	{
 		Object:      "ForwardingRule",
@@ -243,6 +305,28 @@ var AllServices = []*ServiceInfo{
 			"Update",
 		},
 	},
+	{
+		Object:      "HealthCheck",
+		Service:     "RegionHealthChecks",
+		Resource:    "healthChecks",
+		version:     VersionAlpha,
+		keyType:     Regional,
+		serviceType: reflect.TypeOf(&alpha.RegionHealthChecksService{}),
+		additionalMethods: []string{
+			"Update",
+		},
+	},
+	{
+		Object:      "HealthCheck",
+		Service:     "RegionHealthChecks",
+		Resource:    "healthChecks",
+		version:     VersionBeta,
+		keyType:     Regional,
+		serviceType: reflect.TypeOf(&beta.RegionHealthChecksService{}),
+		additionalMethods: []string{
+			"Update",
+		},
+	},
 	{
 		Object:      "HttpHealthCheck",
 		Service:     "HttpHealthChecks",
@@ -313,6 +397,30 @@ var AllServices = []*ServiceInfo{
 			"UpdateNetworkInterface",
 		},
 	},
+	{
+		Object:      "Network",
+		Service:     "Networks",
+		Resource:    "networks",
+		version:     VersionAlpha,
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&alpha.NetworksService{}),
+	},
+	{
+		Object:      "Network",
+		Service:     "Networks",
+		Resource:    "networks",
+		version:     VersionBeta,
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&alpha.NetworksService{}),
+	},
+	{
+		Object:      "Network",
+		Service:     "Networks",
+		Resource:    "networks",
+		version:     VersionGA,
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&alpha.NetworksService{}),
+	},
 	{
 		Object:      "NetworkEndpointGroup",
 		Service:     "NetworkEndpointGroups",
@@ -341,6 +449,20 @@ var AllServices = []*ServiceInfo{
 		},
 		options: AggregatedList,
 	},
+	{
+		Object:      "NetworkEndpointGroup",
+		Service:     "NetworkEndpointGroups",
+		Resource:    "networkEndpointGroups",
+		version:     VersionGA,
+		keyType:     Zonal,
+		serviceType: reflect.TypeOf(&ga.NetworkEndpointGroupsService{}),
+		additionalMethods: []string{
+			"AttachNetworkEndpoints",
+			"DetachNetworkEndpoints",
+			"ListNetworkEndpoints",
+		},
+		options: AggregatedList,
+	},
 	{
 		Object:   "Project",
 		Service:  "Projects",
@@ -387,6 +509,84 @@ var AllServices = []*ServiceInfo{
 		keyType:     Global,
 		serviceType: reflect.TypeOf(&ga.SslCertificatesService{}),
 	},
+	{
+		Object:      "SslCertificate",
+		Service:     "SslCertificates",
+		Resource:    "sslCertificates",
+		version:     VersionBeta,
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&beta.SslCertificatesService{}),
+	},
+	{
+		Object:      "SslCertificate",
+		Service:     "SslCertificates",
+		Resource:    "sslCertificates",
+		version:     VersionAlpha,
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&alpha.SslCertificatesService{}),
+	},
+	{
+		Object:      "SslCertificate",
+		Service:     "RegionSslCertificates",
+		Resource:    "sslCertificates",
+		version:     VersionAlpha,
+		keyType:     Regional,
+		serviceType: reflect.TypeOf(&alpha.RegionSslCertificatesService{}),
+	},
+	{
+		Object:      "SslCertificate",
+		Service:     "RegionSslCertificates",
+		Resource:    "sslCertificates",
+		version:     VersionBeta,
+		keyType:     Regional,
+		serviceType: reflect.TypeOf(&beta.RegionSslCertificatesService{}),
+	},
+	{
+		Object:      "Subnetwork",
+		Service:     "Subnetworks",
+		Resource:    "subnetworks",
+		version:     VersionAlpha,
+		keyType:     Regional,
+		serviceType: reflect.TypeOf(&alpha.SubnetworksService{}),
+	},
+	{
+		Object:      "Subnetwork",
+		Service:     "Subnetworks",
+		Resource:    "subnetworks",
+		version:     VersionBeta,
+		keyType:     Regional,
+		serviceType: reflect.TypeOf(&alpha.SubnetworksService{}),
+	},
+	{
+		Object:      "Subnetwork",
+		Service:     "Subnetworks",
+		Resource:    "subnetworks",
+		version:     VersionGA,
+		keyType:     Regional,
+		serviceType: reflect.TypeOf(&alpha.SubnetworksService{}),
+	},
+	{
+		Object:      "TargetHttpProxy",
+		Service:     "TargetHttpProxies",
+		Resource:    "targetHttpProxies",
+		version:     VersionAlpha,
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&alpha.TargetHttpProxiesService{}),
+		additionalMethods: []string{
+			"SetUrlMap",
+		},
+	},
+	{
+		Object:      "TargetHttpProxy",
+		Service:     "TargetHttpProxies",
+		Resource:    "targetHttpProxies",
+		version:     VersionBeta,
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&beta.TargetHttpProxiesService{}),
+		additionalMethods: []string{
+			"SetUrlMap",
+		},
+	},
 	{
 		Object:      "TargetHttpProxy",
 		Service:     "TargetHttpProxies",
@@ -397,6 +597,28 @@ var AllServices = []*ServiceInfo{
 			"SetUrlMap",
 		},
 	},
+	{
+		Object:      "TargetHttpProxy",
+		Service:     "RegionTargetHttpProxies",
+		Resource:    "targetHttpProxies",
+		version:     VersionAlpha,
+		keyType:     Regional,
+		serviceType: reflect.TypeOf(&alpha.RegionTargetHttpProxiesService{}),
+		additionalMethods: []string{
+			"SetUrlMap",
+		},
+	},
+	{
+		Object:      "TargetHttpProxy",
+		Service:     "RegionTargetHttpProxies",
+		Resource:    "targetHttpProxies",
+		version:     VersionBeta,
+		keyType:     Regional,
+		serviceType: reflect.TypeOf(&beta.RegionTargetHttpProxiesService{}),
+		additionalMethods: []string{
+			"SetUrlMap",
+		},
+	},
 	{
 		Object:      "TargetHttpsProxy",
 		Service:     "TargetHttpsProxies",
@@ -408,6 +630,54 @@ var AllServices = []*ServiceInfo{
 			"SetUrlMap",
 		},
 	},
+	{
+		Object:      "TargetHttpsProxy",
+		Service:     "TargetHttpsProxies",
+		Resource:    "targetHttpsProxies",
+		version:     VersionAlpha,
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&alpha.TargetHttpsProxiesService{}),
+		additionalMethods: []string{
+			"SetSslCertificates",
+			"SetUrlMap",
+		},
+	},
+	{
+		Object:      "TargetHttpsProxy",
+		Service:     "TargetHttpsProxies",
+		Resource:    "targetHttpsProxies",
+		version:     VersionBeta,
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&beta.TargetHttpsProxiesService{}),
+		additionalMethods: []string{
+			"SetSslCertificates",
+			"SetUrlMap",
+		},
+	},
+	{
+		Object:      "TargetHttpsProxy",
+		Service:     "RegionTargetHttpsProxies",
+		Resource:    "targetHttpsProxies",
+		version:     VersionAlpha,
+		keyType:     Regional,
+		serviceType: reflect.TypeOf(&alpha.RegionTargetHttpsProxiesService{}),
+		additionalMethods: []string{
+			"SetSslCertificates",
+			"SetUrlMap",
+		},
+	},
+	{
+		Object:      "TargetHttpsProxy",
+		Service:     "RegionTargetHttpsProxies",
+		Resource:    "targetHttpsProxies",
+		version:     VersionBeta,
+		keyType:     Regional,
+		serviceType: reflect.TypeOf(&beta.RegionTargetHttpsProxiesService{}),
+		additionalMethods: []string{
+			"SetSslCertificates",
+			"SetUrlMap",
+		},
+	},
 	{
 		Object:      "TargetPool",
 		Service:     "TargetPools",
@@ -419,6 +689,28 @@ var AllServices = []*ServiceInfo{
 			"RemoveInstance",
 		},
 	},
+	{
+		Object:      "UrlMap",
+		Service:     "UrlMaps",
+		Resource:    "urlMaps",
+		version:     VersionAlpha,
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&alpha.UrlMapsService{}),
+		additionalMethods: []string{
+			"Update",
+		},
+	},
+	{
+		Object:      "UrlMap",
+		Service:     "UrlMaps",
+		Resource:    "urlMaps",
+		version:     VersionBeta,
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&beta.UrlMapsService{}),
+		additionalMethods: []string{
+			"Update",
+		},
+	},
 	{
 		Object:      "UrlMap",
 		Service:     "UrlMaps",
@@ -429,6 +721,28 @@ var AllServices = []*ServiceInfo{
 			"Update",
 		},
 	},
+	{
+		Object:      "UrlMap",
+		Service:     "RegionUrlMaps",
+		Resource:    "urlMaps",
+		version:     VersionAlpha,
+		keyType:     Regional,
+		serviceType: reflect.TypeOf(&alpha.RegionUrlMapsService{}),
+		additionalMethods: []string{
+			"Update",
+		},
+	},
+	{
+		Object:      "UrlMap",
+		Service:     "RegionUrlMaps",
+		Resource:    "urlMaps",
+		version:     VersionBeta,
+		keyType:     Regional,
+		serviceType: reflect.TypeOf(&beta.RegionUrlMapsService{}),
+		additionalMethods: []string{
+			"Update",
+		},
+	},
 	{
 		Object:      "Zone",
 		Service:     "Zones",

vendor/github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud/mock/mock.go

@@ -53,6 +53,34 @@ type gceObject interface {
 	MarshalJSON() ([]byte, error)
 }
 
+// AttachDiskHook mocks attaching a disk to an instance
+func AttachDiskHook(ctx context.Context, key *meta.Key, req *ga.AttachedDisk, m *cloud.MockInstances) error {
+	instance, err := m.Get(ctx, key)
+	if err != nil {
+		return err
+	}
+	instance.Disks = append(instance.Disks, req)
+	return nil
+}
+
+// DetachDiskHook mocks detaching a disk from an instance
+func DetachDiskHook(ctx context.Context, key *meta.Key, diskName string, m *cloud.MockInstances) error {
+	instance, err := m.Get(ctx, key)
+	if err != nil {
+		return err
+	}
+	for i, disk := range instance.Disks {
+		if disk.DeviceName == diskName {
+			instance.Disks = append(instance.Disks[:i], instance.Disks[i+1:]...)
+			return nil
+		}
+	}
+	return &googleapi.Error{
+		Code:    http.StatusNotFound,
+		Message: fmt.Sprintf("Disk: %s was not found in Instance %s", diskName, key.String()),
+	}
+}
+
 // AddInstanceHook mocks adding a Instance to MockTargetPools
 func AddInstanceHook(ctx context.Context, key *meta.Key, req *ga.TargetPoolsAddInstanceRequest, m *cloud.MockTargetPools) error {
 	pool, err := m.Get(ctx, key)
@@ -333,10 +361,7 @@ func (igAttrs *InstanceGroupAttributes) List(key *meta.Key) []*ga.InstanceWithNa
 func AddInstancesHook(ctx context.Context, key *meta.Key, req *ga.InstanceGroupsAddInstancesRequest, m *cloud.MockInstanceGroups) error {
 	_, err := m.Get(ctx, key)
 	if err != nil {
-		return &googleapi.Error{
-			Code:    http.StatusNotFound,
-			Message: fmt.Sprintf("Key: %s was not found in InstanceGroups", key.String()),
-		}
+		return err
 	}
 
 	var attrs InstanceGroupAttributes
@@ -350,10 +375,7 @@ func AddInstancesHook(ctx context.Context, key *meta.Key, req *ga.InstanceGroups
 func ListInstancesHook(ctx context.Context, key *meta.Key, req *ga.InstanceGroupsListInstancesRequest, filter *filter.F, m *cloud.MockInstanceGroups) ([]*ga.InstanceWithNamedPorts, error) {
 	_, err := m.Get(ctx, key)
 	if err != nil {
-		return nil, &googleapi.Error{
-			Code:    http.StatusNotFound,
-			Message: fmt.Sprintf("Key: %s was not found in InstanceGroups", key.String()),
-		}
+		return nil, err
 	}
 
 	var attrs InstanceGroupAttributes
@@ -367,10 +389,7 @@ func ListInstancesHook(ctx context.Context, key *meta.Key, req *ga.InstanceGroup
 func RemoveInstancesHook(ctx context.Context, key *meta.Key, req *ga.InstanceGroupsRemoveInstancesRequest, m *cloud.MockInstanceGroups) error {
 	_, err := m.Get(ctx, key)
 	if err != nil {
-		return &googleapi.Error{
-			Code:    http.StatusNotFound,
-			Message: fmt.Sprintf("Key: %s was not found in InstanceGroups", key.String()),
-		}
+		return err
 	}
 
 	var attrs InstanceGroupAttributes
@@ -385,10 +404,7 @@ func RemoveInstancesHook(ctx context.Context, key *meta.Key, req *ga.InstanceGro
 func UpdateFirewallHook(ctx context.Context, key *meta.Key, obj *ga.Firewall, m *cloud.MockFirewalls) error {
 	_, err := m.Get(ctx, key)
 	if err != nil {
-		return &googleapi.Error{
-			Code:    http.StatusNotFound,
-			Message: fmt.Sprintf("Key: %s was not found in Firewalls", key.String()),
-		}
+		return err
 	}
 
 	obj.Name = key.Name
@@ -404,10 +420,7 @@ func UpdateFirewallHook(ctx context.Context, key *meta.Key, obj *ga.Firewall, m
 func UpdateHealthCheckHook(ctx context.Context, key *meta.Key, obj *ga.HealthCheck, m *cloud.MockHealthChecks) error {
 	_, err := m.Get(ctx, key)
 	if err != nil {
-		return &googleapi.Error{
-			Code:    http.StatusNotFound,
-			Message: fmt.Sprintf("Key: %s was not found in HealthChecks", key.String()),
-		}
+		return err
 	}
 
 	obj.Name = key.Name
@@ -418,16 +431,74 @@ func UpdateHealthCheckHook(ctx context.Context, key *meta.Key, obj *ga.HealthChe
 	return nil
 }
 
+// UpdateAlphaHealthCheckHook defines the hook for updating an alpha HealthCheck.
+// It replaces the object with the same key in the mock with the updated object.
+func UpdateAlphaHealthCheckHook(ctx context.Context, key *meta.Key, obj *alpha.HealthCheck, m *cloud.MockAlphaHealthChecks) error {
+	_, err := m.Get(ctx, key)
+	if err != nil {
+		return err
+	}
+
+	obj.Name = key.Name
+	projectID := m.ProjectRouter.ProjectID(ctx, "alpha", "healthChecks")
+	obj.SelfLink = cloud.SelfLink(meta.VersionAlpha, projectID, "healthChecks", key)
+
+	m.Objects[*key] = &cloud.MockHealthChecksObj{Obj: obj}
+	return nil
+}
+
+// UpdateAlphaRegionHealthCheckHook defines the hook for updating an alpha HealthCheck.
+// It replaces the object with the same key in the mock with the updated object.
+func UpdateAlphaRegionHealthCheckHook(ctx context.Context, key *meta.Key, obj *alpha.HealthCheck, m *cloud.MockAlphaRegionHealthChecks) error {
+	if _, err := m.Get(ctx, key); err != nil {
+		return err
+	}
+
+	obj.Name = key.Name
+	projectID := m.ProjectRouter.ProjectID(ctx, "alpha", "healthChecks")
+	obj.SelfLink = cloud.SelfLink(meta.VersionAlpha, projectID, "healthChecks", key)
+
+	m.Objects[*key] = &cloud.MockRegionHealthChecksObj{Obj: obj}
+	return nil
+}
+
+// UpdateBetaHealthCheckHook defines the hook for updating a HealthCheck. It
+// replaces the object with the same key in the mock with the updated object.
+func UpdateBetaHealthCheckHook(ctx context.Context, key *meta.Key, obj *beta.HealthCheck, m *cloud.MockBetaHealthChecks) error {
+	if _, err := m.Get(ctx, key); err != nil {
+		return err
+	}
+
+	obj.Name = key.Name
+	projectID := m.ProjectRouter.ProjectID(ctx, "beta", "healthChecks")
+	obj.SelfLink = cloud.SelfLink(meta.VersionBeta, projectID, "healthChecks", key)
+
+	m.Objects[*key] = &cloud.MockHealthChecksObj{Obj: obj}
+	return nil
+}
+
+// UpdateBetaRegionHealthCheckHook defines the hook for updating a HealthCheck. It
+// replaces the object with the same key in the mock with the updated object.
+func UpdateBetaRegionHealthCheckHook(ctx context.Context, key *meta.Key, obj *beta.HealthCheck, m *cloud.MockBetaRegionHealthChecks) error {
+	if _, err := m.Get(ctx, key); err != nil {
+		return err
+	}
+
+	obj.Name = key.Name
+	projectID := m.ProjectRouter.ProjectID(ctx, "beta", "healthChecks")
+	obj.SelfLink = cloud.SelfLink(meta.VersionBeta, projectID, "healthChecks", key)
+
+	m.Objects[*key] = &cloud.MockRegionHealthChecksObj{Obj: obj}
+	return nil
+}
+
 // UpdateRegionBackendServiceHook defines the hook for updating a Region
 // BackendsService. It replaces the object with the same key in the mock with
 // the updated object.
 func UpdateRegionBackendServiceHook(ctx context.Context, key *meta.Key, obj *ga.BackendService, m *cloud.MockRegionBackendServices) error {
 	_, err := m.Get(ctx, key)
 	if err != nil {
-		return &googleapi.Error{
-			Code:    http.StatusNotFound,
-			Message: fmt.Sprintf("Key: %s was not found in RegionBackendServices", key.String()),
-		}
+		return err
 	}
 
 	obj.Name = key.Name
@@ -438,15 +509,46 @@ func UpdateRegionBackendServiceHook(ctx context.Context, key *meta.Key, obj *ga.
 	return nil
 }
 
+// UpdateRegionBackendServiceHook defines the hook for updating a Region
+// BackendsService. It replaces the object with the same key in the mock with
+// the updated object.
+func UpdateAlphaRegionBackendServiceHook(ctx context.Context, key *meta.Key, obj *ga.BackendService, m *cloud.MockAlphaRegionBackendServices) error {
+	_, err := m.Get(ctx, key)
+	if err != nil {
+		return err
+	}
+
+	obj.Name = key.Name
+	projectID := m.ProjectRouter.ProjectID(ctx, "ga", "backendServices")
+	obj.SelfLink = cloud.SelfLink(meta.VersionAlpha, projectID, "backendServices", key)
+
+	m.Objects[*key] = &cloud.MockRegionBackendServicesObj{Obj: obj}
+	return nil
+}
+
+// UpdateBetaRegionBackendServiceHook defines the hook for updating a Region
+// BackendsService. It replaces the object with the same key in the mock with
+// the updated object.
+func UpdateBetaRegionBackendServiceHook(ctx context.Context, key *meta.Key, obj *ga.BackendService, m *cloud.MockBetaRegionBackendServices) error {
+	_, err := m.Get(ctx, key)
+	if err != nil {
+		return err
+	}
+
+	obj.Name = key.Name
+	projectID := m.ProjectRouter.ProjectID(ctx, "ga", "backendServices")
+	obj.SelfLink = cloud.SelfLink(meta.VersionAlpha, projectID, "backendServices", key)
+
+	m.Objects[*key] = &cloud.MockRegionBackendServicesObj{Obj: obj}
+	return nil
+}
+
 // UpdateBackendServiceHook defines the hook for updating a BackendService.
 // It replaces the object with the same key in the mock with the updated object.
 func UpdateBackendServiceHook(ctx context.Context, key *meta.Key, obj *ga.BackendService, m *cloud.MockBackendServices) error {
 	_, err := m.Get(ctx, key)
 	if err != nil {
-		return &googleapi.Error{
-			Code:    http.StatusNotFound,
-			Message: fmt.Sprintf("Key: %s was not found in BackendServices", key.String()),
-		}
+		return err
 	}
 
 	obj.Name = key.Name
@@ -462,10 +564,7 @@ func UpdateBackendServiceHook(ctx context.Context, key *meta.Key, obj *ga.Backen
 func UpdateAlphaBackendServiceHook(ctx context.Context, key *meta.Key, obj *alpha.BackendService, m *cloud.MockAlphaBackendServices) error {
 	_, err := m.Get(ctx, key)
 	if err != nil {
-		return &googleapi.Error{
-			Code:    http.StatusNotFound,
-			Message: fmt.Sprintf("Key: %s was not found in BackendServices", key.String()),
-		}
+		return err
 	}
 
 	obj.Name = key.Name
@@ -481,10 +580,7 @@ func UpdateAlphaBackendServiceHook(ctx context.Context, key *meta.Key, obj *alph
 func UpdateBetaBackendServiceHook(ctx context.Context, key *meta.Key, obj *beta.BackendService, m *cloud.MockBetaBackendServices) error {
 	_, err := m.Get(ctx, key)
 	if err != nil {
-		return &googleapi.Error{
-			Code:    http.StatusNotFound,
-			Message: fmt.Sprintf("Key: %s was not found in BackendServices", key.String()),
-		}
+		return err
 	}
 
 	obj.Name = key.Name
@@ -500,10 +596,7 @@ func UpdateBetaBackendServiceHook(ctx context.Context, key *meta.Key, obj *beta.
 func UpdateURLMapHook(ctx context.Context, key *meta.Key, obj *ga.UrlMap, m *cloud.MockUrlMaps) error {
 	_, err := m.Get(ctx, key)
 	if err != nil {
-		return &googleapi.Error{
-			Code:    http.StatusNotFound,
-			Message: fmt.Sprintf("Key: %s was not found in UrlMaps", key.String()),
-		}
+		return err
 	}
 
 	obj.Name = key.Name
@@ -514,6 +607,229 @@ func UpdateURLMapHook(ctx context.Context, key *meta.Key, obj *ga.UrlMap, m *clo
 	return nil
 }
 
+// UpdateAlphaURLMapHook defines the hook for updating an alpha UrlMap.
+// It replaces the object with the same key in the mock with the updated object.
+func UpdateAlphaURLMapHook(ctx context.Context, key *meta.Key, obj *alpha.UrlMap, m *cloud.MockAlphaUrlMaps) error {
+	_, err := m.Get(ctx, key)
+	if err != nil {
+		return err
+	}
+
+	obj.Name = key.Name
+	projectID := m.ProjectRouter.ProjectID(ctx, "alpha", "urlMaps")
+	obj.SelfLink = cloud.SelfLink(meta.VersionAlpha, projectID, "urlMaps", key)
+
+	m.Objects[*key] = &cloud.MockUrlMapsObj{Obj: obj}
+	return nil
+}
+
+// UpdateAlphaRegionURLMapHook defines the hook for updating an alpha UrlMap.
+// It replaces the object with the same key in the mock with the updated object.
+func UpdateAlphaRegionURLMapHook(ctx context.Context, key *meta.Key, obj *alpha.UrlMap, m *cloud.MockAlphaRegionUrlMaps) error {
+	_, err := m.Get(ctx, key)
+	if err != nil {
+		return err
+	}
+
+	obj.Name = key.Name
+	projectID := m.ProjectRouter.ProjectID(ctx, "alpha", "urlMaps")
+	obj.SelfLink = cloud.SelfLink(meta.VersionAlpha, projectID, "urlMaps", key)
+
+	m.Objects[*key] = &cloud.MockRegionUrlMapsObj{Obj: obj}
+	return nil
+}
+
+// UpdateBetaRegionURLMapHook defines the hook for updating an alpha UrlMap.
+// It replaces the object with the same key in the mock with the updated object.
+func UpdateBetaRegionURLMapHook(ctx context.Context, key *meta.Key, obj *alpha.UrlMap, m *cloud.MockBetaRegionUrlMaps) error {
+	_, err := m.Get(ctx, key)
+	if err != nil {
+		return err
+	}
+
+	obj.Name = key.Name
+	projectID := m.ProjectRouter.ProjectID(ctx, "alpha", "urlMaps")
+	obj.SelfLink = cloud.SelfLink(meta.VersionAlpha, projectID, "urlMaps", key)
+
+	m.Objects[*key] = &cloud.MockRegionUrlMapsObj{Obj: obj}
+	return nil
+}
+
+// SetTargetGlobalForwardingRuleHook defines the hook for setting the target proxy for a GlobalForwardingRule.
+func SetTargetGlobalForwardingRuleHook(ctx context.Context, key *meta.Key, obj *ga.TargetReference, m *cloud.MockGlobalForwardingRules) error {
+	fw, err := m.Get(ctx, key)
+	if err != nil {
+		return err
+	}
+
+	fw.Target = obj.Target
+	return nil
+}
+
+// SetTargetForwardingRuleHook defines the hook for setting the target proxy for a ForwardingRule.
+func SetTargetForwardingRuleHook(ctx context.Context, key *meta.Key, obj *ga.TargetReference, m *cloud.MockForwardingRules) error {
+	fw, err := m.Get(ctx, key)
+	if err != nil {
+		return err
+	}
+
+	fw.Target = obj.Target
+	return nil
+}
+
+// SetTargetAlphaForwardingRuleHook defines the hook for setting the target proxy for an Alpha ForwardingRule.
+func SetTargetAlphaForwardingRuleHook(ctx context.Context, key *meta.Key, obj *alpha.TargetReference, m *cloud.MockAlphaForwardingRules) error {
+	fw, err := m.Get(ctx, key)
+	if err != nil {
+		return err
+	}
+
+	fw.Target = obj.Target
+	return nil
+}
+
+// SetTargetBetaForwardingRuleHook defines the hook for setting the target proxy for an Alpha ForwardingRule.
+func SetTargetBetaForwardingRuleHook(ctx context.Context, key *meta.Key, obj *alpha.TargetReference, m *cloud.MockBetaForwardingRules) error {
+	fw, err := m.Get(ctx, key)
+	if err != nil {
+		return err
+	}
+
+	fw.Target = obj.Target
+	return nil
+}
+
+// SetTargetAlphaGlobalForwardingRuleHook defines the hook for setting the target proxy for an alpha GlobalForwardingRule.
+func SetTargetAlphaGlobalForwardingRuleHook(ctx context.Context, key *meta.Key, ref *alpha.TargetReference, m *cloud.MockAlphaGlobalForwardingRules) error {
+	fw, err := m.Get(ctx, key)
+	if err != nil {
+		return err
+	}
+
+	fw.Target = ref.Target
+	return nil
+}
+
+// SetURLMapTargetHTTPProxyHook defines the hook for setting the url map for a TargetHttpProxy.
+func SetURLMapTargetHTTPProxyHook(ctx context.Context, key *meta.Key, ref *ga.UrlMapReference, m *cloud.MockTargetHttpProxies) error {
+	tp, err := m.Get(ctx, key)
+	if err != nil {
+		return err
+	}
+
+	tp.UrlMap = ref.UrlMap
+	return nil
+}
+
+// SetURLMapTargetHTTPProxyHook defines the hook for setting the url map for a TargetHttpProxy.
+func SetURLMapTargetHTTPSProxyHook(ctx context.Context, key *meta.Key, ref *ga.UrlMapReference, m *cloud.MockTargetHttpsProxies) error {
+	tp, err := m.Get(ctx, key)
+	if err != nil {
+		return err
+	}
+
+	tp.UrlMap = ref.UrlMap
+	return nil
+}
+
+// SetURLMapTargetHTTPProxyHook defines the hook for setting the url map for a TargetHttpProxy.
+func SetURLMapAlphaRegionTargetHTTPSProxyHook(ctx context.Context, key *meta.Key, ref *alpha.UrlMapReference, m *cloud.MockAlphaRegionTargetHttpsProxies) error {
+	tp, err := m.Get(ctx, key)
+	if err != nil {
+		return err
+	}
+
+	tp.UrlMap = ref.UrlMap
+	return nil
+}
+
+// SetURLMapBetaRegionTargetHTTPProxyHook defines the hook for setting the url map for a TargetHttpProxy.
+func SetURLMapBetaRegionTargetHTTPSProxyHook(ctx context.Context, key *meta.Key, ref *alpha.UrlMapReference, m *cloud.MockBetaRegionTargetHttpsProxies) error {
+	tp, err := m.Get(ctx, key)
+	if err != nil {
+		return err
+	}
+
+	tp.UrlMap = ref.UrlMap
+	return nil
+}
+
+// SetURLMapAlphaTargetHTTPProxyHook defines the hook for setting the url map for a TargetHttpProxy.
+func SetURLMapAlphaTargetHTTPProxyHook(ctx context.Context, key *meta.Key, ref *alpha.UrlMapReference, m *cloud.MockAlphaTargetHttpProxies) error {
+	tp, err := m.Get(ctx, key)
+	if err != nil {
+		return err
+	}
+
+	tp.UrlMap = ref.UrlMap
+	return nil
+}
+
+// SetURLMapAlphaRegionTargetHTTPProxyHook defines the hook for setting the url map for a TargetHttpProxy.
+func SetURLMapAlphaRegionTargetHTTPProxyHook(ctx context.Context, key *meta.Key, ref *alpha.UrlMapReference, m *cloud.MockAlphaRegionTargetHttpProxies) error {
+	tp, err := m.Get(ctx, key)
+	if err != nil {
+		return err
+	}
+
+	tp.UrlMap = ref.UrlMap
+	return nil
+}
+
+// SetURLMapBetaRegionTargetHTTPProxyHook defines the hook for setting the url map for a TargetHttpProxy.
+func SetURLMapBetaRegionTargetHTTPProxyHook(ctx context.Context, key *meta.Key, ref *alpha.UrlMapReference, m *cloud.MockBetaRegionTargetHttpProxies) error {
+	tp, err := m.Get(ctx, key)
+	if err != nil {
+		return err
+	}
+
+	tp.UrlMap = ref.UrlMap
+	return nil
+}
+
+// SetSslCertificateTargetHTTPSProxyHook defines the hook for setting ssl certificates on a TargetHttpsProxy.
+func SetSslCertificateTargetHTTPSProxyHook(ctx context.Context, key *meta.Key, req *ga.TargetHttpsProxiesSetSslCertificatesRequest, m *cloud.MockTargetHttpsProxies) error {
+	tp, err := m.Get(ctx, key)
+	if err != nil {
+		return err
+	}
+
+	tp.SslCertificates = req.SslCertificates
+	return nil
+}
+
+// SetSslCertificateAlphaTargetHTTPSProxyHook defines the hook for setting ssl certificates on a TargetHttpsProxy.
+func SetSslCertificateAlphaTargetHTTPSProxyHook(ctx context.Context, key *meta.Key, req *alpha.TargetHttpsProxiesSetSslCertificatesRequest, m *cloud.MockAlphaTargetHttpsProxies) error {
+	tp, err := m.Get(ctx, key)
+	if err != nil {
+		return err
+	}
+	tp.SslCertificates = req.SslCertificates
+	return nil
+}
+
+// SetSslCertificateAlphaRegionTargetHTTPSProxyHook defines the hook for setting ssl certificates on a TargetHttpsProxy.
+func SetSslCertificateAlphaRegionTargetHTTPSProxyHook(ctx context.Context, key *meta.Key, req *alpha.TargetHttpsProxiesSetSslCertificatesRequest, m *cloud.MockAlphaRegionTargetHttpsProxies) error {
+	tp, err := m.Get(ctx, key)
+	if err != nil {
+		return err
+	}
+
+	tp.SslCertificates = req.SslCertificates
+	return nil
+}
+
+// SetSslCertificateBetaRegionTargetHTTPSProxyHook defines the hook for setting ssl certificates on a TargetHttpsProxy.
+func SetSslCertificateBetaRegionTargetHTTPSProxyHook(ctx context.Context, key *meta.Key, req *alpha.TargetHttpsProxiesSetSslCertificatesRequest, m *cloud.MockBetaRegionTargetHttpsProxies) error {
+	tp, err := m.Get(ctx, key)
+	if err != nil {
+		return err
+	}
+
+	tp.SslCertificates = req.SslCertificates
+	return nil
+}
+
 // InsertFirewallsUnauthorizedErrHook mocks firewall insertion. A forbidden error will be thrown as return.
 func InsertFirewallsUnauthorizedErrHook(ctx context.Context, key *meta.Key, obj *ga.Firewall, m *cloud.MockFirewalls) (bool, error) {
 	return true, &googleapi.Error{Code: http.StatusForbidden}