move shared test cluster vars into method + type

pkg/cloudprovider/providers/gce/gce_loadbalancer_external_test.go

@@ -30,40 +30,33 @@ import (
 	"k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud"
 )
 
-const serviceName = ""
-
 func TestEnsureStaticIP(t *testing.T) {
-	projectID := "test-project"
+	gce, err := fakeGCECloud(DefaultTestClusterValues())
-	region := "us-central1"
-	zoneName := "us-central1-b"
-
-	gce, err := fakeGCECloud(projectID, region, zoneName)
 	require.NoError(t, err)
 
 	ipName := "some-static-ip"
+	serviceName := "some-service"
 
 	// First ensure call
-	ip, existed, err := ensureStaticIP(gce, ipName, serviceName, region, "", cloud.NetworkTierDefault)
+	ip, existed, err := ensureStaticIP(gce, ipName, serviceName, gce.region, "", cloud.NetworkTierDefault)
 	if err != nil || existed {
-		t.Fatalf(`ensureStaticIP(%v, %v, %v, %v, "") = %v, %v, %v; want valid ip, false, nil`, gce, ipName, serviceName, region, ip, existed, err)
+		t.Fatalf(`ensureStaticIP(%v, %v, %v, %v, "") = %v, %v, %v; want valid ip, false, nil`, gce, ipName, serviceName, gce.region, ip, existed, err)
 	}
 
 	// Second ensure call
 	var ipPrime string
-	ipPrime, existed, err = ensureStaticIP(gce, ipName, serviceName, region, ip, cloud.NetworkTierDefault)
+	ipPrime, existed, err = ensureStaticIP(gce, ipName, serviceName, gce.region, ip, cloud.NetworkTierDefault)
 	if err != nil || !existed || ip != ipPrime {
-		t.Fatalf(`ensureStaticIP(%v, %v, %v, %v, %v) = %v, %v, %v; want %v, true, nil`, gce, ipName, serviceName, region, ip, ipPrime, existed, err, ip)
+		t.Fatalf(`ensureStaticIP(%v, %v, %v, %v, %v) = %v, %v, %v; want %v, true, nil`, gce, ipName, serviceName, gce.region, ip, ipPrime, existed, err, ip)
 	}
 }
 
 func TestEnsureStaticIPWithTier(t *testing.T) {
-	projectID := "test-project"
+	s, err := fakeGCECloud(DefaultTestClusterValues())
-	region := "us-central1"
-	zoneName := "us-central1-b"
-
-	s, err := fakeGCECloud(projectID, region, zoneName)
 	require.NoError(t, err)
 
+	serviceName := "some-service"
+
 	for desc, tc := range map[string]struct {
 		name     string
 		netTier  cloud.NetworkTier
@@ -81,13 +74,13 @@ func TestEnsureStaticIPWithTier(t *testing.T) {
 		},
 	} {
 		t.Run(desc, func(t *testing.T) {
-			ip, existed, err := ensureStaticIP(s, tc.name, serviceName, region, "", tc.netTier)
+			ip, existed, err := ensureStaticIP(s, tc.name, serviceName, s.region, "", tc.netTier)
 			assert.NoError(t, err)
 			assert.False(t, existed)
 			assert.NotEqual(t, ip, "")
 			// Get the Address from the fake address service and verify that the tier
 			// is set correctly.
-			alphaAddr, err := s.GetAlphaRegionAddress(tc.name, region)
+			alphaAddr, err := s.GetAlphaRegionAddress(tc.name, s.region)
 			require.NoError(t, err)
 			assert.Equal(t, tc.expected, alphaAddr.NetworkTier)
 		})
@@ -96,7 +89,6 @@ func TestEnsureStaticIPWithTier(t *testing.T) {
 
 func TestVerifyRequestedIP(t *testing.T) {
 	lbRef := "test-lb"
-	region := "us-central1"
 
 	for desc, tc := range map[string]struct {
 		requestedIP     string
@@ -137,13 +129,13 @@ func TestVerifyRequestedIP(t *testing.T) {
 		},
 	} {
 		t.Run(desc, func(t *testing.T) {
-			s, err := fakeGCECloud("test-project", region, "us-central1a")
+			s, err := fakeGCECloud(DefaultTestClusterValues())
 			require.NoError(t, err)
 
 			for _, addr := range tc.addrList {
-				s.ReserveAlphaRegionAddress(addr, region)
+				s.ReserveAlphaRegionAddress(addr, s.region)
 			}
-			isUserOwnedIP, err := verifyUserRequestedIP(s, region, tc.requestedIP, tc.fwdRuleIP, lbRef, tc.netTier)
+			isUserOwnedIP, err := verifyUserRequestedIP(s, s.region, tc.requestedIP, tc.fwdRuleIP, lbRef, tc.netTier)
 			assert.Equal(t, tc.expectErr, err != nil, fmt.Sprintf("err: %v", err))
 			assert.Equal(t, tc.expectUserOwned, isUserOwnedIP)
 		})
@@ -154,9 +146,8 @@ func TestCreateForwardingRuleWithTier(t *testing.T) {
 	// Common variables among the tests.
 	ports := []v1.ServicePort{{Name: "foo", Protocol: v1.ProtocolTCP, Port: int32(123)}}
 	target := "test-target-pool"
-	svcName := "foo-svc"
+	vals := DefaultTestClusterValues()
-	projectID := "test-project"
+	serviceName := "foo-svc"
-	region := "us-central1"
 
 	baseLinkUrl := "https://www.googleapis.com/compute/%v/projects/%v/regions/%v/forwardingRules/%v"
 
@@ -174,7 +165,7 @@ func TestCreateForwardingRuleWithTier(t *testing.T) {
 				PortRange:   "123-123",
 				Target:      target,
 				NetworkTier: "PREMIUM",
-				SelfLink:    fmt.Sprintf(baseLinkUrl, "v1", projectID, region, "lb-1"),
+				SelfLink:    fmt.Sprintf(baseLinkUrl, "v1", vals.ProjectID, vals.Region, "lb-1"),
 			},
 		},
 		"Standard tier": {
@@ -187,21 +178,21 @@ func TestCreateForwardingRuleWithTier(t *testing.T) {
 				PortRange:   "123-123",
 				Target:      target,
 				NetworkTier: "STANDARD",
-				SelfLink:    fmt.Sprintf(baseLinkUrl, "alpha", projectID, region, "lb-2"),
+				SelfLink:    fmt.Sprintf(baseLinkUrl, "alpha", vals.ProjectID, vals.Region, "lb-2"),
 			},
 		},
 	} {
 		t.Run(desc, func(t *testing.T) {
-			s, err := fakeGCECloud(projectID, region, "us-central1a")
+			s, err := fakeGCECloud(vals)
 			require.NoError(t, err)
 
 			lbName := tc.expectedRule.Name
 			ipAddr := tc.expectedRule.IPAddress
 
-			err = createForwardingRule(s, lbName, svcName, region, ipAddr, target, ports, tc.netTier)
+			err = createForwardingRule(s, lbName, serviceName, s.region, ipAddr, target, ports, tc.netTier)
 			assert.NoError(t, err)
 
-			alphaRule, err := s.GetAlphaRegionForwardingRule(lbName, region)
+			alphaRule, err := s.GetAlphaRegionForwardingRule(lbName, s.region)
 			assert.NoError(t, err)
 			assert.Equal(t, tc.expectedRule, alphaRule)
 		})
@@ -210,9 +201,8 @@ func TestCreateForwardingRuleWithTier(t *testing.T) {
 
 func TestDeleteAddressWithWrongTier(t *testing.T) {
 	lbRef := "test-lb"
-	region := "us-central1"
 
-	s, err := fakeGCECloud("test-region", region, "us-central1a")
+	s, err := fakeGCECloud(DefaultTestClusterValues())
 	require.NoError(t, err)
 
 	// Enable the cloud.NetworkTiers feature
@@ -249,17 +239,17 @@ func TestDeleteAddressWithWrongTier(t *testing.T) {
 	} {
 		t.Run(desc, func(t *testing.T) {
 			for _, addr := range tc.addrList {
-				s.ReserveAlphaRegionAddress(addr, region)
+				s.ReserveAlphaRegionAddress(addr, s.region)
 			}
 
 			// Sanity check to ensure we inject the right address.
-			_, err = s.GetRegionAddress(tc.addrName, region)
+			_, err = s.GetRegionAddress(tc.addrName, s.region)
 			require.NoError(t, err)
 
-			err = deleteAddressWithWrongTier(s, region, tc.addrName, lbRef, tc.netTier)
+			err = deleteAddressWithWrongTier(s, s.region, tc.addrName, lbRef, tc.netTier)
 			assert.NoError(t, err)
 			// Check whether the address still exists.
-			_, err = s.GetRegionAddress(tc.addrName, region)
+			_, err = s.GetRegionAddress(tc.addrName, s.region)
 			if tc.expectDelete {
 				assert.True(t, isNotFound(err))
 			} else {
@@ -285,27 +275,23 @@ func createExternalLoadBalancer(gce *GCECloud, nodeNames []string, clusterName,
 }
 
 func TestEnsureExternalLoadBalancer(t *testing.T) {
-	projectID := "test-project"
+	vals := DefaultTestClusterValues()
-	region := "us-central1"
-	zoneName := "us-central1-b"
-	clusterName := "Test Cluster Name"
-	clusterID := "test-cluster-id"
 	nodeName := "test-node-1"
 
-	gce, err := fakeGCECloud(projectID, region, zoneName)
+	gce, err := fakeGCECloud(vals)
 	require.NoError(t, err)
 
-	status, err := createExternalLoadBalancer(gce, []string{nodeName}, clusterName, clusterID, zoneName)
+	status, err := createExternalLoadBalancer(gce, []string{nodeName}, vals.ClusterName, vals.ClusterID, vals.ZoneName)
 	assert.NoError(t, err)
 	assert.NotEmpty(t, status.Ingress)
 
 	lbName := cloudprovider.GetLoadBalancerName(fakeApiService)
-	hcName := MakeNodesHealthCheckName(clusterID)
+	hcName := MakeNodesHealthCheckName(vals.ClusterID)
 
 	// Check that Firewalls are created for the LoadBalancer and the HealthCheck
 	fwNames := []string{
 		MakeFirewallName(lbName),
-		MakeHealthCheckFirewallName(clusterID, hcName, true),
+		MakeHealthCheckFirewallName(vals.ClusterID, hcName, true),
 	}
 
 	for _, fwName := range fwNames {
@@ -316,7 +302,7 @@ func TestEnsureExternalLoadBalancer(t *testing.T) {
 	}
 
 	// Check that TargetPool is Created
-	pool, err := gce.GetTargetPool(lbName, region)
+	pool, err := gce.GetTargetPool(lbName, gce.region)
 	require.NoError(t, err)
 	assert.Equal(t, lbName, pool.Name)
 	assert.NotEmpty(t, pool.HealthChecks)
@@ -328,7 +314,7 @@ func TestEnsureExternalLoadBalancer(t *testing.T) {
 	assert.Equal(t, hcName, healthcheck.Name)
 
 	// Check that ForwardingRule is created
-	fwdRule, err := gce.GetRegionForwardingRule(lbName, region)
+	fwdRule, err := gce.GetRegionForwardingRule(lbName, gce.region)
 	require.NoError(t, err)
 	assert.Equal(t, lbName, fwdRule.Name)
 	assert.Equal(t, "TCP", fwdRule.IPProtocol)
@@ -336,22 +322,17 @@ func TestEnsureExternalLoadBalancer(t *testing.T) {
 }
 
 func TestUpdateExternalLoadBalancer(t *testing.T) {
-	projectID := "test-project"
+	vals := DefaultTestClusterValues()
-	region := "us-central1"
-	zoneName := "us-central1-b"
-	clusterName := "Test Cluster Name"
-	clusterID := "test-cluster-1"
-
 	nodeName := "test-node-1"
 
-	gce, err := fakeGCECloud(projectID, region, zoneName)
+	gce, err := fakeGCECloud((DefaultTestClusterValues()))
 	require.NoError(t, err)
 
-	_, err = createExternalLoadBalancer(gce, []string{nodeName}, clusterName, clusterID, zoneName)
+	_, err = createExternalLoadBalancer(gce, []string{nodeName}, vals.ClusterName, vals.ClusterID, vals.ZoneName)
 	assert.NoError(t, err)
 
 	newNodeName := "test-node-2"
-	newNodes, err := createAndInsertNodes(gce, []string{nodeName, newNodeName}, zoneName)
+	newNodes, err := createAndInsertNodes(gce, []string{nodeName, newNodeName}, vals.ZoneName)
 	assert.NoError(t, err)
 
 	// Add the new node, then check that it is properly added to the TargetPool
@@ -360,64 +341,59 @@ func TestUpdateExternalLoadBalancer(t *testing.T) {
 
 	lbName := cloudprovider.GetLoadBalancerName(fakeApiService)
 
-	pool, err := gce.GetTargetPool(lbName, region)
+	pool, err := gce.GetTargetPool(lbName, gce.region)
 	require.NoError(t, err)
 
 	// TODO: when testify is updated to v1.2.0+, use ElementsMatch instead
 	assert.Contains(
 		t,
 		pool.Instances,
-		fmt.Sprintf("/zones/%s/instances/%s", zoneName, nodeName),
+		fmt.Sprintf("/zones/%s/instances/%s", vals.ZoneName, nodeName),
 	)
 
 	assert.Contains(
 		t,
 		pool.Instances,
-		fmt.Sprintf("/zones/%s/instances/%s", zoneName, newNodeName),
+		fmt.Sprintf("/zones/%s/instances/%s", vals.ZoneName, newNodeName),
 	)
 
-	newNodes, err = createAndInsertNodes(gce, []string{nodeName}, zoneName)
+	newNodes, err = createAndInsertNodes(gce, []string{nodeName}, vals.ZoneName)
 	assert.NoError(t, err)
 
 	// Remove the new node by calling updateExternalLoadBalancer with a list
 	// only containing the old node, and test that the TargetPool no longer
 	// contains the new node.
-	err = gce.updateExternalLoadBalancer(clusterName, fakeApiService, newNodes)
+	err = gce.updateExternalLoadBalancer(vals.ClusterName, fakeApiService, newNodes)
 	assert.NoError(t, err)
 
-	pool, err = gce.GetTargetPool(lbName, region)
+	pool, err = gce.GetTargetPool(lbName, gce.region)
 	require.NoError(t, err)
 
 	assert.Equal(
 		t,
-		[]string{fmt.Sprintf("/zones/%s/instances/%s", zoneName, nodeName)},
+		[]string{fmt.Sprintf("/zones/%s/instances/%s", vals.ZoneName, nodeName)},
 		pool.Instances,
 	)
 }
 
 func TestEnsureExternalLoadBalancerDeleted(t *testing.T) {
-	projectID := "test-project"
+	vals := DefaultTestClusterValues()
-	region := "us-central1"
+	gce, err := fakeGCECloud(vals)
-	zoneName := "us-central1-b"
-	clusterName := "Test Cluster Name"
-	clusterID := "test-cluster-id"
-
-	gce, err := fakeGCECloud(projectID, region, zoneName)
 	require.NoError(t, err)
 
-	_, err = createExternalLoadBalancer(gce, []string{"test-node-1"}, clusterName, clusterID, zoneName)
+	_, err = createExternalLoadBalancer(gce, []string{"test-node-1"}, vals.ClusterName, vals.ClusterID, vals.ZoneName)
 	assert.NoError(t, err)
 
-	err = gce.ensureExternalLoadBalancerDeleted(clusterName, clusterID, fakeApiService)
+	err = gce.ensureExternalLoadBalancerDeleted(vals.ClusterName, vals.ClusterID, fakeApiService)
 	assert.NoError(t, err)
 
 	lbName := cloudprovider.GetLoadBalancerName(fakeApiService)
-	hcName := MakeNodesHealthCheckName(clusterID)
+	hcName := MakeNodesHealthCheckName(vals.ClusterID)
 
 	// Check that Firewalls are deleted for the LoadBalancer and the HealthCheck
 	fwNames := []string{
 		MakeFirewallName(lbName),
-		MakeHealthCheckFirewallName(clusterID, hcName, true),
+		MakeHealthCheckFirewallName(vals.ClusterID, hcName, true),
 	}
 
 	for _, fwName := range fwNames {
@@ -427,7 +403,7 @@ func TestEnsureExternalLoadBalancerDeleted(t *testing.T) {
 	}
 
 	// Check that TargetPool is deleted
-	pool, err := gce.GetTargetPool(lbName, region)
+	pool, err := gce.GetTargetPool(lbName, gce.region)
 	require.Error(t, err)
 	assert.Nil(t, pool)
 
@@ -437,19 +413,14 @@ func TestEnsureExternalLoadBalancerDeleted(t *testing.T) {
 	assert.Nil(t, healthcheck)
 
 	// Check forwarding rule is deleted
-	fwdRule, err := gce.GetRegionForwardingRule(lbName, region)
+	fwdRule, err := gce.GetRegionForwardingRule(lbName, gce.region)
 	require.Error(t, err)
 	assert.Nil(t, fwdRule)
 }
 
 func TestLoadBalancerWrongTierResourceDeletion(t *testing.T) {
-	projectID := "test-project"
+	vals := DefaultTestClusterValues()
-	region := "us-central1"
+	gce, err := fakeGCECloud(vals)
-	zoneName := "us-central1-b"
-	clusterName := "Test Cluster Name"
-	clusterID := "test-cluster-id"
-
-	gce, err := fakeGCECloud(projectID, region, zoneName)
 	require.NoError(t, err)
 
 	// Enable the cloud.NetworkTiers feature
@@ -469,7 +440,7 @@ func TestLoadBalancerWrongTierResourceDeletion(t *testing.T) {
 		gce,
 		lbName,
 		serviceName.String(),
-		region,
+		gce.region,
 		"",
 		gce.targetPoolURL(lbName),
 		fakeApiService.Spec.Ports,
@@ -483,18 +454,18 @@ func TestLoadBalancerWrongTierResourceDeletion(t *testing.T) {
 		NetworkTier: cloud.NetworkTierStandard.ToGCEValue(),
 	}
 
-	err = gce.ReserveAlphaRegionAddress(addressObj, region)
+	err = gce.ReserveAlphaRegionAddress(addressObj, gce.region)
 	require.NoError(t, err)
 
-	_, err = createExternalLoadBalancer(gce, []string{"test-node-1"}, clusterName, clusterID, zoneName)
+	_, err = createExternalLoadBalancer(gce, []string{"test-node-1"}, vals.ClusterName, vals.ClusterID, vals.ZoneName)
 	require.NoError(t, err)
 
 	// Expect forwarding rule tier to not be Standard
-	tier, err := gce.getNetworkTierFromForwardingRule(lbName, region)
+	tier, err := gce.getNetworkTierFromForwardingRule(lbName, gce.region)
 	assert.NoError(t, err)
 	assert.Equal(t, cloud.NetworkTierDefault.ToGCEValue(), tier)
 
 	// Expect address to be deleted
-	_, err = gce.GetRegionAddress(lbName, region)
+	_, err = gce.GetRegionAddress(lbName, gce.region)
 	assert.True(t, isNotFound(err))
 }

pkg/cloudprovider/providers/gce/gce_loadbalancer_internal_test.go

@@ -51,17 +51,17 @@ func TestEnsureInternalBackendServiceUpdates(t *testing.T) {
 	vals := DefaultTestClusterValues()
 	nodeNames := []string{"test-node-1"}
 
-	gce, err := fakeGCECloud(projectID, region, zoneName)
+	gce, err := fakeGCECloud(vals)
 	require.NoError(t, err)
 
 	lbName := cloudprovider.GetLoadBalancerName(fakeApiService)
-	nodes, err := createAndInsertNodes(gce, nodeNames, zoneName)
+	nodes, err := createAndInsertNodes(gce, nodeNames, vals.ZoneName)
-	igName := makeInstanceGroupName(clusterID)
+	igName := makeInstanceGroupName(vals.ClusterID)
 	igLinks, err := gce.ensureInternalInstanceGroups(igName, nodes)
 	require.NoError(t, err)
 
 	sharedBackend := shareBackendService(fakeApiService)
-	bsName := makeBackendServiceName(lbName, clusterID, sharedBackend, cloud.SchemeInternal, "TCP", fakeApiService.Spec.SessionAffinity)
+	bsName := makeBackendServiceName(lbName, vals.ClusterID, sharedBackend, cloud.SchemeInternal, "TCP", fakeApiService.Spec.SessionAffinity)
 	err = gce.ensureInternalBackendService(bsName, "description", fakeApiService.Spec.SessionAffinity, cloud.SchemeInternal, "TCP", igLinks, "")
 	require.NoError(t, err)
 
@@ -75,23 +75,20 @@ func TestEnsureInternalBackendServiceUpdates(t *testing.T) {
 }
 
 func TestEnsureInternalBackendServiceGroups(t *testing.T) {
-	projectID := "test-project"
+	vals := DefaultTestClusterValues()
-	region := "us-central1"
-	zoneName := "us-central1-b"
-	clusterID := "test-cluster-id"
 	nodeNames := []string{"test-node-1"}
 
-	gce, err := fakeGCECloud(projectID, region, zoneName)
+	gce, err := fakeGCECloud(vals)
 	require.NoError(t, err)
 
 	lbName := cloudprovider.GetLoadBalancerName(fakeApiService)
-	nodes, err := createAndInsertNodes(gce, nodeNames, zoneName)
+	nodes, err := createAndInsertNodes(gce, nodeNames, vals.ZoneName)
-	igName := makeInstanceGroupName(clusterID)
+	igName := makeInstanceGroupName(vals.ClusterID)
 	igLinks, err := gce.ensureInternalInstanceGroups(igName, nodes)
 	require.NoError(t, err)
 
 	sharedBackend := shareBackendService(fakeApiService)
-	bsName := makeBackendServiceName(lbName, clusterID, sharedBackend, cloud.SchemeInternal, "TCP", fakeApiService.Spec.SessionAffinity)
+	bsName := makeBackendServiceName(lbName, vals.ClusterID, sharedBackend, cloud.SchemeInternal, "TCP", fakeApiService.Spec.SessionAffinity)
 	err = gce.ensureInternalBackendService(bsName, "description", fakeApiService.Spec.SessionAffinity, cloud.SchemeInternal, "TCP", igLinks, "")
 	require.NoError(t, err)
 
@@ -104,39 +101,35 @@ func TestEnsureInternalBackendServiceGroups(t *testing.T) {
 	assert.NoError(t, err)
 
 	// Check that the instances are updated
-	newNodes, err := createAndInsertNodes(gce, newNodeNames, zoneName)
+	newNodes, err := createAndInsertNodes(gce, newNodeNames, vals.ZoneName)
 	newIgLinks, err := gce.ensureInternalInstanceGroups(igName, newNodes)
 	backends := backendsFromGroupLinks(newIgLinks)
 	assert.Equal(t, bs.Backends, backends)
 }
 
 func TestEnsureInternalLoadBalancer(t *testing.T) {
-	projectID := "test-project"
+	vals := DefaultTestClusterValues()
-	region := "us-central1"
-	zoneName := "us-central1-b"
-	clusterName := "Test Cluster"
-	clusterID := "test-cluster-id"
 	nodeName := "test-node-1"
 
-	gce, err := fakeGCECloud(projectID, region, zoneName)
+	gce, err := fakeGCECloud(vals)
 	require.NoError(t, err)
 
-	status, err := createInternalLoadBalancer(gce, nil, []string{nodeName}, clusterName, clusterID, zoneName)
+	status, err := createInternalLoadBalancer(gce, nil, []string{nodeName}, vals.ClusterName, vals.ClusterID, vals.ZoneName)
 	assert.NoError(t, err)
 	assert.NotEmpty(t, status.Ingress)
 
 	lbName := cloudprovider.GetLoadBalancerName(fakeApiService)
 
 	// Check that Instance Group is created
-	igName := makeInstanceGroupName(clusterID)
+	igName := makeInstanceGroupName(vals.ClusterID)
-	ig, err := gce.GetInstanceGroup(igName, zoneName)
+	ig, err := gce.GetInstanceGroup(igName, vals.ZoneName)
 	assert.NoError(t, err)
 	assert.Equal(t, igName, ig.Name)
 
 	// Check that Firewalls are created for the LoadBalancer and the HealthCheck
 	fwNames := []string{
 		lbName,
-		makeHealthCheckFirewallName(lbName, clusterID, true),
+		makeHealthCheckFirewallName(lbName, vals.ClusterID, true),
 	}
 
 	for _, fwName := range fwNames {
@@ -148,14 +141,14 @@ func TestEnsureInternalLoadBalancer(t *testing.T) {
 
 	// Check that HealthCheck is created
 	sharedHealthCheck := !v1_service.RequestsOnlyLocalTraffic(fakeApiService)
-	hcName := makeHealthCheckName(lbName, clusterID, sharedHealthCheck)
+	hcName := makeHealthCheckName(lbName, vals.ClusterID, sharedHealthCheck)
 	healthcheck, err := gce.GetHealthCheck(hcName)
 	require.NoError(t, err)
 	assert.Equal(t, hcName, healthcheck.Name)
 
 	// Check that BackendService exists
 	sharedBackend := shareBackendService(fakeApiService)
-	backendServiceName := makeBackendServiceName(lbName, clusterID, sharedBackend, cloud.SchemeInternal, "TCP", fakeApiService.Spec.SessionAffinity)
+	backendServiceName := makeBackendServiceName(lbName, vals.ClusterID, sharedBackend, cloud.SchemeInternal, "TCP", fakeApiService.Spec.SessionAffinity)
 	backendServiceLink := gce.getBackendServiceLink(backendServiceName)
 
 	bs, err := gce.GetRegionBackendService(backendServiceName, gce.region)
@@ -168,7 +161,7 @@ func TestEnsureInternalLoadBalancer(t *testing.T) {
 	)
 
 	// Check that ForwardingRule is created
-	fwdRule, err := gce.GetRegionForwardingRule(lbName, region)
+	fwdRule, err := gce.GetRegionForwardingRule(lbName, gce.region)
 	require.NoError(t, err)
 	assert.Equal(t, lbName, fwdRule.Name)
 	assert.Equal(t, "TCP", fwdRule.IPProtocol)
@@ -178,14 +171,10 @@ func TestEnsureInternalLoadBalancer(t *testing.T) {
 }
 
 func TestEnsureInternalLoadBalancerWithExistingResources(t *testing.T) {
-	projectID := "test-project"
+	vals := DefaultTestClusterValues()
-	region := "us-central1"
-	zoneName := "us-central1-b"
-	clusterName := "Test Cluster"
-	clusterID := "test-cluster-id"
 	nodeNames := []string{"test-node-1"}
 
-	gce, err := fakeGCECloud(projectID, region, zoneName)
+	gce, err := fakeGCECloud(vals)
 	require.NoError(t, err)
 
 	// Create the expected resources necessary for an Internal Load Balancer
@@ -193,35 +182,30 @@ func TestEnsureInternalLoadBalancerWithExistingResources(t *testing.T) {
 	lbName := cloudprovider.GetLoadBalancerName(fakeApiService)
 
 	sharedHealthCheck := !v1_service.RequestsOnlyLocalTraffic(fakeApiService)
-	hcName := makeHealthCheckName(lbName, clusterID, sharedHealthCheck)
+	hcName := makeHealthCheckName(lbName, vals.ClusterID, sharedHealthCheck)
 	hcPath, hcPort := GetNodesHealthCheckPath(), GetNodesHealthCheckPort()
 	existingHC := newInternalLBHealthCheck(hcName, nm, sharedHealthCheck, hcPath, hcPort)
 	err = gce.CreateHealthCheck(existingHC)
 	require.NoError(t, err)
 
-	nodes, err := createAndInsertNodes(gce, nodeNames, zoneName)
+	nodes, err := createAndInsertNodes(gce, nodeNames, vals.ZoneName)
-	igName := makeInstanceGroupName(clusterID)
+	igName := makeInstanceGroupName(vals.ClusterID)
 	igLinks, err := gce.ensureInternalInstanceGroups(igName, nodes)
 	require.NoError(t, err)
 
 	sharedBackend := shareBackendService(fakeApiService)
 	bsDescription := makeBackendServiceDescription(nm, sharedBackend)
-	bsName := makeBackendServiceName(lbName, clusterID, sharedBackend, cloud.SchemeInternal, "TCP", fakeApiService.Spec.SessionAffinity)
+	bsName := makeBackendServiceName(lbName, vals.ClusterID, sharedBackend, cloud.SchemeInternal, "TCP", fakeApiService.Spec.SessionAffinity)
 	err = gce.ensureInternalBackendService(bsName, bsDescription, fakeApiService.Spec.SessionAffinity, cloud.SchemeInternal, "TCP", igLinks, existingHC.SelfLink)
 	require.NoError(t, err)
 
-	_, err = createInternalLoadBalancer(gce, nil, nodeNames, clusterName, clusterID, zoneName)
+	_, err = createInternalLoadBalancer(gce, nil, nodeNames, vals.ClusterName, vals.ClusterID, vals.ZoneName)
 	assert.NoError(t, err)
 }
 
 func TestEnsureInternalLoadBalancerClearPreviousResources(t *testing.T) {
-	projectID := "test-project"
+	vals := DefaultTestClusterValues()
-	region := "us-central1"
+	gce, err := fakeGCECloud(vals)
-	zoneName := "us-central1-b"
-	clusterName := "Test Cluster"
-	clusterID := "test-cluster-id"
-
-	gce, err := fakeGCECloud(projectID, region, zoneName)
 	require.NoError(t, err)
 
 	lbName := cloudprovider.GetLoadBalancerName(fakeApiService)
@@ -250,7 +234,7 @@ func TestEnsureInternalLoadBalancerClearPreviousResources(t *testing.T) {
 	gce.CreateFirewall(existingFirewall)
 
 	sharedHealthCheck := !v1_service.RequestsOnlyLocalTraffic(fakeApiService)
-	hcName := makeHealthCheckName(lbName, clusterID, sharedHealthCheck)
+	hcName := makeHealthCheckName(lbName, vals.ClusterID, sharedHealthCheck)
 	hcPath, hcPort := GetNodesHealthCheckPath(), GetNodesHealthCheckPort()
 	nm := types.NamespacedName{Name: fakeApiService.Name, Namespace: fakeApiService.Namespace}
 
@@ -261,7 +245,7 @@ func TestEnsureInternalLoadBalancerClearPreviousResources(t *testing.T) {
 
 	// Create a backend Service that's missing Description and Backends
 	sharedBackend := shareBackendService(fakeApiService)
-	backendServiceName := makeBackendServiceName(lbName, clusterID, sharedBackend, cloud.SchemeInternal, "TCP", fakeApiService.Spec.SessionAffinity)
+	backendServiceName := makeBackendServiceName(lbName, vals.ClusterID, sharedBackend, cloud.SchemeInternal, "TCP", fakeApiService.Spec.SessionAffinity)
 	existingBS := &compute.BackendService{
 		Name:                lbName,
 		Protocol:            "TCP",
@@ -273,7 +257,7 @@ func TestEnsureInternalLoadBalancerClearPreviousResources(t *testing.T) {
 	gce.CreateRegionBackendService(existingBS, gce.region)
 	existingFwdRule.BackendService = existingBS.Name
 
-	_, err = createInternalLoadBalancer(gce, existingFwdRule, []string{"test-node-1"}, clusterName, clusterID, zoneName)
+	_, err = createInternalLoadBalancer(gce, existingFwdRule, []string{"test-node-1"}, vals.ClusterName, vals.ClusterID, vals.ZoneName)
 	assert.NoError(t, err)
 
 	// Expect new resources with the correct attributes to be created
@@ -294,18 +278,13 @@ func TestEnsureInternalLoadBalancerClearPreviousResources(t *testing.T) {
 }
 
 func TestUpdateInternalLoadBalancerBackendServices(t *testing.T) {
-	projectID := "test-project"
+	vals := DefaultTestClusterValues()
-	region := "us-central1"
-	zoneName := "us-central1-b"
-	clusterName := "Test Cluster Name"
-	clusterID := "test-cluster-id"
-
 	nodeName := "test-node-1"
 
-	gce, err := fakeGCECloud(projectID, region, zoneName)
+	gce, err := fakeGCECloud(vals)
 	require.NoError(t, err)
 
-	_, err = createInternalLoadBalancer(gce, nil, []string{"test-node-1"}, clusterName, clusterID, zoneName)
+	_, err = createInternalLoadBalancer(gce, nil, []string{"test-node-1"}, vals.ClusterName, vals.ClusterID, vals.ZoneName)
 	assert.NoError(t, err)
 
 	// BackendService exists prior to updateInternalLoadBalancer call, but has
@@ -314,7 +293,7 @@ func TestUpdateInternalLoadBalancerBackendServices(t *testing.T) {
 	// BackendService
 	lbName := cloudprovider.GetLoadBalancerName(fakeApiService)
 	sharedBackend := shareBackendService(fakeApiService)
-	backendServiceName := makeBackendServiceName(lbName, clusterID, sharedBackend, cloud.SchemeInternal, "TCP", fakeApiService.Spec.SessionAffinity)
+	backendServiceName := makeBackendServiceName(lbName, vals.ClusterID, sharedBackend, cloud.SchemeInternal, "TCP", fakeApiService.Spec.SessionAffinity)
 	existingBS := &compute.BackendService{
 		Name:                backendServiceName,
 		Protocol:            "TCP",
@@ -324,10 +303,10 @@ func TestUpdateInternalLoadBalancerBackendServices(t *testing.T) {
 
 	gce.CreateRegionBackendService(existingBS, gce.region)
 
-	nodes, err := createAndInsertNodes(gce, []string{nodeName}, zoneName)
+	nodes, err := createAndInsertNodes(gce, []string{nodeName}, vals.ZoneName)
 	require.NoError(t, err)
 
-	err = gce.updateInternalLoadBalancer(clusterName, clusterID, fakeApiService, nodes)
+	err = gce.updateInternalLoadBalancer(vals.ClusterName, vals.ClusterID, fakeApiService, nodes)
 	assert.NoError(t, err)
 
 	bs, err := gce.GetRegionBackendService(backendServiceName, gce.region)
@@ -351,63 +330,53 @@ func TestUpdateInternalLoadBalancerBackendServices(t *testing.T) {
 }
 
 func TestUpdateInternalLoadBalancerNodes(t *testing.T) {
-	projectID := "test-project"
+	vals := DefaultTestClusterValues()
-	region := "us-central1"
+	gce, err := fakeGCECloud(vals)
-	zoneName := "us-central1-b"
-	clusterName := "Test Cluster Name"
-	clusterID := "test-cluster-id"
-
-	gce, err := fakeGCECloud(projectID, region, zoneName)
 	require.NoError(t, err)
 
-	_, err = createInternalLoadBalancer(gce, nil, []string{"test-node-1"}, clusterName, clusterID, zoneName)
+	_, err = createInternalLoadBalancer(gce, nil, []string{"test-node-1"}, vals.ClusterName, vals.ClusterID, vals.ZoneName)
 	assert.NoError(t, err)
 
 	// Remove the old Node and insert a new Node.
 	newNodeName := "test-node-2"
-	newNodes, err := createAndInsertNodes(gce, []string{newNodeName}, zoneName)
+	newNodes, err := createAndInsertNodes(gce, []string{newNodeName}, vals.ZoneName)
 	require.NoError(t, err)
 
-	err = gce.updateInternalLoadBalancer(clusterName, clusterID, fakeApiService, newNodes)
+	err = gce.updateInternalLoadBalancer(vals.ClusterName, vals.ClusterID, fakeApiService, newNodes)
 	assert.NoError(t, err)
 
 	// Expect node 1 to be deleted and node 2 to still exist
-	igName := makeInstanceGroupName(clusterID)
+	igName := makeInstanceGroupName(vals.ClusterID)
-	instances, err := gce.ListInstancesInInstanceGroup(igName, zoneName, "ALL")
+	instances, err := gce.ListInstancesInInstanceGroup(igName, vals.ZoneName, "ALL")
 	require.NoError(t, err)
 
 	assert.Equal(t, 1, len(instances))
 	assert.Contains(
 		t,
 		instances[0].Instance,
-		fmt.Sprintf("projects/%s/zones/%s/instances/%s", projectID, zoneName, newNodeName),
+		fmt.Sprintf("projects/%s/zones/%s/instances/%s", vals.ProjectID, vals.ZoneName, newNodeName),
 	)
 }
 
 func TestEnsureInternalLoadBalancerDeleted(t *testing.T) {
-	projectID := "test-project"
+	vals := DefaultTestClusterValues()
-	region := "us-central1"
+	gce, err := fakeGCECloud(vals)
-	zoneName := "us-central1-b"
-	clusterName := "Test Cluster Name"
-	clusterID := "test-cluster-id"
-
-	gce, err := fakeGCECloud(projectID, region, zoneName)
 	require.NoError(t, err)
 
-	_, err = createInternalLoadBalancer(gce, nil, []string{"test-node-1"}, clusterName, clusterID, zoneName)
+	_, err = createInternalLoadBalancer(gce, nil, []string{"test-node-1"}, vals.ClusterName, vals.ClusterID, vals.ZoneName)
 	assert.NoError(t, err)
 
-	err = gce.ensureInternalLoadBalancerDeleted(clusterName, clusterID, fakeApiService)
+	err = gce.ensureInternalLoadBalancerDeleted(vals.ClusterName, vals.ClusterID, fakeApiService)
 	assert.NoError(t, err)
 
 	lbName := cloudprovider.GetLoadBalancerName(fakeApiService)
 	sharedHealthCheck := !v1_service.RequestsOnlyLocalTraffic(fakeApiService)
-	hcName := makeHealthCheckName(lbName, clusterID, sharedHealthCheck)
+	hcName := makeHealthCheckName(lbName, vals.ClusterID, sharedHealthCheck)
 
 	// Check that Firewalls are deleted for the LoadBalancer and the HealthCheck
 	fwNames := []string{
 		MakeFirewallName(lbName),
-		MakeHealthCheckFirewallName(clusterID, hcName, true),
+		MakeHealthCheckFirewallName(vals.ClusterID, hcName, true),
 	}
 
 	for _, fwName := range fwNames {
@@ -417,8 +386,8 @@ func TestEnsureInternalLoadBalancerDeleted(t *testing.T) {
 	}
 
 	// Check that Instance Group is deleted
-	igName := makeInstanceGroupName(clusterID)
+	igName := makeInstanceGroupName(vals.ClusterID)
-	ig, err := gce.GetInstanceGroup(igName, zoneName)
+	ig, err := gce.GetInstanceGroup(igName, vals.ZoneName)
 	assert.Error(t, err)
 	assert.Nil(t, ig)
 
@@ -428,28 +397,23 @@ func TestEnsureInternalLoadBalancerDeleted(t *testing.T) {
 	assert.Nil(t, healthcheck)
 
 	// Check forwarding rule is deleted
-	fwdRule, err := gce.GetRegionForwardingRule(lbName, region)
+	fwdRule, err := gce.GetRegionForwardingRule(lbName, gce.region)
 	require.Error(t, err)
 	assert.Nil(t, fwdRule)
 }
 
 func TestEnsureInternalLoadBalancerDeletedTwiceDoesNotError(t *testing.T) {
-	projectID := "test-project"
+	vals := DefaultTestClusterValues()
-	region := "us-central1"
+	gce, err := fakeGCECloud(vals)
-	zoneName := "us-central1-b"
-	clusterName := "Test Cluster Name"
-	clusterID := "test-cluster-id"
-
-	gce, err := fakeGCECloud(projectID, region, zoneName)
 	require.NoError(t, err)
 
-	_, err = createInternalLoadBalancer(gce, nil, []string{"test-node-1"}, clusterName, clusterID, zoneName)
+	_, err = createInternalLoadBalancer(gce, nil, []string{"test-node-1"}, vals.ClusterName, vals.ClusterID, vals.ZoneName)
 	assert.NoError(t, err)
 
-	err = gce.ensureInternalLoadBalancerDeleted(clusterName, clusterID, fakeApiService)
+	err = gce.ensureInternalLoadBalancerDeleted(vals.ClusterName, vals.ClusterID, fakeApiService)
 	assert.NoError(t, err)
 
 	// Deleting the loadbalancer and resources again should not cause an error.
-	err = gce.ensureInternalLoadBalancerDeleted(clusterName, clusterID, fakeApiService)
+	err = gce.ensureInternalLoadBalancerDeleted(vals.ClusterName, vals.ClusterID, fakeApiService)
 	assert.NoError(t, err)
 }

pkg/cloudprovider/providers/gce/gce_loadbalancer_utils_test.go

@@ -34,6 +34,24 @@ import (
 	kubeletapis "k8s.io/kubernetes/pkg/kubelet/apis"
 )
 
+type TestClusterValues struct {
+	ProjectID   string
+	Region      string
+	ZoneName    string
+	ClusterID   string
+	ClusterName string
+}
+
+func DefaultTestClusterValues() TestClusterValues {
+	return TestClusterValues{
+		ProjectID:   "test-project",
+		Region:      "us-central1",
+		ZoneName:    "us-central1-b",
+		ClusterID:   "test-cluster-id",
+		ClusterName: "Test Cluster Name",
+	}
+}
+
 var fakeApiService = &v1.Service{
 	Spec: v1.ServiceSpec{
 		SessionAffinity: v1.ServiceAffinityClientIP,
@@ -48,7 +66,7 @@ func (*fakeRoundTripper) RoundTrip(*http.Request) (*http.Response, error) {
 	return nil, fmt.Errorf("err: test used fake http client")
 }
 
-func fakeGCECloud(projectID, region, zoneName string) (*GCECloud, error) {
+func fakeGCECloud(vals TestClusterValues) (*GCECloud, error) {
 	client := &http.Client{Transport: &fakeRoundTripper{}}
 
 	service, err := compute.New(client)
@@ -57,8 +75,8 @@ func fakeGCECloud(projectID, region, zoneName string) (*GCECloud, error) {
 	}
 
 	// Used in disk unit tests
-	fakeManager := newFakeManager(projectID, region)
+	fakeManager := newFakeManager(vals.ProjectID, vals.Region)
-	zonesWithNodes := createNodeZones([]string{zoneName})
+	zonesWithNodes := createNodeZones([]string{vals.ZoneName})
 
 	alphaFeatureGate, err := NewAlphaFeatureGate([]string{})
 	if err != nil {
@@ -66,12 +84,12 @@ func fakeGCECloud(projectID, region, zoneName string) (*GCECloud, error) {
 	}
 
 	gce := &GCECloud{
-		region:             region,
+		region:             vals.Region,
 		service:            service,
 		manager:            fakeManager,
-		managedZones:       []string{zoneName},
+		managedZones:       []string{vals.ZoneName},
-		projectID:          projectID,
+		projectID:          vals.ProjectID,
-		networkProjectID:   projectID,
+		networkProjectID:   vals.ProjectID,
 		AlphaFeatureGate:   alphaFeatureGate,
 		nodeZones:          zonesWithNodes,
 		nodeInformerSynced: func() bool { return true },
@@ -94,7 +112,7 @@ func fakeGCECloud(projectID, region, zoneName string) (*GCECloud, error) {
 
 	keyGA := meta.GlobalKey("key-ga")
 	c.MockZones.Objects[*keyGA] = &cloud.MockZonesObj{
-		Obj: &compute.Zone{Name: zoneName, Region: gce.getRegionLink(region)},
+		Obj: &compute.Zone{Name: vals.ZoneName, Region: gce.getRegionLink(vals.Region)},
 	}
 
 	gce.c = c