[API Update & Refactor] ELB

acceptance/openstack/elb/v3/certificates_test.go

@@ -30,22 +30,23 @@ func TestCertificateLifecycle(t *testing.T) {
 	th.AssertNoErr(t, err)
 
 	certificateID := createCertificate(t, client)
-	defer deleteCertificate(t, client, certificateID)
+	t.Cleanup(func() {
+		deleteCertificate(t, client, certificateID)
+	})
 
 	t.Logf("Attempting to update ELBv3 certificate: %s", certificateID)
 	certName := tools.RandomString("update-cert-", 3)
-	emptyDescription := ""
 	updateOpts := certificates.UpdateOpts{
 		Name:        certName,
-		Description: &emptyDescription,
+		Description: "",
 	}
 
-	_, err = certificates.Update(client, certificateID, updateOpts).Extract()
+	_, err = certificates.Update(client, certificateID, updateOpts)
 	th.AssertNoErr(t, err)
 	t.Logf("Updated ELBv3 certificate: %s", certificateID)
 
-	newCertificate, err := certificates.Get(client, certificateID).Extract()
+	newCertificate, err := certificates.Get(client, certificateID)
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, updateOpts.Name, newCertificate.Name)
-	th.AssertEquals(t, emptyDescription, newCertificate.Description)
+	th.AssertEquals(t, "", newCertificate.Description)
 }

acceptance/openstack/elb/v3/flavors_test.go

@@ -19,7 +19,7 @@ func TestFlavorsList(t *testing.T) {
 	flavorsList, err := flavors.ExtractFlavors(flavorsPages)
 	th.AssertNoErr(t, err)
 
-	zeroFlavor, err := flavors.Get(client, flavorsList[0].ID).Extract()
+	zeroFlavor, err := flavors.Get(client, flavorsList[0].ID)
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, zeroFlavor, &flavorsList[0])
 }

acceptance/openstack/elb/v3/helpers.go

@@ -50,7 +50,7 @@ func createLoadBalancer(t *testing.T, client *golangsdk.ServiceClient) string {
 		IpTargetEnable: &ipTargetEnable,
 	}
 
-	loadbalancer, err := loadbalancers.Create(client, createOpts).Extract()
+	loadbalancer, err := loadbalancers.Create(client, createOpts)
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, createOpts.Name, loadbalancer.Name)
 	th.AssertEquals(t, createOpts.Description, loadbalancer.Description)
@@ -61,7 +61,7 @@ func createLoadBalancer(t *testing.T, client *golangsdk.ServiceClient) string {
 
 func deleteLoadbalancer(t *testing.T, client *golangsdk.ServiceClient, loadbalancerID string) {
 	t.Logf("Attempting to delete ELBv3 LoadBalancer: %s", loadbalancerID)
-	err := loadbalancers.Delete(client, loadbalancerID).ExtractErr()
+	err := loadbalancers.Delete(client, loadbalancerID)
 	th.AssertNoErr(t, err)
 	t.Logf("Deleted ELBv3 LoadBalancer: %s", loadbalancerID)
 }
@@ -130,7 +130,7 @@ i1YhgnQbn5E0hz55OLu5jvOkKQjPCW+8Kg==
 		Certificate: cert,
 	}
 
-	certificate, err := certificates.Create(client, createOpts).Extract()
+	certificate, err := certificates.Create(client, createOpts)
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, createOpts.Name, certificate.Name)
 	th.AssertEquals(t, createOpts.Description, certificate.Description)
@@ -141,7 +141,7 @@ i1YhgnQbn5E0hz55OLu5jvOkKQjPCW+8Kg==
 
 func deleteCertificate(t *testing.T, client *golangsdk.ServiceClient, certificateID string) {
 	t.Logf("Attempting to delete ELBv3 certificate: %s", certificateID)
-	err := certificates.Delete(client, certificateID).ExtractErr()
+	err := certificates.Delete(client, certificateID)
 	th.AssertNoErr(t, err)
 	t.Logf("Deleted ELBv3 certificate: %s", certificateID)
 }
@@ -151,46 +151,46 @@ func createPool(t *testing.T, client *golangsdk.ServiceClient, loadbalancerID st
 	vpcID := clients.EnvOS.GetEnv("VPC_ID")
 	poolName := tools.RandomString("create-pool-", 3)
 	createOpts := pools.CreateOpts{
-		LBMethod:                 "LEAST_CONNECTIONS",
-		Protocol:                 "HTTP",
-		LoadbalancerID:           loadbalancerID,
-		Name:                     poolName,
-		Description:              "some interesting description",
-		VpcId:                    vpcID,
-		Type:                     "instance",
-		DeletionProtectionEnable: pointerto.Bool(true),
+		LbAlgorithm:                    "LEAST_CONNECTIONS",
+		Protocol:                       "HTTP",
+		LoadbalancerId:                 loadbalancerID,
+		Name:                           poolName,
+		Description:                    "some interesting description",
+		VpcId:                          vpcID,
+		Type:                           "instance",
+		MemberDeletionProtectionEnable: pointerto.Bool(true),
 	}
 
-	pool, err := pools.Create(client, createOpts).Extract()
+	pool, err := pools.Create(client, createOpts)
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, createOpts.Name, pool.Name)
 	th.AssertEquals(t, createOpts.Description, pool.Description)
-	th.AssertEquals(t, createOpts.LBMethod, pool.LBMethod)
-	th.AssertEquals(t, true, pool.DeletionProtectionEnable)
+	th.AssertEquals(t, createOpts.LbAlgorithm, pool.LbAlgorithm)
+	th.AssertEquals(t, true, pool.MemberDeletionProtectionEnable)
 	th.AssertEquals(t, createOpts.Type, pool.Type)
 	th.AssertEquals(t, createOpts.VpcId, pool.VpcId)
-	t.Logf("Created ELBv3 Pool: %s", pool.ID)
+	t.Logf("Created ELBv3 Pool: %s", pool.Id)
 
-	return pool.ID
+	return pool.Id
 }
 
 func deletePool(t *testing.T, client *golangsdk.ServiceClient, poolID string) {
 	t.Logf("Attempting to delete ELBv3 Pool: %s", poolID)
-	err := pools.Delete(client, poolID).ExtractErr()
+	err := pools.Delete(client, poolID)
 	th.AssertNoErr(t, err)
 	t.Logf("Deleted ELBv3 Pool: %s", poolID)
 }
 
 func createListener(t *testing.T, client *golangsdk.ServiceClient, loadbalancerID string) string {
 	listener, err := listeners.Create(client, listeners.CreateOpts{
 		LoadbalancerID: loadbalancerID,
-		Protocol:       listeners.ProtocolHTTP,
+		Protocol:       "HTTP",
 		ProtocolPort:   80,
-	}).Extract()
+	})
 	th.AssertNoErr(t, err)
 	return listener.ID
 }
 
 func deleteListener(t *testing.T, client *golangsdk.ServiceClient, listenerID string) {
-	th.AssertNoErr(t, listeners.Delete(client, listenerID).ExtractErr())
+	th.AssertNoErr(t, listeners.Delete(client, listenerID))
 }

acceptance/openstack/elb/v3/ipgroups_test.go

@@ -15,8 +15,9 @@ func TestIpGroupList(t *testing.T) {
 	client, err := clients.NewElbV3Client()
 	th.AssertNoErr(t, err)
 
-	listOpts := ipgroups.ListOpts{}
-	ipgroupsList, err := ipgroups.List(client, listOpts)
+	ipgroupsLists, err := ipgroups.List(client, ipgroups.ListOpts{}).AllPages()
+	th.AssertNoErr(t, err)
+	ipgroupsList, err := ipgroups.ExtractIpGroups(ipgroupsLists)
 	th.AssertNoErr(t, err)
 
 	for _, gr := range ipgroupsList {
@@ -29,20 +30,19 @@ func TestIpGroupsLifecycle(t *testing.T) {
 	th.AssertNoErr(t, err)
 
 	loadbalancerID := createLoadBalancer(t, client)
-	defer deleteLoadbalancer(t, client, loadbalancerID)
+	t.Cleanup(func() {
+		deleteLoadbalancer(t, client, loadbalancerID)
+	})
 
-	ipGroupOpts := ipgroups.IpGroupOption{
-		Ip:          "192.168.10.10",
-		Description: "first",
-	}
-	ipGroupName := tools.RandomString("create-ip-group-", 3)
-	createOpts := ipgroups.CreateOpts{
-		Description: "some interesting description",
-		Name:        ipGroupName,
-		IpList:      []ipgroups.IpGroupOption{ipGroupOpts},
-	}
 	t.Logf("Attempting to create ELBv3 IpGroup")
-	ipGroup, err := ipgroups.Create(client, createOpts)
+	ipGroup, err := ipgroups.Create(client, ipgroups.CreateOpts{
+		Description: "some interesting description",
+		Name:        tools.RandomString("create-ip-group-", 3),
+		IpList: []ipgroups.IpGroupOption{ipgroups.IpGroupOption{
+			Ip:          "192.168.10.10",
+			Description: "first",
+		}},
+	})
 	th.AssertNoErr(t, err)
 
 	t.Cleanup(func() {
@@ -52,9 +52,8 @@ func TestIpGroupsLifecycle(t *testing.T) {
 	})
 
 	t.Logf("Attempting to update ELBv3 IpGroup: %s", ipGroup.ID)
-	ipGroupNameUpdate := tools.RandomString("update-ip-group-", 3)
-	updateOpts := ipgroups.UpdateOpts{
-		Name: ipGroupNameUpdate,
+	_, err = ipgroups.Update(client, ipGroup.ID, ipgroups.UpdateOpts{
+		Name: tools.RandomString("update-ip-group-", 3),
 		IpList: []ipgroups.IpGroupOption{
 			{
 				Ip:          "192.168.10.12",
@@ -65,34 +64,37 @@ func TestIpGroupsLifecycle(t *testing.T) {
 				Description: "fourth",
 			},
 		},
-	}
-	err = ipgroups.Update(client, ipGroup.ID, updateOpts)
+	})
 	th.AssertNoErr(t, err)
 	t.Logf("Updated ELBv3 ipGroup: %s", ipGroup.ID)
 
 	updatedIpGroup, err := ipgroups.Get(client, ipGroup.ID)
 	th.AssertNoErr(t, err)
-	th.AssertEquals(t, ipGroupNameUpdate, updatedIpGroup.Name)
+	th.AssertEquals(t, tools.RandomString("update-ip-group-", 3), updatedIpGroup.Name)
 
-	listOpts := ipgroups.ListOpts{}
-	ipGroupsSlice, err := ipgroups.List(client, listOpts)
+	ipGroupsSlices, err := ipgroups.List(client, ipgroups.ListOpts{}).AllPages()
 	th.AssertNoErr(t, err)
+	ipGroupsSlice, err := ipgroups.ExtractIpGroups(ipGroupsSlices)
+	th.AssertNoErr(t, err)
+
 	th.AssertEquals(t, 1, len(ipGroupsSlice))
 	th.AssertDeepEquals(t, *updatedIpGroup, ipGroupsSlice[0])
 
 	t.Logf("Attempting to create ELBv3 Listener with ipGroup association")
 	listener, err := listeners.Create(client, listeners.CreateOpts{
 		LoadbalancerID:  loadbalancerID,
-		Protocol:        listeners.ProtocolHTTP,
+		Protocol:        "HTTP",
 		ProtocolPort:    80,
 		EnhanceL7policy: pointerto.Bool(true),
 		IpGroup: &listeners.IpGroup{
 			IpGroupID: ipGroup.ID,
 			Enable:    pointerto.Bool(true),
 		},
-	}).Extract()
+	})
 	th.AssertNoErr(t, err)
-	defer deleteListener(t, client, listener.ID)
+	t.Cleanup(func() {
+		deleteListener(t, client, listener.ID)
+	})
 
 	updatedIpList, err := ipgroups.UpdateIpList(client, ipGroup.ID, ipgroups.UpdateOpts{
 		IpList: []ipgroups.IpGroupOption{

acceptance/openstack/elb/v3/listeners_test.go

@@ -15,10 +15,12 @@ func TestListenerLifecycle(t *testing.T) {
 	th.AssertNoErr(t, err)
 
 	loadbalancerID := createLoadBalancer(t, client)
-	defer deleteLoadbalancer(t, client, loadbalancerID)
+	t.Cleanup(func() {
+		deleteLoadbalancer(t, client, loadbalancerID)
+	})
 
 	certificateID := createCertificate(t, client)
-	defer deleteCertificate(t, client, certificateID)
+	t.Cleanup(func() { deleteCertificate(t, client, certificateID) })
 
 	t.Logf("Attempting to create ELBv3 Listener")
 	listenerName := tools.RandomString("create-listener-", 3)
@@ -38,13 +40,13 @@ func TestListenerLifecycle(t *testing.T) {
 		},
 	}
 
-	listener, err := listeners.Create(client, createOpts).Extract()
-	defer func() {
+	listener, err := listeners.Create(client, createOpts)
+	t.Cleanup(func() {
 		t.Logf("Attempting to delete ELBv3 Listener: %s", listener.ID)
-		err := listeners.Delete(client, listener.ID).ExtractErr()
+		err := listeners.Delete(client, listener.ID)
 		th.AssertNoErr(t, err)
 		t.Logf("Deleted ELBv3 Listener: %s", listener.ID)
-	}()
+	})
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, createOpts.Name, listener.Name)
 	th.AssertEquals(t, createOpts.Description, listener.Description)
@@ -58,11 +60,11 @@ func TestListenerLifecycle(t *testing.T) {
 		Name:         &listenerName,
 		SniMatchAlgo: "longest_suffix",
 	}
-	_, err = listeners.Update(client, listener.ID, updateOpts).Extract()
+	_, err = listeners.Update(client, listener.ID, updateOpts)
 	th.AssertNoErr(t, err)
 	t.Logf("Updated ELBv3 Listener: %s", listener.ID)
 
-	newListener, err := listeners.Get(client, listener.ID).Extract()
+	newListener, err := listeners.Get(client, listener.ID)
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, listenerName, newListener.Name)
 	th.AssertEquals(t, emptyDescription, newListener.Description)

acceptance/openstack/elb/v3/loadbalancers_test.go

@@ -18,7 +18,7 @@ func TestLoadBalancerList(t *testing.T) {
 	loadbalancerPages, err := loadbalancers.List(client, listOpts).AllPages()
 	th.AssertNoErr(t, err)
 
-	loadbalancerList, err := loadbalancers.ExtractLoadbalancers(loadbalancerPages)
+	loadbalancerList, err := loadbalancers.ExtractLoadBalancers(loadbalancerPages)
 	th.AssertNoErr(t, err)
 
 	for _, lb := range loadbalancerList {
@@ -31,35 +31,37 @@ func TestLoadBalancerLifecycle(t *testing.T) {
 	th.AssertNoErr(t, err)
 
 	loadbalancerID := createLoadBalancer(t, client)
-	defer deleteLoadbalancer(t, client, loadbalancerID)
+	t.Cleanup(func() {
+		deleteLoadbalancer(t, client, loadbalancerID)
+	})
 
 	t.Logf("Attempting to update ELBv3 LoadBalancer: %s", loadbalancerID)
 	lbName := tools.RandomString("update-lb-", 3)
 	emptyDescription := ""
 	updateOptsDpE := loadbalancers.UpdateOpts{
 		Name:                     lbName,
-		Description:              &emptyDescription,
+		Description:              emptyDescription,
 		DeletionProtectionEnable: pointerto.Bool(true),
 	}
-	_, err = loadbalancers.Update(client, loadbalancerID, updateOptsDpE).Extract()
+	_, err = loadbalancers.Update(client, loadbalancerID, updateOptsDpE)
 	th.AssertNoErr(t, err)
 	t.Logf("Updated ELBv3 LoadBalancer: %s", loadbalancerID)
 
-	err = loadbalancers.Delete(client, loadbalancerID).ExtractErr()
+	err = loadbalancers.Delete(client, loadbalancerID)
 	if err != nil {
 		t.Logf("Cannot delete, Deletion Protection enabled for ELBv3 LoadBalancer: %s", loadbalancerID)
 	}
 
 	updateOptsDpD := loadbalancers.UpdateOpts{
 		Name:                     lbName,
-		Description:              &emptyDescription,
+		Description:              emptyDescription,
 		DeletionProtectionEnable: pointerto.Bool(false),
 	}
-	_, err = loadbalancers.Update(client, loadbalancerID, updateOptsDpD).Extract()
+	_, err = loadbalancers.Update(client, loadbalancerID, updateOptsDpD)
 	th.AssertNoErr(t, err)
 	t.Logf("Updated ELBv3 LoadBalancer: %s", loadbalancerID)
 
-	newLoadbalancer, err := loadbalancers.Get(client, loadbalancerID).Extract()
+	newLoadbalancer, err := loadbalancers.Get(client, loadbalancerID)
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, updateOptsDpD.Name, newLoadbalancer.Name)
 	th.AssertEquals(t, emptyDescription, newLoadbalancer.Description)