Merge pull request #46 from thomasheller/backup-storages-created-and-origin

Support fields "created" and "origin" for backup storages

Author: alienhaxor

upcloud/service/service_test.go

@@ -1,15 +1,16 @@
 package service
 
 import (
-	"github.com/UpCloudLtd/upcloud-go-api/upcloud"
-	"github.com/UpCloudLtd/upcloud-go-api/upcloud/client"
-	"github.com/UpCloudLtd/upcloud-go-api/upcloud/request"
 	"log"
 	"os"
 	"reflect"
 	"strings"
 	"testing"
 	"time"
+
+	"github.com/UpCloudLtd/upcloud-go-api/upcloud"
+	"github.com/UpCloudLtd/upcloud-go-api/upcloud/client"
+	"github.com/UpCloudLtd/upcloud-go-api/upcloud/request"
 )
 
 // The service object used by the tests
@@ -18,7 +19,7 @@ var svc *Service
 // TestMain is the main test method
 func TestMain(m *testing.M) {
 	setup()
-    retCode := m.Run()
+	retCode := m.Run()
 
 	// Optionally perform teardown
 	deleteResources := os.Getenv("UPCLOUD_GO_SDK_TEST_DELETE_RESOURCES")
@@ -393,6 +394,7 @@ func TestLoadEjectCDROM(t *testing.T) {
 //
 // - creates a storage device
 // - creates a backup of the storage device
+// - gets backup storage details
 //
 // It's not feasible to test backup restoration due to time constraints
 func TestCreateBackup(t *testing.T) {
@@ -407,14 +409,42 @@ func TestCreateBackup(t *testing.T) {
 
 	// Create a backup
 	t.Logf("Creating backup of storage with UUID %s ...", storageDetails.UUID)
+
+	timeBeforeBackup := utcTimeWithSecondPrecision()
+
 	backupDetails, err := svc.CreateBackup(&request.CreateBackupRequest{
 		UUID:  storageDetails.UUID,
 		Title: "Backup",
 	})
 
 	handleError(err)
 	waitForStorageOnline(storageDetails.UUID)
+
+	timeAfterBackup := utcTimeWithSecondPrecision()
+
 	t.Logf("Created backup with UUID %s", backupDetails.UUID)
+
+	// Get backup storage details
+	t.Logf("Getting details of backup storage with UUID %s ...", backupDetails.UUID)
+
+	backupStorageDetails, err := svc.GetStorageDetails(&request.GetStorageDetailsRequest{
+		UUID: backupDetails.UUID,
+	})
+	handleError(err)
+
+	if backupStorageDetails.Origin != storageDetails.UUID {
+		t.Errorf("The origin UUID %s of backup storage UUID %s does not match the actual origina UUID %s", backupStorageDetails.Origin, backupDetails.UUID, storageDetails.UUID)
+	}
+
+	if backupStorageDetails.Created.Before(timeBeforeBackup) {
+		t.Errorf("The creation timestamp of backup storage UUID %s is too early: %v (should be after %v)", backupDetails.UUID, backupStorageDetails.Created, timeBeforeBackup)
+	}
+
+	if backupStorageDetails.Created.After(timeAfterBackup) {
+		t.Errorf("The creation timestamp of backup storage UUID %s is too late: %v (should be before %v)", backupDetails.UUID, backupStorageDetails.Created, timeAfterBackup)
+	}
+
+	t.Logf("Backup storage origin UUID OK")
 }
 
 // TestAttachModifyReleaseIPAddress performs the following actions
@@ -740,6 +770,17 @@ func waitForStorageOnline(uuid string) {
 	handleError(err)
 }
 
+// Returns the current UTC time with second precision (milliseconds truncated).
+// This is the format we usually get from the UpCloud API.
+func utcTimeWithSecondPrecision() time.Time {
+	utc, err := time.LoadLocation("UTC")
+	handleError(err)
+
+	t := time.Now().In(utc).Truncate(time.Second)
+
+	return t
+}
+
 // Handles the error by panicing, thus stopping the test execution
 func handleError(err error) {
 	if err != nil {

upcloud/storage.go

@@ -1,6 +1,9 @@
 package upcloud
 
-import "encoding/xml"
+import (
+	"encoding/xml"
+	"time"
+)
 
 // Constants
 const (
@@ -54,6 +57,9 @@ type Storage struct {
 	Type       string `xml:"type"`
 	UUID       string `xml:"uuid"`
 	Zone       string `xml:"zone"`
+	// Only for type "backup":
+	Origin  string    `xml:"origin"`
+	Created time.Time `xml:"created"`
 }
 
 // StorageDetails represents detailed information about a piece of storage

upcloud/storage_test.go

@@ -2,8 +2,10 @@ package upcloud
 
 import (
 	"encoding/xml"
-	"github.com/stretchr/testify/assert"
 	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
 )
 
 // TestUnmarshalStorage tests that Storages and Storage struct are unmarshaled correctly
@@ -54,6 +56,82 @@ func TestUnmarshalStorage(t *testing.T) {
 	assert.Equal(t, "01000000-0000-4000-8000-000010010101", firstStorage.UUID)
 }
 
+// TestUnmarshalStorage tests that Storages and Storage struct are unmarshaled correctly for private and backup storages
+func TestUnmarshalStoragesPrivateAndBackup(t *testing.T) {
+	originalXML := `<?xml version="1.0" encoding="utf-8"?>
+<storages>
+    <storage>
+        <access>private</access>
+        <license>0</license>
+        <size>10</size>
+        <state>online</state>
+	<tier>hdd</tier>
+        <title>Operating system disk</title>
+        <type>normal</type>
+        <uuid>01eff7ad-168e-413e-83b0-054f6a28fa23</uuid>
+        <zone>uk-lon1</zone>
+    </storage>
+    <storage>
+        <access>private</access>
+	<created>2019-09-17T14:34:43Z</created>
+        <license>0</license>
+	<origin>01eff7ad-168e-413e-83b0-054f6a28fa23</origin>
+        <size>10</size>
+        <state>online</state>
+        <title>On demand backup</title>
+        <type>backup</type>
+        <uuid>01287ad1-496c-4b5f-bb67-0fc2e3494740</uuid>
+        <zone>uk-lon1</zone>
+    </storage>
+    <storage>
+        <access>private</access>
+        <license>0</license>
+        <part_of_plan>yes</part_of_plan>
+        <size>50</size>
+        <state>online</state>
+        <tier>maxiops</tier>
+        <title>Databases</title>
+        <type>normal</type>
+        <uuid>01f3286c-a5ea-4670-8121-d0b9767d625b</uuid>
+        <zone>fi-hel1</zone>
+    </storage>
+</storages>`
+
+	storages := Storages{}
+	err := xml.Unmarshal([]byte(originalXML), &storages)
+
+	assert.Nil(t, err)
+	assert.Len(t, storages.Storages, 3)
+
+	firstStorage := storages.Storages[0]
+	assert.Equal(t, "private", firstStorage.Access)
+	assert.Equal(t, 0.0, firstStorage.License)
+	assert.Equal(t, 10, firstStorage.Size)
+	assert.Equal(t, "online", firstStorage.State)
+	assert.Equal(t, "hdd", firstStorage.Tier)
+	assert.Equal(t, "Operating system disk", firstStorage.Title)
+	assert.Equal(t, "normal", firstStorage.Type)
+	assert.Equal(t, "01eff7ad-168e-413e-83b0-054f6a28fa23", firstStorage.UUID)
+	assert.Equal(t, "uk-lon1", firstStorage.Zone)
+	assert.Equal(t, time.Time{}, firstStorage.Created)
+	assert.Equal(t, "", firstStorage.Origin)
+
+	secondStorage := storages.Storages[1]
+	assert.Equal(t, "private", secondStorage.Access)
+	created, err := time.Parse(time.RFC3339, "2019-09-17T14:34:43Z")
+	assert.Nil(t, err)
+	assert.Equal(t, created, secondStorage.Created)
+	assert.Equal(t, 0.0, secondStorage.License)
+	assert.Equal(t, "01eff7ad-168e-413e-83b0-054f6a28fa23", secondStorage.Origin)
+	assert.Equal(t, 10, secondStorage.Size)
+	assert.Equal(t, "online", secondStorage.State)
+	assert.Equal(t, "", secondStorage.Tier)
+	assert.Equal(t, "On demand backup", secondStorage.Title)
+	assert.Equal(t, "backup", secondStorage.Type)
+	assert.Equal(t, "01287ad1-496c-4b5f-bb67-0fc2e3494740", secondStorage.UUID)
+	assert.Equal(t, "uk-lon1", secondStorage.Zone)
+}
+
 // TestUnmarshalStorageDetails tests that StorageDetails struct is unmarshaled correctly
 func TestUnmarshalStorageDetails(t *testing.T) {
 	originalXML := `<?xml version="1.0" encoding="utf-8"?>