Add reusable functions for Create/Delete aggregates

acceptance/openstack/compute/v2/aggregates_test.go

@@ -37,18 +37,11 @@ func TestAggregatesCreateDelete(t *testing.T) {
 		t.Fatalf("Unable to create a compute client: %v", err)
 	}
 
-	opts := aggregates.CreateOpts{
-		Name:             "name",
-		AvailabilityZone: "london",
-	}
-
-	aggregate, err := aggregates.Create(client, opts).Extract()
+	aggregate, err := CreateAggregate(t, client)
 	if err != nil {
 		t.Fatalf("Unable to create an aggregate: %v", err)
 	}
+	defer DeleteAggregate(t, client, aggregate)
 
-	err = aggregates.Delete(client, aggregate.ID).ExtractErr()
-	if err != nil {
-		t.Fatalf("Unable to delete an aggregate: %v", err)
-	}
+	tools.PrintResource(t, aggregate)
 }

acceptance/openstack/compute/v2/compute.go

@@ -26,6 +26,7 @@ import (
 	"github.com/gophercloud/gophercloud/openstack/compute/v2/flavors"
 	"github.com/gophercloud/gophercloud/openstack/compute/v2/servers"
 
+	"github.com/gophercloud/gophercloud/openstack/compute/v2/extensions/aggregates"
 	"golang.org/x/crypto/ssh"
 )
 
@@ -570,6 +571,37 @@ func CreateVolumeAttachment(t *testing.T, client *gophercloud.ServiceClient, blo
 	return volumeAttachment, nil
 }
 
+// CreateAggregate will create an aggregate with random name and available zone.
+// An error will be returned if the aggregate could not be created.
+func CreateAggregate(t *testing.T, client *gophercloud.ServiceClient) (*aggregates.Aggregate, error) {
+	aggregateName := tools.RandomString("aggregate_", 5)
+	availableZone := tools.RandomString("zone_", 5)
+	t.Logf("Attempting to create aggregate %s", aggregateName)
+
+	createOpts := aggregates.CreateOpts{Name: aggregateName, AvailabilityZone: availableZone}
+
+	aggregate, err := aggregates.Create(client, createOpts).Extract()
+	if err != nil {
+		return nil, err
+	}
+
+	t.Logf("Successfully created aggregate %s", aggregate.ID)
+
+	return aggregate, nil
+}
+
+// DeleteAggregate will delete a given host aggregate. A fatal error will occur if
+// the aggregate deleting is failed. This works best when using it as a
+// deferred function.
+func DeleteAggregate(t *testing.T, client *gophercloud.ServiceClient, aggregate *aggregates.Aggregate) {
+	err := aggregates.Delete(client, aggregate.ID).ExtractErr()
+	if err != nil {
+		t.Fatalf("Unable to delete aggregate %s", aggregate.ID)
+	}
+
+	t.Logf("Deleted aggregate: %s", aggregate.ID)
+}
+
 // DeleteDefaultRule deletes a default security group rule.
 // A fatal error will occur if the rule failed to delete. This works best when
 // using it as a deferred function.