Second batch of XML-to-JSON conversion (#8)

Author: yoink00

upcloud/account.go

@@ -1,7 +1,27 @@
 package upcloud
 
+import "encoding/json"
+
 // Account represents an account
 type Account struct {
 	Credits  float64 `xml:"credits"`
 	UserName string  `xml:"username"`
 }
+
+// UnmarshalJSON is a custom unmarshaller that deals with
+// deeply embedded values.
+func (s *Account) UnmarshalJSON(b []byte) error {
+	type localAccount Account
+
+	v := struct {
+		Account localAccount `json:"account"`
+	}{}
+	err := json.Unmarshal(b, &v)
+	if err != nil {
+		return err
+	}
+
+	(*s) = Account(v.Account)
+
+	return nil
+}

upcloud/account_test.go

@@ -1,23 +1,26 @@
 package upcloud
 
 import (
-	"encoding/xml"
+	"encoding/json"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 )
 
 // TestUnmarshalAccount tests that Account objects unmarshal correctly
 func TestUnmarshalAccount(t *testing.T) {
-	originalXML := `<?xml version="1.0" encoding="utf-8"?>
-<account>
-    <credits>22465.536</credits>
-    <username>foobar</username>
-</account>`
+	originalJSON := `
+	{
+      "account": {
+        "credits": 9972.2324,
+        "username": "username"
+      }
+    }
+	`
 
 	account := Account{}
-	err := xml.Unmarshal([]byte(originalXML), &account)
-	assert.Nil(t, err)
-	assert.Equal(t, 22465.536, account.Credits)
-	assert.Equal(t, "foobar", account.UserName)
+	err := json.Unmarshal([]byte(originalJSON), &account)
+	assert.NoError(t, err)
+	assert.Equal(t, 9972.2324, account.Credits)
+	assert.Equal(t, "username", account.UserName)
 }

upcloud/client/client.go

@@ -132,7 +132,7 @@ func (c *Client) PerformPutRequest(url string, requestBody []byte) ([]byte, erro
 		bodyReader = bytes.NewBuffer(requestBody)
 	}
 
-	request, err := http.NewRequest("PUT", url, bodyReader)
+	request, err := http.NewRequest(http.MethodPut, url, bodyReader)
 
 	if err != nil {
 		return nil, err
@@ -141,6 +141,23 @@ func (c *Client) PerformPutRequest(url string, requestBody []byte) ([]byte, erro
 	return c.performRequest(request)
 }
 
+// PerformJSONPutRequest performs a PUT request to the specified URL and returns the response body and eventual errors
+func (c *Client) PerformJSONPutRequest(url string, requestBody []byte) ([]byte, error) {
+	var bodyReader io.Reader
+
+	if requestBody != nil {
+		bodyReader = bytes.NewBuffer(requestBody)
+	}
+
+	request, err := http.NewRequest(http.MethodPut, url, bodyReader)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return c.performJSONRequest(request)
+}
+
 // PerformDeleteRequest performs a DELETE request to the specified URL and returns the response body and eventual errors
 func (c *Client) PerformDeleteRequest(url string) error {
 	request, err := http.NewRequest(http.MethodDelete, url, nil)

upcloud/request/server.go

@@ -33,8 +33,12 @@ func (r *GetServerDetailsRequest) RequestURL() string {
 	return fmt.Sprintf("/server/%s", r.UUID)
 }
 
+// CreateServerIPAddressSlice is a slice of strings
+// It exists to allow for a custom JSON marshaller.
 type CreateServerIPAddressSlice []CreateServerIPAddress
 
+// MarshalJSON is a custom marshaller that deals with
+// deeply embedded values.
 func (s CreateServerIPAddressSlice) MarshalJSON() ([]byte, error) {
 	v := struct {
 		IPAddress []CreateServerIPAddress `json:"ip_address"`
@@ -44,8 +48,12 @@ func (s CreateServerIPAddressSlice) MarshalJSON() ([]byte, error) {
 	return json.Marshal(v)
 }
 
+// CreateServerStorageDeviceSlice is a slice of strings
+// It exists to allow for a custom JSON marshaller.
 type CreateServerStorageDeviceSlice []upcloud.CreateServerStorageDevice
 
+// MarshalJSON is a custom marshaller that deals with
+// deeply embedded values.
 func (s CreateServerStorageDeviceSlice) MarshalJSON() ([]byte, error) {
 	v := struct {
 		StorageDevice []upcloud.CreateServerStorageDevice `json:"storage_device"`
@@ -81,6 +89,8 @@ type CreateServerRequest struct {
 	Zone        string `xml:"zone" json:"zone"`
 }
 
+// MarshalJSON is a custom marshaller that deals with
+// deeply embedded values.
 func (r CreateServerRequest) MarshalJSON() ([]byte, error) {
 	type localCreateServerRequest CreateServerRequest
 	v := struct {
@@ -96,8 +106,12 @@ func (r *CreateServerRequest) RequestURL() string {
 	return "/server"
 }
 
+// SSHKeySlice is a slice of strings
+// It exists to allow for a custom JSON unmarshaller.
 type SSHKeySlice []string
 
+// UnmarshalJSON is a custom unmarshaller that deals with
+// deeply embedded values.
 func (s *SSHKeySlice) UnmarshalJSON(b []byte) error {
 	v := struct {
 		SSHKey []string `json:"ssh_key"`
@@ -112,6 +126,8 @@ func (s *SSHKeySlice) UnmarshalJSON(b []byte) error {
 	return nil
 }
 
+// MarshalJSON is a custom marshaller that deals with
+// deeply embedded values.
 func (s SSHKeySlice) MarshalJSON() ([]byte, error) {
 	v := struct {
 		SSHKey []string `json:"ssh_key"`
@@ -158,19 +174,32 @@ func (r *StartServerRequest) RequestURL() string {
 
 // StopServerRequest represents a request to stop a server
 type StopServerRequest struct {
-	XMLName xml.Name `xml:"stop_server"`
+	XMLName xml.Name `xml:"stop_server" json:"-"`
 
-	UUID string `xml:"-"`
+	UUID string `xml:"-" json:"-"`
 
-	StopType string        `xml:"stop_type,omitempty"`
-	Timeout  time.Duration `xml:"timeout,omitempty"`
+	StopType string        `xml:"stop_type,omitempty" json:"stop_type,omitempty"`
+	Timeout  time.Duration `xml:"timeout,omitempty" json:"timeout,omitempty,string"`
 }
 
 // RequestURL implements the Request interface
 func (r *StopServerRequest) RequestURL() string {
 	return fmt.Sprintf("/server/%s/stop", r.UUID)
 }
 
+// MarshalJSON is a custom marshaller that deals with
+// deeply embedded values.
+func (r StopServerRequest) MarshalJSON() ([]byte, error) {
+	type localStopServerRequest StopServerRequest
+	v := struct {
+		StopServerRequest localStopServerRequest `json:"stop_server"`
+	}{}
+	v.StopServerRequest = localStopServerRequest(r)
+	v.StopServerRequest.Timeout = v.StopServerRequest.Timeout / 1e9
+
+	return json.Marshal(&v)
+}
+
 // MarshalXML implements a custom marshaller for StopServerRequest which converts the timeout to seconds
 func (r *StopServerRequest) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
 	type Alias StopServerRequest
@@ -186,20 +215,33 @@ func (r *StopServerRequest) MarshalXML(e *xml.Encoder, start xml.StartElement) e
 
 // RestartServerRequest represents a request to restart a server
 type RestartServerRequest struct {
-	XMLName xml.Name `xml:"restart_server"`
+	XMLName xml.Name `xml:"restart_server" json:"-"`
 
-	UUID string `xml:"-"`
+	UUID string `xml:"-" json:"-"`
 
-	StopType      string        `xml:"stop_type,omitempty"`
-	Timeout       time.Duration `xml:"timeout,omitempty"`
-	TimeoutAction string        `xml:"timeout_action,omitempty"`
+	StopType      string        `xml:"stop_type,omitempty" json:"stop_type,omitempty"`
+	Timeout       time.Duration `xml:"timeout,omitempty"  json:"timeout,omitempty,string"`
+	TimeoutAction string        `xml:"timeout_action,omitempty" json:"timeout_action,omitempty"`
 }
 
 // RequestURL implements the Request interface
 func (r *RestartServerRequest) RequestURL() string {
 	return fmt.Sprintf("/server/%s/restart", r.UUID)
 }
 
+// MarshalJSON is a custom marshaller that deals with
+// deeply embedded values.
+func (r RestartServerRequest) MarshalJSON() ([]byte, error) {
+	type localRestartServerRequest RestartServerRequest
+	v := struct {
+		RestartServerRequest localRestartServerRequest `json:"restart_server"`
+	}{}
+	v.RestartServerRequest = localRestartServerRequest(r)
+	v.RestartServerRequest.Timeout = v.RestartServerRequest.Timeout / 1e9
+
+	return json.Marshal(&v)
+}
+
 // MarshalXML implements a custom marshaller for RestartServerRequest which converts the timeout to seconds
 func (r *RestartServerRequest) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
 	type Alias RestartServerRequest
@@ -215,26 +257,36 @@ func (r *RestartServerRequest) MarshalXML(e *xml.Encoder, start xml.StartElement
 
 // ModifyServerRequest represents a request to modify a server
 type ModifyServerRequest struct {
-	XMLName xml.Name `xml:"server"`
+	XMLName xml.Name `xml:"server" json:"-"`
 
-	UUID string `xml:"-"`
+	UUID string `xml:"-" json:"-"`
 
-	AvoidHost string `xml:"avoid_host,omitempty"`
-	BootOrder string `xml:"boot_order,omitempty"`
-	// TODO: Investigate correct type and format
-	CoreNumber string `xml:"core_number,omitempty"`
+	AvoidHost  string `xml:"avoid_host,omitempty" json:"avoid_host,omitempty"`
+	BootOrder  string `xml:"boot_order,omitempty" json:"boot_order,omitempty"`
+	CoreNumber int    `xml:"core_number,omitempty" json:"core_number,omitempty,string"`
 	// TODO: Convert to boolean
-	Firewall string `xml:"firewall,omitempty"`
-	Hostname string `xml:"hostname,omitempty"`
-	// TODO: Investigate correct type and format
-	MemoryAmount string `xml:"memory_amount,omitempty"`
-	Plan         string `xml:"plan,omitempty"`
-	TimeZone     string `xml:"timezone,omitempty"`
-	Title        string `xml:"title,omitempty"`
-	VideoModel   string `xml:"video_model,omitempty"`
+	Firewall     string `xml:"firewall,omitempty" json:"firewall,omitempty"`
+	Hostname     string `xml:"hostname,omitempty" json:"hostname,omitempty"`
+	MemoryAmount int    `xml:"memory_amount,omitempty" json:"memory_amount,omitempty,string"`
+	Plan         string `xml:"plan,omitempty" json:"plan,omitempty"`
+	TimeZone     string `xml:"timezone,omitempty" json:"timezone,omitempty"`
+	Title        string `xml:"title,omitempty" json:"title,omitempty"`
+	VideoModel   string `xml:"video_model,omitempty" json:"video_model,omitempty"`
 	// TODO: Convert to boolean
-	VNC         string `xml:"vnc,omitempty"`
-	VNCPassword string `xml:"vnc_password,omitempty"`
+	VNC         string `xml:"vnc,omitempty" json:"vnc,omitempty"`
+	VNCPassword string `xml:"vnc_password,omitempty" json:"vnc_password,omitempty"`
+}
+
+// MarshalJSON is a custom marshaller that deals with
+// deeply embedded values.
+func (r ModifyServerRequest) MarshalJSON() ([]byte, error) {
+	type localModifyServerRequest ModifyServerRequest
+	v := struct {
+		ModifyServerRequest localModifyServerRequest `json:"server"`
+	}{}
+	v.ModifyServerRequest = localModifyServerRequest(r)
+
+	return json.Marshal(&v)
 }
 
 // RequestURL implements the Request interface

upcloud/request/server_test.go

@@ -2,7 +2,6 @@ package request
 
 import (
 	"encoding/json"
-	"encoding/xml"
 	"testing"
 	"time"
 
@@ -124,14 +123,21 @@ func TestStartServerRequest(t *testing.T) {
 func TestStopServerRequest(t *testing.T) {
 	request := StopServerRequest{
 		UUID:     "foo",
-		StopType: ServerStopTypeHard,
+		StopType: ServerStopTypeSoft,
 		Timeout:  time.Minute * 5,
 	}
 
-	expectedXML := "<stop_server><timeout>300</timeout><stop_type>hard</stop_type></stop_server>"
-	actualXML, err := xml.Marshal(&request)
+	expectedJSON := `
+	  {
+		"stop_server": {
+		  "stop_type": "soft",
+		  "timeout": "300"
+		}
+	  }
+	`
+	actualJSON, err := json.MarshalIndent(&request, "", "    ")
 	assert.Nil(t, err)
-	assert.Equal(t, expectedXML, string(actualXML))
+	assert.JSONEq(t, expectedJSON, string(actualJSON))
 	assert.Equal(t, "/server/foo/stop", request.RequestURL())
 }
 
@@ -144,24 +150,44 @@ func TestRestartServerRequest(t *testing.T) {
 		TimeoutAction: RestartTimeoutActionDestroy,
 	}
 
-	expectedXML := "<restart_server><timeout>300</timeout><stop_type>soft</stop_type><timeout_action>destroy</timeout_action></restart_server>"
-	actualXML, err := xml.Marshal(&request)
+	expectedJSON := `
+	  {
+		"restart_server": {
+		  "stop_type": "soft",
+		  "timeout": "300",
+		  "timeout_action": "destroy"
+		}
+	  }
+	`
+	actualJSON, err := json.Marshal(&request)
 	assert.Nil(t, err)
-	assert.Equal(t, expectedXML, string(actualXML))
+	assert.JSONEq(t, expectedJSON, string(actualJSON))
 	assert.Equal(t, "/server/foo/restart", request.RequestURL())
 }
 
 // TestModifyServerRequest tests that ModifyServerRequest objects behave correctly
 func TestModifyServerRequest(t *testing.T) {
 	request := ModifyServerRequest{
-		UUID:  "foo",
-		Title: "Modified server",
+		UUID:         "foo",
+		Title:        "Modified server",
+		CoreNumber:   8,
+		MemoryAmount: 16384,
+		Plan:         "custom",
 	}
 
-	expectedXML := "<server><title>Modified server</title></server>"
-	actualXML, err := xml.Marshal(&request)
+	expectedJSON := `
+	  {
+		"server" : {
+          "title": "Modified server",
+		  "core_number": "8",
+		  "memory_amount": "16384",
+		  "plan" : "custom"
+		}
+	  }
+	`
+	actualJSON, err := json.Marshal(&request)
 	assert.Nil(t, err)
-	assert.Equal(t, expectedXML, string(actualXML))
+	assert.JSONEq(t, expectedJSON, string(actualJSON))
 	assert.Equal(t, "/server/foo", request.RequestURL())
 }