Merge pull request rackspace#235 from jrperritt/cloud-files

Cloud files v1

Author: smashwilson

acceptance/openstack/client_test.go

@@ -30,7 +30,7 @@ func TestAuthenticatedClient(t *testing.T) {
 	t.Logf("Client successfully acquired a token: %v", client.TokenID)
 
 	// Find the storage service in the service catalog.
-	storage, err := openstack.NewStorageV1(client, gophercloud.EndpointOpts{
+	storage, err := openstack.NewObjectStorageV1(client, gophercloud.EndpointOpts{
 		Region: os.Getenv("OS_REGION_NAME"),
 	})
 	if err != nil {

acceptance/openstack/compute/v2/servers_test.go

@@ -4,11 +4,15 @@ package v2
 
 import (
 	"fmt"
+	"os"
 	"testing"
 
 	"github.com/rackspace/gophercloud"
 	"github.com/rackspace/gophercloud/acceptance/tools"
+	"github.com/rackspace/gophercloud/openstack"
 	"github.com/rackspace/gophercloud/openstack/compute/v2/servers"
+	"github.com/rackspace/gophercloud/openstack/networking/v2/networks"
+	"github.com/rackspace/gophercloud/openstack/utils"
 	"github.com/rackspace/gophercloud/pagination"
 )
 
@@ -42,14 +46,59 @@ func TestListServers(t *testing.T) {
 	fmt.Printf("--------\n%d servers listed on %d pages.\n", count, pages)
 }
 
+func networkingClient() (*gophercloud.ServiceClient, error) {
+	opts, err := utils.AuthOptions()
+	if err != nil {
+		return nil, err
+	}
+
+	provider, err := openstack.AuthenticatedClient(opts)
+	if err != nil {
+		return nil, err
+	}
+
+	return openstack.NewNetworkV2(provider, gophercloud.EndpointOpts{
+		Name:   "neutron",
+		Region: os.Getenv("OS_REGION_NAME"),
+	})
+}
+
 func createServer(t *testing.T, client *gophercloud.ServiceClient, choices *ComputeChoices) (*servers.Server, error) {
+	var network networks.Network
+
+	networkingClient, err := networkingClient()
+	if err != nil {
+		t.Fatalf("Unable to create a networking client: %v", err)
+	}
+
+	pager := networks.List(networkingClient, networks.ListOpts{Name: "public", Limit: 1})
+	pager.EachPage(func(page pagination.Page) (bool, error) {
+		networks, err := networks.ExtractNetworks(page)
+		if err != nil {
+			t.Errorf("Failed to extract networks: %v", err)
+			return false, err
+		}
+
+		if len(networks) == 0 {
+			t.Fatalf("No networks to attach to server")
+			return false, err
+		}
+
+		network = networks[0]
+
+		return false, nil
+	})
+
 	name := tools.RandomString("ACPTTEST", 16)
 	t.Logf("Attempting to create server: %s\n", name)
 
 	server, err := servers.Create(client, servers.CreateOpts{
 		Name:      name,
 		FlavorRef: choices.FlavorID,
 		ImageRef:  choices.ImageID,
+		Networks: []servers.Network{
+			servers.Network{UUID: network.ID},
+		},
 	}).Extract()
 	if err != nil {
 		t.Fatalf("Unable to create server: %v", err)
@@ -69,9 +118,6 @@ func TestCreateDestroyServer(t *testing.T) {
 		t.Fatalf("Unable to create a compute client: %v", err)
 	}
 
-	name := tools.RandomString("ACPTTEST", 16)
-	t.Logf("Attempting to create server: %s\n", name)
-
 	server, err := createServer(t, client, choices)
 	if err != nil {
 		t.Fatalf("Unable to create server: %v", err)
@@ -157,7 +203,7 @@ func TestActionChangeAdminPassword(t *testing.T) {
 	}
 
 	randomPassword := tools.MakeNewPassword(server.AdminPass)
-	res = servers.ChangeAdminPassword(client, server.ID, randomPassword)
+	res := servers.ChangeAdminPassword(client, server.ID, randomPassword)
 	if res.Err != nil {
 		t.Fatal(err)
 	}
@@ -194,7 +240,7 @@ func TestActionReboot(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	res = servers.Reboot(client, server.ID, "aldhjflaskhjf")
+	res := servers.Reboot(client, server.ID, "aldhjflaskhjf")
 	if res.Err == nil {
 		t.Fatal("Expected the SDK to provide an ArgumentError here")
 	}
@@ -271,7 +317,7 @@ func resizeServer(t *testing.T, client *gophercloud.ServiceClient, server *serve
 	t.Logf("Attempting to resize server [%s]", server.ID)
 
 	if res := servers.Resize(client, server.ID, choices.FlavorIDResize); res.Err != nil {
-		t.Fatal(err)
+		t.Fatal(res.Err)
 	}
 
 	if err := waitForStatus(client, server, "VERIFY_RESIZE"); err != nil {

acceptance/openstack/networking/v2/extensions/security_test.go

@@ -21,6 +21,9 @@ func TestSecurityGroups(t *testing.T) {
 	// create security group
 	groupID := createSecGroup(t)
 
+	// delete security group
+	defer deleteSecGroup(t, groupID)
+
 	// list security group
 	listSecGroups(t)
 
@@ -30,14 +33,11 @@ func TestSecurityGroups(t *testing.T) {
 	// create port with security group
 	networkID, portID := createPort(t, groupID)
 
-	// delete port
-	deletePort(t, portID)
-
-	// delete security group
-	deleteSecGroup(t, groupID)
-
 	// teardown
-	deleteNetwork(t, networkID)
+	defer deleteNetwork(t, networkID)
+
+	// delete port
+	defer deletePort(t, portID)
 }
 
 func TestSecurityGroupRules(t *testing.T) {
@@ -47,6 +47,8 @@ func TestSecurityGroupRules(t *testing.T) {
 	// create security group
 	groupID := createSecGroup(t)
 
+	defer deleteSecGroup(t, groupID)
+
 	// create security group rule
 	ruleID := createSecRule(t, groupID)
 

acceptance/openstack/objectstorage/v1/accounts_test.go

@@ -7,46 +7,32 @@ import (
 	"testing"
 
 	"github.com/rackspace/gophercloud/openstack/objectstorage/v1/accounts"
+	th "github.com/rackspace/gophercloud/testhelper"
 )
 
 func TestAccounts(t *testing.T) {
 	// Create a provider client for making the HTTP requests.
 	// See common.go in this directory for more information.
 	client, err := newClient()
-	if err != nil {
-		t.Error(err)
-		return
-	}
+	th.AssertNoErr(t, err)
 
 	// Update an account's metadata.
-	err = accounts.Update(client, accounts.UpdateOpts{
-		Metadata: metadata,
-	})
-	if err != nil {
-		t.Error(err)
-		return
-	}
+	res = accounts.Update(client, accounts.UpdateOpts{Metadata: metadata})
+	th.AssertNoErr(t, res.Err)
+
 	// Defer the deletion of the metadata set above.
 	defer func() {
 		tempMap := make(map[string]string)
 		for k := range metadata {
 			tempMap[k] = ""
 		}
-		err = accounts.Update(client, accounts.UpdateOpts{
-			Metadata: tempMap,
-		})
-		if err != nil {
-			t.Error(err)
-			return
-		}
+		res = accounts.Update(client, accounts.UpdateOpts{Metadata: tempMap})
+		th.AssertNoErr(t, res.Err)
 	}()
 
 	// Retrieve account metadata.
-	gr, err := accounts.Get(client, accounts.GetOpts{})
-	if err != nil {
-		t.Error(err)
-		return
-	}
+	res := accounts.Get(client, accounts.GetOpts{})
+	th.AssertNoErr(res.Err)
 	// Extract the custom metadata from the 'Get' response.
 	am := accounts.ExtractMetadata(gr)
 	for k := range metadata {

acceptance/openstack/objectstorage/v1/common.go

@@ -3,26 +3,24 @@
 package v1
 
 import (
+	"os"
+
 	"github.com/rackspace/gophercloud"
 	"github.com/rackspace/gophercloud/openstack"
 	"github.com/rackspace/gophercloud/openstack/utils"
-	"os"
+	th "github.com/rackspace/gophercloud/testhelper"
 )
 
 var metadata = map[string]string{"gopher": "cloud"}
 
 func newClient() (*gophercloud.ServiceClient, error) {
 	ao, err := utils.AuthOptions()
-	if err != nil {
-		return nil, err
-	}
+	th.AssertNoErr(t, err)
 
 	client, err := openstack.AuthenticatedClient(ao)
-	if err != nil {
-		return nil, err
-	}
+	th.AssertNoErr(t, err)
 
-	return openstack.NewStorageV1(client, gophercloud.EndpointOpts{
+	return openstack.NewObjectStorageV1(client, gophercloud.EndpointOpts{
 		Region: os.Getenv("OS_REGION_NAME"),
-	})
+	}), nil
 }

acceptance/openstack/objectstorage/v1/containers_test.go

@@ -9,6 +9,7 @@ import (
 	"github.com/rackspace/gophercloud/acceptance/tools"
 	"github.com/rackspace/gophercloud/openstack/objectstorage/v1/containers"
 	"github.com/rackspace/gophercloud/pagination"
+	th "github.com/rackspace/gophercloud/testhelper"
 )
 
 // numContainers is the number of containers to create for testing.
@@ -17,9 +18,7 @@ var numContainers = 2
 func TestContainers(t *testing.T) {
 	// Create a new client to execute the HTTP requests. See common.go for newClient body.
 	client, err := newClient()
-	if err != nil {
-		t.Error(err)
-	}
+	th.AssertNoErr(err)
 
 	// Create a slice of random container names.
 	cNames := make([]string, numContainers)
@@ -29,77 +28,60 @@ func TestContainers(t *testing.T) {
 
 	// Create numContainers containers.
 	for i := 0; i < len(cNames); i++ {
-		_, err := containers.Create(client, cNames[i], nil).ExtractHeaders()
-		if err != nil {
-			t.Error(err)
-		}
+		res := containers.Create(client, cNames[i], nil)
+		th.AssertNoErr(res.Err)
 	}
 	// Delete the numContainers containers after function completion.
 	defer func() {
 		for i := 0; i < len(cNames); i++ {
-			_, err = containers.Delete(client, cNames[i]).ExtractHeaders()
-			if err != nil {
-				t.Error(err)
-			}
+			res = containers.Delete(client, cNames[i])
+			th.AssertNoErr(res.Err)
 		}
 	}()
 
 	// List the numContainer names that were just created. To just list those,
 	// the 'prefix' parameter is used.
 	err = containers.List(client, &containers.ListOpts{Full: true, Prefix: "gophercloud-test-container-"}).EachPage(func(page pagination.Page) (bool, error) {
 		containerList, err := containers.ExtractInfo(page)
-		if err != nil {
-			t.Error(err)
-		}
+		th.AssertNoErr(err)
+
 		for _, n := range containerList {
 			t.Logf("Container: Name [%s] Count [%d] Bytes [%d]",
 				n.Name, n.Count, n.Bytes)
 		}
 
 		return true, nil
 	})
-	if err != nil {
-		t.Error(err)
-	}
+	th.AssertNoErr(err)
 
 	// List the info for the numContainer containers that were created.
 	err = containers.List(client, &containers.ListOpts{Full: false, Prefix: "gophercloud-test-container-"}).EachPage(func(page pagination.Page) (bool, error) {
 		containerList, err := containers.ExtractNames(page)
-		if err != nil {
-			return false, err
-		}
+		th.AssertNoErr(err)
 		for _, n := range containerList {
 			t.Logf("Container: Name [%s]", n)
 		}
 
 		return true, nil
 	})
-	if err != nil {
-		t.Error(err)
-	}
+	th.AssertNoErr(err)
 
 	// Update one of the numContainer container metadata.
-	_, err = containers.Update(client, cNames[0], &containers.UpdateOpts{Metadata: metadata}).ExtractHeaders()
-	if err != nil {
-		t.Error(err)
-	}
+	res = containers.Update(client, cNames[0], &containers.UpdateOpts{Metadata: metadata})
+	th.AssertNoErr(res.Err)
 	// After the tests are done, delete the metadata that was set.
 	defer func() {
 		tempMap := make(map[string]string)
 		for k := range metadata {
 			tempMap[k] = ""
 		}
-		_, err = containers.Update(client, cNames[0], &containers.UpdateOpts{Metadata: tempMap}).ExtractHeaders()
-		if err != nil {
-			t.Error(err)
-		}
+		res = containers.Update(client, cNames[0], &containers.UpdateOpts{Metadata: tempMap})
+		th.AssertNoErr(res.Err)
 	}()
 
 	// Retrieve a container's metadata.
 	cm, err := containers.Get(client, cNames[0]).ExtractMetadata()
-	if err != nil {
-		t.Error(err)
-	}
+	th.AssertNoErr(err)
 	for k := range metadata {
 		if cm[k] != metadata[strings.Title(k)] {
 			t.Errorf("Expected custom metadata with key: %s", k)