[EVS] V3 API Update

acceptance/openstack/common.go

@@ -10,10 +10,10 @@ import (
 	"github.com/opentelekomcloud/gophertelekomcloud"
 	"github.com/opentelekomcloud/gophertelekomcloud/acceptance/clients"
 	"github.com/opentelekomcloud/gophertelekomcloud/acceptance/tools"
-	"github.com/opentelekomcloud/gophertelekomcloud/openstack/blockstorage/v2/volumes"
 	"github.com/opentelekomcloud/gophertelekomcloud/openstack/common/extensions"
 	"github.com/opentelekomcloud/gophertelekomcloud/openstack/compute/v2/extensions/secgroups"
 	"github.com/opentelekomcloud/gophertelekomcloud/openstack/ecs/v1/cloudservers"
+	"github.com/opentelekomcloud/gophertelekomcloud/openstack/evs/v3/volumes"
 	"github.com/opentelekomcloud/gophertelekomcloud/openstack/imageservice/v2/images"
 	"github.com/opentelekomcloud/gophertelekomcloud/openstack/networking/v1/subnets"
 	th "github.com/opentelekomcloud/gophertelekomcloud/testhelper"
@@ -82,11 +82,11 @@ func CreateVolume(t *testing.T) *volumes.Volume {
 		Name:       tools.RandomString("test-vol-", 6),
 		Size:       10,
 		VolumeType: "SSD",
-	}).Extract()
+	})
 	th.AssertNoErr(t, err)
 
 	err = golangsdk.WaitFor(300, func() (bool, error) {
-		volume, err := volumes.Get(client, vol.ID).Extract()
+		volume, err := volumes.Get(client, vol.ID)
 		if err != nil {
 			return false, err
 		}
@@ -106,7 +106,10 @@ func CreateVolume(t *testing.T) *volumes.Volume {
 func DeleteVolume(t *testing.T, id string) {
 	client, err := clients.NewBlockStorageV3Client()
 	th.AssertNoErr(t, err)
-	th.AssertNoErr(t, volumes.Delete(client, id, volumes.DeleteOpts{Cascade: true}).ExtractErr())
+	th.AssertNoErr(t, volumes.Delete(client, volumes.DeleteOpts{
+		VolumeId: id,
+		Cascade:  true,
+	}))
 }
 
 const (

acceptance/openstack/compute/v2/helper.go

@@ -0,0 +1,79 @@
+package v2
+
+import (
+	"testing"
+	"time"
+
+	golangsdk "github.com/opentelekomcloud/gophertelekomcloud"
+	"github.com/opentelekomcloud/gophertelekomcloud/acceptance/clients"
+	"github.com/opentelekomcloud/gophertelekomcloud/acceptance/openstack"
+	"github.com/opentelekomcloud/gophertelekomcloud/acceptance/tools"
+	"github.com/opentelekomcloud/gophertelekomcloud/openstack/compute/v2/flavors"
+	"github.com/opentelekomcloud/gophertelekomcloud/openstack/compute/v2/images"
+	"github.com/opentelekomcloud/gophertelekomcloud/openstack/compute/v2/servers"
+	th "github.com/opentelekomcloud/gophertelekomcloud/testhelper"
+)
+
+func CreateServer(t *testing.T, client *golangsdk.ServiceClient) (*servers.Server, error) {
+	t.Logf("Attempting to create ECSv2")
+	ecsName := tools.RandomString("create-ecs-", 3)
+
+	az := clients.EnvOS.GetEnv("AVAILABILITY_ZONE")
+	if az == "" {
+		az = "eu-de-01"
+	}
+
+	networkID := clients.EnvOS.GetEnv("NETWORK_ID")
+	if networkID == "" {
+		t.Skip("OS_NETWORK_ID env var is missing but ECS test requires using existing network")
+	}
+
+	imageID, err := images.IDFromName(client, "Standard_Debian_10_latest")
+	th.AssertNoErr(t, err)
+
+	flavorID, err := flavors.IDFromName(client, "s2.large.2")
+	th.AssertNoErr(t, err)
+
+	ecs, err := servers.Create(client, servers.CreateOpts{
+		Name:      ecsName,
+		ImageRef:  imageID,
+		FlavorRef: flavorID,
+		SecurityGroups: []string{
+			openstack.DefaultSecurityGroup(t),
+		},
+		AvailabilityZone: az,
+		Networks: []servers.Network{
+			{
+				UUID: networkID,
+			},
+		},
+	}).Extract()
+	th.AssertNoErr(t, err)
+
+	err = servers.WaitForStatus(client, ecs.ID, "ACTIVE", 1200)
+	th.AssertNoErr(t, err)
+	t.Logf("Created ECSv2: %s", ecs.ID)
+	return ecs, err
+}
+
+func DeleteServer(t *testing.T, client *golangsdk.ServiceClient, ecs *servers.Server) {
+	t.Logf("Attempting to delete ECSv2: %s", ecs.ID)
+
+	_, err := servers.Delete(client, ecs.ID).ExtractJobResponse()
+	th.AssertNoErr(t, err)
+
+	err = golangsdk.WaitFor(1200, func() (bool, error) {
+		_, err := servers.Get(client, ecs.ID).Extract()
+		if err != nil {
+			if _, ok := err.(golangsdk.ErrDefault400); ok {
+				time.Sleep(10 * time.Second)
+				return false, nil
+			}
+			return false, err
+		}
+		return true, nil
+	})
+	th.AssertNoErr(t, err)
+
+	t.Logf("ECSv2 instance deleted: %s", ecs.ID)
+}

acceptance/openstack/compute/v2/servers_test.go

@@ -2,14 +2,9 @@ package v2
 
 import (
 	"testing"
-	"time"
 
-	"github.com/opentelekomcloud/gophertelekomcloud"
 	"github.com/opentelekomcloud/gophertelekomcloud/acceptance/clients"
-	"github.com/opentelekomcloud/gophertelekomcloud/acceptance/openstack"
 	"github.com/opentelekomcloud/gophertelekomcloud/acceptance/tools"
-	"github.com/opentelekomcloud/gophertelekomcloud/openstack/compute/v2/flavors"
-	"github.com/opentelekomcloud/gophertelekomcloud/openstack/compute/v2/images"
 	"github.com/opentelekomcloud/gophertelekomcloud/openstack/compute/v2/servers"
 	th "github.com/opentelekomcloud/gophertelekomcloud/testhelper"
 )
@@ -34,85 +29,22 @@ func TestServerLifecycle(t *testing.T) {
 	client, err := clients.NewComputeV2Client()
 	th.AssertNoErr(t, err)
 
-	t.Logf("Attempting to create ECSv2")
-	ecsName := tools.RandomString("create-ecs-", 3)
-
-	az := clients.EnvOS.GetEnv("AVAILABILITY_ZONE")
-	if az == "" {
-		az = "eu-de-01"
-	}
-
-	networkID := clients.EnvOS.GetEnv("NETWORK_ID")
-	if networkID == "" {
-		t.Skip("OS_NETWORK_ID env var is missing but ECS test requires using existing network")
-	}
-
-	imageID, err := images.IDFromName(client, "Standard_Debian_10_latest")
-	th.AssertNoErr(t, err)
-
-	flavorID, err := flavors.IDFromName(client, "s2.large.2")
-	th.AssertNoErr(t, err)
-
-	createOpts := servers.CreateOpts{
-		Name:      ecsName,
-		ImageRef:  imageID,
-		FlavorRef: flavorID,
-		SecurityGroups: []string{
-			openstack.DefaultSecurityGroup(t),
-		},
-		AvailabilityZone: az,
-		Networks: []servers.Network{
-			{
-				UUID: networkID,
-			},
-		},
-	}
-
-	ecs, err := servers.Create(client, createOpts).Extract()
+	ecs, err := CreateServer(t, client)
 	th.AssertNoErr(t, err)
-
-	err = servers.WaitForStatus(client, ecs.ID, "ACTIVE", 1200)
-	th.AssertNoErr(t, err)
-	t.Logf("Created ECSv2: %s", ecs.ID)
-
-	ecs, err = servers.Get(client, ecs.ID).Extract()
-	th.AssertNoErr(t, err)
-	th.AssertEquals(t, ecsName, ecs.Name)
+	t.Cleanup(func() {
+		DeleteServer(t, client, ecs)
+	})
 
 	nicInfo, err := servers.GetNICs(client, ecs.ID).Extract()
 	th.AssertNoErr(t, err)
 	tools.PrintResource(t, nicInfo)
 
-	defer func() {
-		t.Logf("Attempting to delete ECSv2: %s", ecs.ID)
-
-		_, err := servers.Delete(client, ecs.ID).ExtractJobResponse()
-		th.AssertNoErr(t, err)
-
-		err = golangsdk.WaitFor(1200, func() (bool, error) {
-			_, err := servers.Get(client, ecs.ID).Extract()
-			if err != nil {
-				if _, ok := err.(golangsdk.ErrDefault400); ok {
-					time.Sleep(10 * time.Second)
-					return false, nil
-				}
-				return false, err
-			}
-			return true, nil
-		})
-		th.AssertNoErr(t, err)
-
-		t.Logf("ECSv2 instance deleted: %s", ecs.ID)
-	}()
-
 	t.Logf("Attempting to update ECSv2: %s", ecs.ID)
 
-	ecsName = tools.RandomString("update-ecs-", 3)
-	updateOpts := servers.UpdateOpts{
+	ecsName := tools.RandomString("update-ecs-", 3)
+	_, err = servers.Update(client, ecs.ID, servers.UpdateOpts{
 		Name: ecsName,
-	}
-
-	_, err = servers.Update(client, ecs.ID, updateOpts).Extract()
+	}).Extract()
 	th.AssertNoErr(t, err)
 
 	t.Logf("ECSv2 successfully updated: %s", ecs.ID)

acceptance/openstack/evs/v3/blockstorage.go

@@ -0,0 +1,167 @@
+package v3
+
+import (
+	"testing"
+
+	golangsdk "github.com/opentelekomcloud/gophertelekomcloud"
+	"github.com/opentelekomcloud/gophertelekomcloud/acceptance/tools"
+	"github.com/opentelekomcloud/gophertelekomcloud/openstack/evs/v3/snapshots"
+	"github.com/opentelekomcloud/gophertelekomcloud/openstack/evs/v3/volumes"
+	"github.com/opentelekomcloud/gophertelekomcloud/openstack/evs/v3/volumetypes"
+	th "github.com/opentelekomcloud/gophertelekomcloud/testhelper"
+)
+
+// CreateSnapshot will create a snapshot of the specified volume.
+// Snapshot will be assigned a random name and description.
+func CreateSnapshot(t *testing.T, client *golangsdk.ServiceClient, volume *volumes.Volume) (*snapshots.Snapshot, error) {
+	snapshotName := tools.RandomString("ACPTTEST", 16)
+	snapshotDescription := tools.RandomString("ACPTTEST", 16)
+	t.Logf("Attempting to create snapshot: %s", snapshotName)
+
+	createOpts := snapshots.CreateOpts{
+		VolumeID:    volume.ID,
+		Name:        snapshotName,
+		Description: snapshotDescription,
+	}
+
+	snapshot, err := snapshots.Create(client, createOpts)
+	if err != nil {
+		return snapshot, err
+	}
+
+	err = snapshots.WaitForStatus(client, snapshot.ID, "available", 60)
+	if err != nil {
+		return snapshot, err
+	}
+
+	tools.PrintResource(t, snapshot)
+	th.AssertEquals(t, snapshot.Name, snapshotName)
+	th.AssertEquals(t, snapshot.VolumeID, volume.ID)
+
+	t.Logf("Successfully created snapshot: %s", snapshot.ID)
+
+	return snapshot, nil
+}
+
+// CreateVolume will create a volume with a random name and size of 1GB. An
+// error will be returned if the volume was unable to be created.
+func CreateVolume(t *testing.T, client *golangsdk.ServiceClient) (*volumes.Volume, error) {
+	volumeName := tools.RandomString("ACPTTEST", 16)
+	volumeDescription := tools.RandomString("ACPTTEST-DESC", 16)
+	t.Logf("Attempting to create volume: %s", volumeName)
+
+	createOpts := volumes.CreateOpts{
+		Size:        1,
+		Name:        volumeName,
+		Description: volumeDescription,
+	}
+
+	volume, err := volumes.Create(client, createOpts)
+	if err != nil {
+		return volume, err
+	}
+
+	err = volumes.WaitForStatus(client, volume.ID, "available", 60)
+	if err != nil {
+		return volume, err
+	}
+
+	tools.PrintResource(t, volume)
+	th.AssertEquals(t, volume.Name, volumeName)
+	th.AssertEquals(t, volume.Description, volumeDescription)
+	th.AssertEquals(t, volume.Size, 1)
+
+	t.Logf("Successfully created volume: %s", volume.ID)
+
+	return volume, nil
+}
+
+// CreateVolumeWithType will create a volume of the given volume type
+// with a random name and size of 1GB. An error will be returned if
+// the volume was unable to be created.
+func CreateVolumeWithType(t *testing.T, client *golangsdk.ServiceClient, vt *volumetypes.VolumeType) (*volumes.Volume, error) {
+	volumeName := tools.RandomString("ACPTTEST", 16)
+	volumeDescription := tools.RandomString("ACPTTEST-DESC", 16)
+	t.Logf("Attempting to create volume: %s", volumeName)
+
+	createOpts := volumes.CreateOpts{
+		Size:        1,
+		Name:        volumeName,
+		Description: volumeDescription,
+		VolumeType:  vt.Name,
+	}
+
+	volume, err := volumes.Create(client, createOpts)
+	if err != nil {
+		return volume, err
+	}
+
+	err = volumes.WaitForStatus(client, volume.ID, "available", 60)
+	if err != nil {
+		return volume, err
+	}
+
+	tools.PrintResource(t, volume)
+	th.AssertEquals(t, volume.Name, volumeName)
+	th.AssertEquals(t, volume.Description, volumeDescription)
+	th.AssertEquals(t, volume.Size, 1)
+	th.AssertEquals(t, volume.VolumeType, vt.Name)
+
+	t.Logf("Successfully created volume: %s", volume.ID)
+
+	return volume, nil
+}
+
+// DeleteSnapshot will delete a snapshot. A fatal error will occur if the
+// snapshot failed to be deleted.
+func DeleteSnapshot(t *testing.T, client *golangsdk.ServiceClient, snapshot *snapshots.Snapshot) {
+	err := snapshots.Delete(client, snapshot.ID)
+	if err != nil {
+		t.Fatalf("Unable to delete snapshot %s: %+v", snapshot.ID, err)
+	}
+
+	// Volumes can't be deleted until their snapshots have been,
+	// so block until the snapshot as been deleted.
+	err = tools.WaitFor(func() (bool, error) {
+		_, err := snapshots.Get(client, snapshot.ID)
+		if err != nil {
+			return true, nil
+		}
+
+		return false, nil
+	})
+	if err != nil {
+		t.Fatalf("Error waiting for snapshot to delete: %v", err)
+	}
+
+	t.Logf("Deleted snapshot: %s", snapshot.ID)
+}
+
+// DeleteVolume will delete a volume. A fatal error will occur if the volume
+// failed to be deleted. This works best when used as a deferred function.
+func DeleteVolume(t *testing.T, client *golangsdk.ServiceClient, volume *volumes.Volume) {
+	t.Logf("Attempting to delete volume: %s", volume.ID)
+
+	err := volumes.Delete(client, volumes.DeleteOpts{
+		VolumeId: volume.ID,
+	})
+	if err != nil {
+		t.Fatalf("Unable to delete volume %s: %v", volume.ID, err)
+	}
+
+	// VolumeTypes can't be deleted until their volumes have been,
+	// so block until the volume is deleted.
+	err = tools.WaitFor(func() (bool, error) {
+		_, err := volumes.Get(client, volume.ID)
+		if err != nil {
+			return true, nil
+		}
+
+		return false, nil
+	})
+	if err != nil {
+		t.Fatalf("Error waiting for volume to delete: %v", err)
+	}
+
+	t.Logf("Successfully deleted volume: %s", volume.ID)
+}