Releasing version 2.3.0 (#124)

Releasing version 2.3.0

Author: eginez

CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 
+## 2.3.0 - 2018-08-23
+### Added
+- Support for fault domain in the Identity Service
+- Support for Autonomous Data Warehouse and Autonomous Transaction Processing in the Database service
+- Support for resizing an offline volume in the Block Storage service
+- Nil interface when polymorphic json response object is null
+
 ## 2.2.0 - 2018-07-26
 ### Added
 - Support for fault domains in the Compute service

common/client.go

@@ -285,7 +285,7 @@ func (client BaseClient) Call(ctx context.Context, request *http.Request) (respo
 			Logln("not dumping body too big")
 			dumpBody = false
 		}
-		if dump, e := httputil.DumpRequest(request, dumpBody); e == nil {
+		if dump, e := httputil.DumpRequestOut(request, dumpBody); e == nil {
 			Logf("Dump Request %v", string(dump))
 		} else {
 			Debugln(e)

common/helpers.go

@@ -9,6 +9,7 @@ import (
 	"encoding/pem"
 	"fmt"
 	"reflect"
+	"strconv"
 	"strings"
 	"time"
 )
@@ -81,15 +82,33 @@ func PointerString(datastruct interface{}) (representation string) {
 	return
 }
 
-// SDKTime a time struct, which renders to/from json using RFC339
+// SDKTime a struct that parses/renders to/from json using RFC339 date-time information
 type SDKTime struct {
 	time.Time
 }
 
+// SDKDate a struct that parses/renders to/from json using only date information
+type SDKDate struct {
+	//Date date information
+	Date time.Time
+}
+
 func sdkTimeFromTime(t time.Time) SDKTime {
 	return SDKTime{t}
 }
 
+func sdkDateFromTime(t time.Time) SDKDate {
+	return SDKDate{Date: t}
+}
+
+func formatTime(t SDKTime) string {
+	return t.Format(sdkTimeFormat)
+}
+
+func formatDate(t SDKDate) string {
+	return t.Date.Format(sdkDateFormat)
+}
+
 func now() *SDKTime {
 	t := SDKTime{time.Now()}
 	return &t
@@ -98,13 +117,13 @@ func now() *SDKTime {
 var timeType = reflect.TypeOf(SDKTime{})
 var timeTypePtr = reflect.TypeOf(&SDKTime{})
 
-const sdkTimeFormat = time.RFC3339
+var sdkDateType = reflect.TypeOf(SDKDate{})
+var sdkDateTypePtr = reflect.TypeOf(&SDKDate{})
 
+//Formats for sdk supported time representations
+const sdkTimeFormat = time.RFC3339
 const rfc1123OptionalLeadingDigitsInDay = "Mon, _2 Jan 2006 15:04:05 MST"
-
-func formatTime(t SDKTime) string {
-	return t.Format(sdkTimeFormat)
-}
+const sdkDateFormat = "2006-01-02"
 
 func tryParsingTimeWithValidFormatsForHeaders(data []byte, headerName string) (t time.Time, err error) {
 	header := strings.ToLower(headerName)
@@ -149,6 +168,26 @@ func (t *SDKTime) MarshalJSON() (buff []byte, e error) {
 	return
 }
 
+// UnmarshalJSON unmarshals from json
+func (t *SDKDate) UnmarshalJSON(data []byte) (e error) {
+	if string(data) == `"null"` {
+		t.Date = time.Time{}
+		return
+	}
+
+	t.Date, e = tryParsing(data,
+		strconv.Quote(sdkDateFormat),
+	)
+	return
+}
+
+// MarshalJSON marshals to JSON
+func (t *SDKDate) MarshalJSON() (buff []byte, e error) {
+	s := t.Date.Format(sdkDateFormat)
+	buff = []byte(strconv.Quote(s))
+	return
+}
+
 // PrivateKeyFromBytes is a helper function that will produce a RSA private
 // key from bytes.
 func PrivateKeyFromBytes(pemData []byte, password *string) (key *rsa.PrivateKey, e error) {

common/helpers_test.go

@@ -3,9 +3,12 @@
 package common
 
 import (
+	"encoding/json"
 	"fmt"
 	"github.com/stretchr/testify/assert"
+	"reflect"
 	"testing"
+	"time"
 )
 
 func TestStructToString(t *testing.T) {
@@ -82,3 +85,77 @@ func TestDateParsing_LastModifiedHeaderDate(t *testing.T) {
 		assert.Equal(t, tt.Day(), 2)
 	}
 }
+
+func TestFormattedTimeMarshaling(t *testing.T) {
+	sampleTime, _ := time.Parse(time.UnixDate, "Mon Jan 02 15:04:05 MST 2006")
+	testIO := []struct {
+		name          string
+		t             *SDKDate
+		expectedJSON  string
+		expectedError error
+	}{
+		{
+			name:          "formatting time to simple date format",
+			t:             &SDKDate{Date: sampleTime},
+			expectedJSON:  `"2006-01-02"`,
+			expectedError: nil,
+		},
+		{
+			name:          "formatting nil",
+			t:             nil,
+			expectedJSON:  `null`,
+			expectedError: nil,
+		},
+	}
+
+	for _, tc := range testIO {
+		t.Run(tc.name, func(t *testing.T) {
+			bytes, e := json.Marshal(&tc.t)
+			assert.Equal(t, tc.expectedError, e)
+			assert.Equal(t, tc.expectedJSON, string(bytes))
+		})
+	}
+
+}
+
+func TestFormattedTimeUnMarshaling(t *testing.T) {
+	sampleTime, _ := time.Parse(time.UnixDate, "Mon Jan 02 15:04:05 MST 2006")
+	testIO := []struct {
+		name          string
+		json          string
+		expectedTime  *SDKDate
+		expectedError error
+	}{
+		{
+			name:          "unmarshaling time to simple date format",
+			expectedTime:  &SDKDate{Date: sampleTime},
+			json:          `"2006-01-02"`,
+			expectedError: nil,
+		},
+		{
+			name:          "unmarshaling time to simple RFC3339 format",
+			expectedTime:  &SDKDate{Date: sampleTime},
+			json:          `"2006-01-02T15:04:05Z"`,
+			expectedError: &time.ParseError{},
+		},
+		{
+			name:          "unmarshaling null",
+			expectedTime:  &SDKDate{},
+			json:          `"null"`,
+			expectedError: nil,
+		},
+	}
+
+	for _, tc := range testIO {
+		t.Run(tc.name, func(t *testing.T) {
+			newTime := SDKDate{}
+			e := json.Unmarshal([]byte(tc.json), &newTime)
+			assert.IsType(t, reflect.TypeOf(tc.expectedError), reflect.TypeOf(e))
+			if tc.expectedError != nil {
+				return
+			}
+			assert.Equal(t, tc.expectedTime.Date.Format(sdkDateFormat), newTime.Date.Format(sdkDateFormat))
+		})
+	}
+
+}

common/http.go

@@ -42,6 +42,11 @@ func toStringValue(v reflect.Value, field reflect.StructField) (string, error) {
 		return formatTime(t), nil
 	}
 
+	if v.Type() == sdkDateType {
+		t := v.Interface().(SDKDate)
+		return formatDate(t), nil
+	}
+
 	switch v.Kind() {
 	case reflect.Bool:
 		return strconv.FormatBool(v.Bool()), nil
@@ -165,7 +170,8 @@ func omitNilFieldsInJSON(data interface{}, value reflect.Value) (interface{}, er
 				continue
 			}
 
-			if currentFieldValue.Type() == timeType || currentFieldValue.Type() == timeTypePtr {
+			if currentFieldValue.Type() == timeType || currentFieldValue.Type() == timeTypePtr ||
+				currentField.Type == sdkDateType || currentField.Type == sdkDateTypePtr {
 				continue
 			}
 			// does it need to be adjusted?
@@ -643,6 +649,16 @@ func analyzeValue(stringValue string, kind reflect.Kind, field reflect.StructFie
 		val = reflect.ValueOf(sdkTime)
 		valPointer = reflect.ValueOf(&sdkTime)
 		return
+	case sdkDateType.Kind():
+		var t time.Time
+		t, err = tryParsingTimeWithValidFormatsForHeaders([]byte(stringValue), field.Name)
+		if err != nil {
+			return
+		}
+		sdkDate := sdkDateFromTime(t)
+		val = reflect.ValueOf(sdkDate)
+		valPointer = reflect.ValueOf(&sdkDate)
+		return
 	case reflect.Bool:
 		var bVal bool
 		if bVal, err = strconv.ParseBool(stringValue); err != nil {