private/protocol: Add1 support for parsing fractional timestamp (#367)

Ports the V1 SDK's ability to parse fractional timestamp . Adds timestamp_test to assert behavior.

Fixes #365

Author: skotambkar

CHANGELOG_PENDING.md

@@ -1,6 +1,9 @@
 ### SDK Features
 
 ### SDK Enhancements
+* `private/protocol`: Add support for parsing fractional timestamp ([#367](https://github.com/aws/aws-sdk-go-v2/pull/367))
+  * Fixes the SDK's ability to parse fractional unix timestamp values and adds tests.
+  * Fixes [#365](https://github.com/aws/aws-sdk-go-v2/issues/365)
 
 ### SDK Bugs
 

internal/sdkmath/floor.go

@@ -0,0 +1,15 @@
+// +build go1.10
+
+package sdkmath
+
+import "math"
+
+// Round returns the nearest integer, rounding half away from zero.
+//
+// Special cases are:
+//	Round(±0) = ±0
+//	Round(±Inf) = ±Inf
+//	Round(NaN) = NaN
+func Round(x float64) float64 {
+	return math.Round(x)
+}

internal/sdkmath/floor_go1.9.go

@@ -0,0 +1,56 @@
+// +build !go1.10
+
+package sdkmath
+
+import "math"
+
+// Copied from the Go standard library's (Go 1.12) math/floor.go for use in
+// Go version prior to Go 1.10.
+const (
+	uvone    = 0x3FF0000000000000
+	mask     = 0x7FF
+	shift    = 64 - 11 - 1
+	bias     = 1023
+	signMask = 1 << 63
+	fracMask = 1<<shift - 1
+)
+
+// Round returns the nearest integer, rounding half away from zero.
+//
+// Special cases are:
+//	Round(±0) = ±0
+//	Round(±Inf) = ±Inf
+//	Round(NaN) = NaN
+//
+// Copied from the Go standard library's (Go 1.12) math/floor.go for use in
+// Go version prior to Go 1.10.
+func Round(x float64) float64 {
+	// Round is a faster implementation of:
+	//
+	// func Round(x float64) float64 {
+	//   t := Trunc(x)
+	//   if Abs(x-t) >= 0.5 {
+	//     return t + Copysign(1, x)
+	//   }
+	//   return t
+	// }
+	bits := math.Float64bits(x)
+	e := uint(bits>>shift) & mask
+	if e < bias {
+		// Round abs(x) < 1 including denormals.
+		bits &= signMask // +-0
+		if e == bias-1 {
+			bits |= uvone // +-1
+		}
+	} else if e < bias+shift {
+		// Round any abs(x) >= 1 containing a fractional component [0,1).
+		//
+		// Numbers with larger exponents are returned unchanged since they
+		// must be either an integer, infinity, or NaN.
+		const half = 1 << (shift - 1)
+		e -= bias
+		bits += half >> e
+		bits &^= fracMask >> e
+	}
+	return math.Float64frombits(bits)
+}

private/protocol/timestamp.go

@@ -2,8 +2,11 @@ package protocol
 
 import (
 	"fmt"
+	"math"
 	"strconv"
 	"time"
+
+	"github.com/aws/aws-sdk-go-v2/internal/sdkmath"
 )
 
 // Names of time formats supported by the SDK
@@ -18,8 +21,14 @@ const (
 	// RFC 7231#section-7.1.1.1 timetamp format. e.g Tue, 29 Apr 2014 18:30:38 GMT
 	RFC822TimeFormat = "Mon, 2 Jan 2006 15:04:05 GMT"
 
-	// RFC3339 a subset of the ISO8601 timestamp format. e.g 2014-04-29T18:30:38Z
-	ISO8601TimeFormat = "2006-01-02T15:04:05Z"
+	// RFC3339 a subset of the ISO8601 timestamp format. e.g 2014-04-29T18:30:38.999999999Z
+	ISO8601TimeFormat = "2006-01-02T15:04:05.999999999Z"
+
+	// RFC Output TimeStamp format is used for output time without seconds precision
+	RFC822OutputTimeFormat = "Mon, 02 Jan 2006 15:04:05 GMT"
+
+	// ISO output TimeStamp format is used for output time without seconds precision
+	ISO8601OutputTimeFormat = "2006-01-02T15:04:05Z"
 )
 
 // IsKnownTimestampFormat returns if the timestamp format name
@@ -38,18 +47,18 @@ func IsKnownTimestampFormat(name string) bool {
 }
 
 // FormatTime returns a string value of the time.
-func FormatTime(name string, t time.Time) (string,error) {
+func FormatTime(name string, t time.Time) (string, error) {
 	t = t.UTC()
 
 	switch name {
 	case RFC822TimeFormatName:
-		return t.Format(RFC822TimeFormat), nil
+		return t.Format(RFC822OutputTimeFormat), nil
 	case ISO8601TimeFormatName:
-		return t.Format(ISO8601TimeFormat), nil
+		return t.Format(ISO8601OutputTimeFormat), nil
 	case UnixTimeFormatName:
 		return strconv.FormatInt(t.Unix(), 10), nil
 	default:
-		return "",fmt.Errorf("unknown timestamp format name, " + name)
+		return "", fmt.Errorf("unknown timestamp format name, " + name)
 	}
 }
 
@@ -63,11 +72,13 @@ func ParseTime(formatName, value string) (time.Time, error) {
 		return time.Parse(ISO8601TimeFormat, value)
 	case UnixTimeFormatName:
 		v, err := strconv.ParseFloat(value, 64)
+		_, dec := math.Modf(v)
+		dec = sdkmath.Round(dec*1e3) / 1e3 //Rounds 0.1229999 to 0.123
 		if err != nil {
 			return time.Time{}, err
 		}
-		t := time.Unix(int64(v), 0)
-		return t.UTC(),nil
+		t := time.Unix(int64(v), int64(dec*(1e9)))
+		return t.UTC(), nil
 
 	default:
 		panic("unknown timestamp format name, " + formatName)

private/protocol/timestamp_test.go

@@ -0,0 +1,92 @@
+// +build go1.7
+
+package protocol
+
+import (
+	"testing"
+	"time"
+)
+
+func TestFormatTime(t *testing.T) {
+	cases := map[string]struct {
+		formatName     string
+		expectedOutput string
+		input          time.Time
+	}{
+		"UnixTest1": {
+			formatName:     UnixTimeFormatName,
+			expectedOutput: "946845296",
+			input:          time.Date(2000, time.January, 2, 20, 34, 56, .123e9, time.UTC),
+		},
+		"ISO8601Test1": {
+			formatName:     ISO8601TimeFormatName,
+			expectedOutput: "2000-01-02T20:34:56Z",
+			input:          time.Date(2000, time.January, 2, 20, 34, 56, .123e9, time.UTC),
+		},
+		"RFC822Test1": {
+			formatName:     RFC822TimeFormatName,
+			expectedOutput: "Sun, 02 Jan 2000 20:34:56 GMT",
+			input:          time.Date(2000, time.January, 2, 20, 34, 56, 0, time.UTC),
+		},
+	}
+
+	for name, c := range cases {
+		t.Run(name, func(t *testing.T) {
+			if v, _ := FormatTime(c.formatName, c.input); v != c.expectedOutput {
+				t.Errorf("input %v \n and output: %v, \n don't match for %s format ", c.input, c.expectedOutput, c.formatName)
+			}
+		})
+	}
+}
+
+func TestParseTime(t *testing.T) {
+
+	// Assert equals for input and output works for a precision upto three decimal places
+	cases := map[string]struct {
+		formatName, input string
+		expectedOutput    time.Time
+	}{
+		"UnixTest1": {
+			formatName:     UnixTimeFormatName,
+			input:          "946845296.123",
+			expectedOutput: time.Date(2000, time.January, 2, 20, 34, 56, .123e9, time.UTC),
+		},
+		"UnixTest2": {
+			formatName:     UnixTimeFormatName,
+			input:          "946845296.12344",
+			expectedOutput: time.Date(2000, time.January, 2, 20, 34, 56, .123e9, time.UTC),
+		},
+		"UnixTest3": {
+			formatName:     UnixTimeFormatName,
+			input:          "946845296.1229999",
+			expectedOutput: time.Date(2000, time.January, 2, 20, 34, 56, .123e9, time.UTC),
+		},
+		"ISO8601Test1": {
+			formatName:     ISO8601TimeFormatName,
+			input:          "2000-01-02T20:34:56.123Z",
+			expectedOutput: time.Date(2000, time.January, 2, 20, 34, 56, .123e9, time.UTC),
+		},
+		"ISO8601Test2": {
+			formatName:     ISO8601TimeFormatName,
+			input:          "2000-01-02T20:34:56.123456789Z",
+			expectedOutput: time.Date(2000, time.January, 2, 20, 34, 56, .123456789e9, time.UTC),
+		},
+		"RFC822Test1": {
+			formatName:     RFC822TimeFormatName,
+			input:          "Sun, 2 Jan 2000 20:34:56 GMT",
+			expectedOutput: time.Date(2000, time.January, 2, 20, 34, 56, 0, time.UTC),
+		},
+	}
+
+	for name, c := range cases {
+		t.Run(name, func(t *testing.T) {
+			timeVal, err := ParseTime(c.formatName, c.input)
+			if err != nil {
+				t.Errorf("unable to parse time, %v", err)
+			}
+			if timeVal.UTC() != c.expectedOutput {
+				t.Errorf("input: %v \n and output time %v,\n don't match for %s format ", c.input, c.expectedOutput, c.formatName)
+			}
+		})
+	}
+}