Add e2e tests

vendor/github.com/Azure/go-autorest/autorest/date/date.go

@@ -0,0 +1,96 @@
+/*
+Package date provides time.Time derivatives that conform to the Swagger.io (https://swagger.io/)
+defined date   formats: Date and DateTime. Both types may, in most cases, be used in lieu of
+time.Time types. And both convert to time.Time through a ToTime method.
+*/
+package date
+
+// Copyright 2017 Microsoft Corporation
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+
+import (
+	"fmt"
+	"time"
+)
+
+const (
+	fullDate     = "2006-01-02"
+	fullDateJSON = `"2006-01-02"`
+	dateFormat   = "%04d-%02d-%02d"
+	jsonFormat   = `"%04d-%02d-%02d"`
+)
+
+// Date defines a type similar to time.Time but assumes a layout of RFC3339 full-date (i.e.,
+// 2006-01-02).
+type Date struct {
+	time.Time
+}
+
+// ParseDate create a new Date from the passed string.
+func ParseDate(date string) (d Date, err error) {
+	return parseDate(date, fullDate)
+}
+
+func parseDate(date string, format string) (Date, error) {
+	d, err := time.Parse(format, date)
+	return Date{Time: d}, err
+}
+
+// MarshalBinary preserves the Date as a byte array conforming to RFC3339 full-date (i.e.,
+// 2006-01-02).
+func (d Date) MarshalBinary() ([]byte, error) {
+	return d.MarshalText()
+}
+
+// UnmarshalBinary reconstitutes a Date saved as a byte array conforming to RFC3339 full-date (i.e.,
+// 2006-01-02).
+func (d *Date) UnmarshalBinary(data []byte) error {
+	return d.UnmarshalText(data)
+}
+
+// MarshalJSON preserves the Date as a JSON string conforming to RFC3339 full-date (i.e.,
+// 2006-01-02).
+func (d Date) MarshalJSON() (json []byte, err error) {
+	return []byte(fmt.Sprintf(jsonFormat, d.Year(), d.Month(), d.Day())), nil
+}
+
+// UnmarshalJSON reconstitutes the Date from a JSON string conforming to RFC3339 full-date (i.e.,
+// 2006-01-02).
+func (d *Date) UnmarshalJSON(data []byte) (err error) {
+	d.Time, err = time.Parse(fullDateJSON, string(data))
+	return err
+}
+
+// MarshalText preserves the Date as a byte array conforming to RFC3339 full-date (i.e.,
+// 2006-01-02).
+func (d Date) MarshalText() (text []byte, err error) {
+	return []byte(fmt.Sprintf(dateFormat, d.Year(), d.Month(), d.Day())), nil
+}
+
+// UnmarshalText reconstitutes a Date saved as a byte array conforming to RFC3339 full-date (i.e.,
+// 2006-01-02).
+func (d *Date) UnmarshalText(data []byte) (err error) {
+	d.Time, err = time.Parse(fullDate, string(data))
+	return err
+}
+
+// String returns the Date formatted as an RFC3339 full-date string (i.e., 2006-01-02).
+func (d Date) String() string {
+	return fmt.Sprintf(dateFormat, d.Year(), d.Month(), d.Day())
+}
+
+// ToTime returns a Date as a time.Time
+func (d Date) ToTime() time.Time {
+	return d.Time
+}

vendor/github.com/Azure/go-autorest/autorest/date/date_test.go

@@ -0,0 +1,237 @@
+package date
+
+// Copyright 2017 Microsoft Corporation
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"testing"
+	"time"
+)
+
+func ExampleParseDate() {
+	d, err := ParseDate("2001-02-03")
+	if err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(d)
+	// Output: 2001-02-03
+}
+
+func ExampleDate() {
+	d, err := ParseDate("2001-02-03")
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	t, err := time.Parse(time.RFC3339, "2001-02-04T00:00:00Z")
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	// Date acts as time.Time when the receiver
+	if d.Before(t) {
+		fmt.Printf("Before ")
+	} else {
+		fmt.Printf("After ")
+	}
+
+	// Convert Date when needing a time.Time
+	if t.After(d.ToTime()) {
+		fmt.Printf("After")
+	} else {
+		fmt.Printf("Before")
+	}
+	// Output: Before After
+}
+
+func ExampleDate_MarshalBinary() {
+	d, err := ParseDate("2001-02-03")
+	if err != nil {
+		fmt.Println(err)
+	}
+	t, err := d.MarshalBinary()
+	if err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(string(t))
+	// Output: 2001-02-03
+}
+
+func ExampleDate_UnmarshalBinary() {
+	d := Date{}
+	t := "2001-02-03"
+
+	if err := d.UnmarshalBinary([]byte(t)); err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(d)
+	// Output: 2001-02-03
+}
+
+func ExampleDate_MarshalJSON() {
+	d, err := ParseDate("2001-02-03")
+	if err != nil {
+		fmt.Println(err)
+	}
+	j, err := json.Marshal(d)
+	if err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(string(j))
+	// Output: "2001-02-03"
+}
+
+func ExampleDate_UnmarshalJSON() {
+	var d struct {
+		Date Date `json:"date"`
+	}
+	j := `{"date" : "2001-02-03"}`
+
+	if err := json.Unmarshal([]byte(j), &d); err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(d.Date)
+	// Output: 2001-02-03
+}
+
+func ExampleDate_MarshalText() {
+	d, err := ParseDate("2001-02-03")
+	if err != nil {
+		fmt.Println(err)
+	}
+	t, err := d.MarshalText()
+	if err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(string(t))
+	// Output: 2001-02-03
+}
+
+func ExampleDate_UnmarshalText() {
+	d := Date{}
+	t := "2001-02-03"
+
+	if err := d.UnmarshalText([]byte(t)); err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(d)
+	// Output: 2001-02-03
+}
+
+func TestDateString(t *testing.T) {
+	d, err := ParseDate("2001-02-03")
+	if err != nil {
+		t.Fatalf("date: String failed (%v)", err)
+	}
+	if d.String() != "2001-02-03" {
+		t.Fatalf("date: String failed (%v)", d.String())
+	}
+}
+
+func TestDateBinaryRoundTrip(t *testing.T) {
+	d1, err := ParseDate("2001-02-03")
+	if err != nil {
+		t.Fatalf("date: ParseDate failed (%v)", err)
+	}
+	t1, err := d1.MarshalBinary()
+	if err != nil {
+		t.Fatalf("date: MarshalBinary failed (%v)", err)
+	}
+
+	d2 := Date{}
+	if err = d2.UnmarshalBinary(t1); err != nil {
+		t.Fatalf("date: UnmarshalBinary failed (%v)", err)
+	}
+
+	if !reflect.DeepEqual(d1, d2) {
+		t.Fatalf("date: Round-trip Binary failed (%v, %v)", d1, d2)
+	}
+}
+
+func TestDateJSONRoundTrip(t *testing.T) {
+	type s struct {
+		Date Date `json:"date"`
+	}
+	var err error
+	d1 := s{}
+	d1.Date, err = ParseDate("2001-02-03")
+	if err != nil {
+		t.Fatalf("date: ParseDate failed (%v)", err)
+	}
+
+	j, err := json.Marshal(d1)
+	if err != nil {
+		t.Fatalf("date: MarshalJSON failed (%v)", err)
+	}
+
+	d2 := s{}
+	if err = json.Unmarshal(j, &d2); err != nil {
+		t.Fatalf("date: UnmarshalJSON failed (%v)", err)
+	}
+
+	if !reflect.DeepEqual(d1, d2) {
+		t.Fatalf("date: Round-trip JSON failed (%v, %v)", d1, d2)
+	}
+}
+
+func TestDateTextRoundTrip(t *testing.T) {
+	d1, err := ParseDate("2001-02-03")
+	if err != nil {
+		t.Fatalf("date: ParseDate failed (%v)", err)
+	}
+	t1, err := d1.MarshalText()
+	if err != nil {
+		t.Fatalf("date: MarshalText failed (%v)", err)
+	}
+	d2 := Date{}
+	if err = d2.UnmarshalText(t1); err != nil {
+		t.Fatalf("date: UnmarshalText failed (%v)", err)
+	}
+
+	if !reflect.DeepEqual(d1, d2) {
+		t.Fatalf("date: Round-trip Text failed (%v, %v)", d1, d2)
+	}
+}
+
+func TestDateToTime(t *testing.T) {
+	var d Date
+	d, err := ParseDate("2001-02-03")
+	if err != nil {
+		t.Fatalf("date: ParseDate failed (%v)", err)
+	}
+	var _ time.Time = d.ToTime()
+}
+
+func TestDateUnmarshalJSONReturnsError(t *testing.T) {
+	var d struct {
+		Date Date `json:"date"`
+	}
+	j := `{"date" : "February 3, 2001"}`
+
+	if err := json.Unmarshal([]byte(j), &d); err == nil {
+		t.Fatal("date: Date failed to return error for malformed JSON date")
+	}
+}
+
+func TestDateUnmarshalTextReturnsError(t *testing.T) {
+	d := Date{}
+	txt := "February 3, 2001"
+
+	if err := d.UnmarshalText([]byte(txt)); err == nil {
+		t.Fatal("date: Date failed to return error for malformed Text date")
+	}
+}

vendor/github.com/Azure/go-autorest/autorest/date/time.go

@@ -0,0 +1,103 @@
+package date
+
+// Copyright 2017 Microsoft Corporation
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+
+import (
+	"regexp"
+	"time"
+)
+
+// Azure reports time in UTC but it doesn't include the 'Z' time zone suffix in some cases.
+const (
+	azureUtcFormatJSON = `"2006-01-02T15:04:05.999999999"`
+	azureUtcFormat     = "2006-01-02T15:04:05.999999999"
+	rfc3339JSON        = `"` + time.RFC3339Nano + `"`
+	rfc3339            = time.RFC3339Nano
+	tzOffsetRegex      = `(Z|z|\+|-)(\d+:\d+)*"*$`
+)
+
+// Time defines a type similar to time.Time but assumes a layout of RFC3339 date-time (i.e.,
+// 2006-01-02T15:04:05Z).
+type Time struct {
+	time.Time
+}
+
+// MarshalBinary preserves the Time as a byte array conforming to RFC3339 date-time (i.e.,
+// 2006-01-02T15:04:05Z).
+func (t Time) MarshalBinary() ([]byte, error) {
+	return t.Time.MarshalText()
+}
+
+// UnmarshalBinary reconstitutes a Time saved as a byte array conforming to RFC3339 date-time
+// (i.e., 2006-01-02T15:04:05Z).
+func (t *Time) UnmarshalBinary(data []byte) error {
+	return t.UnmarshalText(data)
+}
+
+// MarshalJSON preserves the Time as a JSON string conforming to RFC3339 date-time (i.e.,
+// 2006-01-02T15:04:05Z).
+func (t Time) MarshalJSON() (json []byte, err error) {
+	return t.Time.MarshalJSON()
+}
+
+// UnmarshalJSON reconstitutes the Time from a JSON string conforming to RFC3339 date-time
+// (i.e., 2006-01-02T15:04:05Z).
+func (t *Time) UnmarshalJSON(data []byte) (err error) {
+	timeFormat := azureUtcFormatJSON
+	match, err := regexp.Match(tzOffsetRegex, data)
+	if err != nil {
+		return err
+	} else if match {
+		timeFormat = rfc3339JSON
+	}
+	t.Time, err = ParseTime(timeFormat, string(data))
+	return err
+}
+
+// MarshalText preserves the Time as a byte array conforming to RFC3339 date-time (i.e.,
+// 2006-01-02T15:04:05Z).
+func (t Time) MarshalText() (text []byte, err error) {
+	return t.Time.MarshalText()
+}
+
+// UnmarshalText reconstitutes a Time saved as a byte array conforming to RFC3339 date-time
+// (i.e., 2006-01-02T15:04:05Z).
+func (t *Time) UnmarshalText(data []byte) (err error) {
+	timeFormat := azureUtcFormat
+	match, err := regexp.Match(tzOffsetRegex, data)
+	if err != nil {
+		return err
+	} else if match {
+		timeFormat = rfc3339
+	}
+	t.Time, err = ParseTime(timeFormat, string(data))
+	return err
+}
+
+// String returns the Time formatted as an RFC3339 date-time string (i.e.,
+// 2006-01-02T15:04:05Z).
+func (t Time) String() string {
+	// Note: time.Time.String does not return an RFC3339 compliant string, time.Time.MarshalText does.
+	b, err := t.MarshalText()
+	if err != nil {
+		return ""
+	}
+	return string(b)
+}
+
+// ToTime returns a Time as a time.Time
+func (t Time) ToTime() time.Time {
+	return t.Time
+}

vendor/github.com/Azure/go-autorest/autorest/date/time_test.go

@@ -0,0 +1,277 @@
+package date
+
+// Copyright 2017 Microsoft Corporation
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"testing"
+	"time"
+)
+
+func ExampleParseTime() {
+	d, _ := ParseTime(rfc3339, "2001-02-03T04:05:06Z")
+	fmt.Println(d)
+	// Output: 2001-02-03 04:05:06 +0000 UTC
+}
+
+func ExampleTime_MarshalBinary() {
+	ti, err := ParseTime(rfc3339, "2001-02-03T04:05:06Z")
+	if err != nil {
+		fmt.Println(err)
+	}
+	d := Time{ti}
+	t, err := d.MarshalBinary()
+	if err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(string(t))
+	// Output: 2001-02-03T04:05:06Z
+}
+
+func ExampleTime_UnmarshalBinary() {
+	d := Time{}
+	t := "2001-02-03T04:05:06Z"
+
+	if err := d.UnmarshalBinary([]byte(t)); err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(d)
+	// Output: 2001-02-03T04:05:06Z
+}
+
+func ExampleTime_MarshalJSON() {
+	d, err := ParseTime(rfc3339, "2001-02-03T04:05:06Z")
+	if err != nil {
+		fmt.Println(err)
+	}
+	j, err := json.Marshal(d)
+	if err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(string(j))
+	// Output: "2001-02-03T04:05:06Z"
+}
+
+func ExampleTime_UnmarshalJSON() {
+	var d struct {
+		Time Time `json:"datetime"`
+	}
+	j := `{"datetime" : "2001-02-03T04:05:06Z"}`
+
+	if err := json.Unmarshal([]byte(j), &d); err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(d.Time)
+	// Output: 2001-02-03T04:05:06Z
+}
+
+func ExampleTime_MarshalText() {
+	d, err := ParseTime(rfc3339, "2001-02-03T04:05:06Z")
+	if err != nil {
+		fmt.Println(err)
+	}
+	t, err := d.MarshalText()
+	if err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(string(t))
+	// Output: 2001-02-03T04:05:06Z
+}
+
+func ExampleTime_UnmarshalText() {
+	d := Time{}
+	t := "2001-02-03T04:05:06Z"
+
+	if err := d.UnmarshalText([]byte(t)); err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(d)
+	// Output: 2001-02-03T04:05:06Z
+}
+
+func TestUnmarshalTextforInvalidDate(t *testing.T) {
+	d := Time{}
+	dt := "2001-02-03T04:05:06AAA"
+
+	if err := d.UnmarshalText([]byte(dt)); err == nil {
+		t.Fatalf("date: Time#Unmarshal was expecting error for invalid date")
+	}
+}
+
+func TestUnmarshalJSONforInvalidDate(t *testing.T) {
+	d := Time{}
+	dt := `"2001-02-03T04:05:06AAA"`
+
+	if err := d.UnmarshalJSON([]byte(dt)); err == nil {
+		t.Fatalf("date: Time#Unmarshal was expecting error for invalid date")
+	}
+}
+
+func TestTimeString(t *testing.T) {
+	ti, err := ParseTime(rfc3339, "2001-02-03T04:05:06Z")
+	if err != nil {
+		fmt.Println(err)
+	}
+	d := Time{ti}
+	if d.String() != "2001-02-03T04:05:06Z" {
+		t.Fatalf("date: Time#String failed (%v)", d.String())
+	}
+}
+
+func TestTimeStringReturnsEmptyStringForError(t *testing.T) {
+	d := Time{Time: time.Date(20000, 01, 01, 01, 01, 01, 01, time.UTC)}
+	if d.String() != "" {
+		t.Fatalf("date: Time#String failed empty string for an error")
+	}
+}
+
+func TestTimeBinaryRoundTrip(t *testing.T) {
+	ti, err := ParseTime(rfc3339, "2001-02-03T04:05:06Z")
+	if err != nil {
+		t.Fatalf("date: Time#ParseTime failed (%v)", err)
+	}
+	d1 := Time{ti}
+	t1, err := d1.MarshalBinary()
+	if err != nil {
+		t.Fatalf("date: Time#MarshalBinary failed (%v)", err)
+	}
+
+	d2 := Time{}
+	if err = d2.UnmarshalBinary(t1); err != nil {
+		t.Fatalf("date: Time#UnmarshalBinary failed (%v)", err)
+	}
+
+	if !reflect.DeepEqual(d1, d2) {
+		t.Fatalf("date:Round-trip Binary failed (%v, %v)", d1, d2)
+	}
+}
+
+func TestTimeJSONRoundTrip(t *testing.T) {
+	type s struct {
+		Time Time `json:"datetime"`
+	}
+
+	ti, err := ParseTime(rfc3339, "2001-02-03T04:05:06Z")
+	if err != nil {
+		t.Fatalf("date: Time#ParseTime failed (%v)", err)
+	}
+
+	d1 := s{Time: Time{ti}}
+	j, err := json.Marshal(d1)
+	if err != nil {
+		t.Fatalf("date: Time#MarshalJSON failed (%v)", err)
+	}
+
+	d2 := s{}
+	if err = json.Unmarshal(j, &d2); err != nil {
+		t.Fatalf("date: Time#UnmarshalJSON failed (%v)", err)
+	}
+
+	if !reflect.DeepEqual(d1, d2) {
+		t.Fatalf("date: Round-trip JSON failed (%v, %v)", d1, d2)
+	}
+}
+
+func TestTimeTextRoundTrip(t *testing.T) {
+	ti, err := ParseTime(rfc3339, "2001-02-03T04:05:06Z")
+	if err != nil {
+		t.Fatalf("date: Time#ParseTime failed (%v)", err)
+	}
+	d1 := Time{Time: ti}
+	t1, err := d1.MarshalText()
+	if err != nil {
+		t.Fatalf("date: Time#MarshalText failed (%v)", err)
+	}
+
+	d2 := Time{}
+	if err = d2.UnmarshalText(t1); err != nil {
+		t.Fatalf("date: Time#UnmarshalText failed (%v)", err)
+	}
+
+	if !reflect.DeepEqual(d1, d2) {
+		t.Fatalf("date: Round-trip Text failed (%v, %v)", d1, d2)
+	}
+}
+
+func TestTimeToTime(t *testing.T) {
+	ti, err := ParseTime(rfc3339, "2001-02-03T04:05:06Z")
+	d := Time{ti}
+	if err != nil {
+		t.Fatalf("date: Time#ParseTime failed (%v)", err)
+	}
+	var _ time.Time = d.ToTime()
+}
+
+func TestUnmarshalJSONNoOffset(t *testing.T) {
+	var d struct {
+		Time Time `json:"datetime"`
+	}
+	j := `{"datetime" : "2001-02-03T04:05:06.789"}`
+
+	if err := json.Unmarshal([]byte(j), &d); err != nil {
+		t.Fatalf("date: Time#Unmarshal failed (%v)", err)
+	}
+}
+
+func TestUnmarshalJSONPosOffset(t *testing.T) {
+	var d struct {
+		Time Time `json:"datetime"`
+	}
+	j := `{"datetime" : "1980-01-02T00:11:35.01+01:00"}`
+
+	if err := json.Unmarshal([]byte(j), &d); err != nil {
+		t.Fatalf("date: Time#Unmarshal failed (%v)", err)
+	}
+}
+
+func TestUnmarshalJSONNegOffset(t *testing.T) {
+	var d struct {
+		Time Time `json:"datetime"`
+	}
+	j := `{"datetime" : "1492-10-12T10:15:01.789-08:00"}`
+
+	if err := json.Unmarshal([]byte(j), &d); err != nil {
+		t.Fatalf("date: Time#Unmarshal failed (%v)", err)
+	}
+}
+
+func TestUnmarshalTextNoOffset(t *testing.T) {
+	d := Time{}
+	t1 := "2001-02-03T04:05:06"
+
+	if err := d.UnmarshalText([]byte(t1)); err != nil {
+		t.Fatalf("date: Time#UnmarshalText failed (%v)", err)
+	}
+}
+
+func TestUnmarshalTextPosOffset(t *testing.T) {
+	d := Time{}
+	t1 := "2001-02-03T04:05:06+00:30"
+
+	if err := d.UnmarshalText([]byte(t1)); err != nil {
+		t.Fatalf("date: Time#UnmarshalText failed (%v)", err)
+	}
+}
+
+func TestUnmarshalTextNegOffset(t *testing.T) {
+	d := Time{}
+	t1 := "2001-02-03T04:05:06-11:00"
+
+	if err := d.UnmarshalText([]byte(t1)); err != nil {
+		t.Fatalf("date: Time#UnmarshalText failed (%v)", err)
+	}
+}

vendor/github.com/Azure/go-autorest/autorest/date/timerfc1123.go

@@ -0,0 +1,100 @@
+package date
+
+// Copyright 2017 Microsoft Corporation
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+
+import (
+	"errors"
+	"time"
+)
+
+const (
+	rfc1123JSON = `"` + time.RFC1123 + `"`
+	rfc1123     = time.RFC1123
+)
+
+// TimeRFC1123 defines a type similar to time.Time but assumes a layout of RFC1123 date-time (i.e.,
+// Mon, 02 Jan 2006 15:04:05 MST).
+type TimeRFC1123 struct {
+	time.Time
+}
+
+// UnmarshalJSON reconstitutes the Time from a JSON string conforming to RFC1123 date-time
+// (i.e., Mon, 02 Jan 2006 15:04:05 MST).
+func (t *TimeRFC1123) UnmarshalJSON(data []byte) (err error) {
+	t.Time, err = ParseTime(rfc1123JSON, string(data))
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// MarshalJSON preserves the Time as a JSON string conforming to RFC1123 date-time (i.e.,
+// Mon, 02 Jan 2006 15:04:05 MST).
+func (t TimeRFC1123) MarshalJSON() ([]byte, error) {
+	if y := t.Year(); y < 0 || y >= 10000 {
+		return nil, errors.New("Time.MarshalJSON: year outside of range [0,9999]")
+	}
+	b := []byte(t.Format(rfc1123JSON))
+	return b, nil
+}
+
+// MarshalText preserves the Time as a byte array conforming to RFC1123 date-time (i.e.,
+// Mon, 02 Jan 2006 15:04:05 MST).
+func (t TimeRFC1123) MarshalText() ([]byte, error) {
+	if y := t.Year(); y < 0 || y >= 10000 {
+		return nil, errors.New("Time.MarshalText: year outside of range [0,9999]")
+	}
+
+	b := []byte(t.Format(rfc1123))
+	return b, nil
+}
+
+// UnmarshalText reconstitutes a Time saved as a byte array conforming to RFC1123 date-time
+// (i.e., Mon, 02 Jan 2006 15:04:05 MST).
+func (t *TimeRFC1123) UnmarshalText(data []byte) (err error) {
+	t.Time, err = ParseTime(rfc1123, string(data))
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// MarshalBinary preserves the Time as a byte array conforming to RFC1123 date-time (i.e.,
+// Mon, 02 Jan 2006 15:04:05 MST).
+func (t TimeRFC1123) MarshalBinary() ([]byte, error) {
+	return t.MarshalText()
+}
+
+// UnmarshalBinary reconstitutes a Time saved as a byte array conforming to RFC1123 date-time
+// (i.e., Mon, 02 Jan 2006 15:04:05 MST).
+func (t *TimeRFC1123) UnmarshalBinary(data []byte) error {
+	return t.UnmarshalText(data)
+}
+
+// ToTime returns a Time as a time.Time
+func (t TimeRFC1123) ToTime() time.Time {
+	return t.Time
+}
+
+// String returns the Time formatted as an RFC1123 date-time string (i.e.,
+// Mon, 02 Jan 2006 15:04:05 MST).
+func (t TimeRFC1123) String() string {
+	// Note: time.Time.String does not return an RFC1123 compliant string, time.Time.MarshalText does.
+	b, err := t.MarshalText()
+	if err != nil {
+		return ""
+	}
+	return string(b)
+}

vendor/github.com/Azure/go-autorest/autorest/date/timerfc1123_test.go

@@ -0,0 +1,226 @@
+package date
+
+// Copyright 2017 Microsoft Corporation
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"testing"
+	"time"
+)
+
+func ExampleTimeRFC1123() {
+	d, err := ParseTime(rfc1123, "Mon, 02 Jan 2006 15:04:05 MST")
+	if err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(d)
+	// Output: 2006-01-02 15:04:05 +0000 MST
+}
+
+func ExampleTimeRFC1123_MarshalBinary() {
+	ti, err := ParseTime(rfc1123, "Mon, 02 Jan 2006 15:04:05 MST")
+	if err != nil {
+		fmt.Println(err)
+	}
+	d := TimeRFC1123{ti}
+	b, err := d.MarshalBinary()
+	if err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(string(b))
+	// Output: Mon, 02 Jan 2006 15:04:05 MST
+}
+
+func ExampleTimeRFC1123_UnmarshalBinary() {
+	d := TimeRFC1123{}
+	t := "Mon, 02 Jan 2006 15:04:05 MST"
+	if err := d.UnmarshalBinary([]byte(t)); err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(d)
+	// Output: Mon, 02 Jan 2006 15:04:05 MST
+}
+
+func ExampleTimeRFC1123_MarshalJSON() {
+	ti, err := ParseTime(rfc1123, "Mon, 02 Jan 2006 15:04:05 MST")
+	if err != nil {
+		fmt.Println(err)
+	}
+	d := TimeRFC1123{ti}
+	j, err := json.Marshal(d)
+	if err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(string(j))
+	// Output: "Mon, 02 Jan 2006 15:04:05 MST"
+}
+
+func TestTimeRFC1123MarshalJSONInvalid(t *testing.T) {
+	ti := time.Date(20000, 01, 01, 00, 00, 00, 00, time.UTC)
+	d := TimeRFC1123{ti}
+	if _, err := json.Marshal(d); err == nil {
+		t.Fatalf("date: TimeRFC1123#Marshal failed for invalid date")
+	}
+}
+
+func ExampleTimeRFC1123_UnmarshalJSON() {
+	var d struct {
+		Time TimeRFC1123 `json:"datetime"`
+	}
+	j := `{"datetime" : "Mon, 02 Jan 2006 15:04:05 MST"}`
+
+	if err := json.Unmarshal([]byte(j), &d); err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(d.Time)
+	// Output: Mon, 02 Jan 2006 15:04:05 MST
+}
+
+func ExampleTimeRFC1123_MarshalText() {
+	ti, err := ParseTime(rfc3339, "2001-02-03T04:05:06Z")
+	if err != nil {
+		fmt.Println(err)
+	}
+	d := TimeRFC1123{ti}
+	t, err := d.MarshalText()
+	if err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(string(t))
+	// Output: Sat, 03 Feb 2001 04:05:06 UTC
+}
+
+func ExampleTimeRFC1123_UnmarshalText() {
+	d := TimeRFC1123{}
+	t := "Sat, 03 Feb 2001 04:05:06 UTC"
+
+	if err := d.UnmarshalText([]byte(t)); err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(d)
+	// Output: Sat, 03 Feb 2001 04:05:06 UTC
+}
+
+func TestUnmarshalJSONforInvalidDateRfc1123(t *testing.T) {
+	dt := `"Mon, 02 Jan 2000000 15:05 MST"`
+	d := TimeRFC1123{}
+	if err := d.UnmarshalJSON([]byte(dt)); err == nil {
+		t.Fatalf("date: TimeRFC1123#Unmarshal failed for invalid date")
+	}
+}
+
+func TestUnmarshalTextforInvalidDateRfc1123(t *testing.T) {
+	dt := "Mon, 02 Jan 2000000 15:05 MST"
+	d := TimeRFC1123{}
+	if err := d.UnmarshalText([]byte(dt)); err == nil {
+		t.Fatalf("date: TimeRFC1123#Unmarshal failed for invalid date")
+	}
+}
+
+func TestTimeStringRfc1123(t *testing.T) {
+	ti, err := ParseTime(rfc1123, "Mon, 02 Jan 2006 15:04:05 MST")
+	if err != nil {
+		fmt.Println(err)
+	}
+	d := TimeRFC1123{ti}
+	if d.String() != "Mon, 02 Jan 2006 15:04:05 MST" {
+		t.Fatalf("date: TimeRFC1123#String failed (%v)", d.String())
+	}
+}
+
+func TestTimeStringReturnsEmptyStringForErrorRfc1123(t *testing.T) {
+	d := TimeRFC1123{Time: time.Date(20000, 01, 01, 01, 01, 01, 01, time.UTC)}
+	if d.String() != "" {
+		t.Fatalf("date: TimeRFC1123#String failed empty string for an error")
+	}
+}
+
+func TestTimeBinaryRoundTripRfc1123(t *testing.T) {
+	ti, err := ParseTime(rfc3339, "2001-02-03T04:05:06Z")
+	if err != nil {
+		t.Fatalf("date: TimeRFC1123#ParseTime failed (%v)", err)
+	}
+	d1 := TimeRFC1123{ti}
+	t1, err := d1.MarshalBinary()
+	if err != nil {
+		t.Fatalf("date: TimeRFC1123#MarshalBinary failed (%v)", err)
+	}
+
+	d2 := TimeRFC1123{}
+	if err = d2.UnmarshalBinary(t1); err != nil {
+		t.Fatalf("date: TimeRFC1123#UnmarshalBinary failed (%v)", err)
+	}
+
+	if !reflect.DeepEqual(d1, d2) {
+		t.Fatalf("date: Round-trip Binary failed (%v, %v)", d1, d2)
+	}
+}
+
+func TestTimeJSONRoundTripRfc1123(t *testing.T) {
+	type s struct {
+		Time TimeRFC1123 `json:"datetime"`
+	}
+	var err error
+	ti, err := ParseTime(rfc1123, "Mon, 02 Jan 2006 15:04:05 MST")
+	if err != nil {
+		t.Fatalf("date: TimeRFC1123#ParseTime failed (%v)", err)
+	}
+	d1 := s{Time: TimeRFC1123{ti}}
+	j, err := json.Marshal(d1)
+	if err != nil {
+		t.Fatalf("date: TimeRFC1123#MarshalJSON failed (%v)", err)
+	}
+
+	d2 := s{}
+	if err = json.Unmarshal(j, &d2); err != nil {
+		t.Fatalf("date: TimeRFC1123#UnmarshalJSON failed (%v)", err)
+	}
+
+	if !reflect.DeepEqual(d1, d2) {
+		t.Fatalf("date: Round-trip JSON failed (%v, %v)", d1, d2)
+	}
+}
+
+func TestTimeTextRoundTripRfc1123(t *testing.T) {
+	ti, err := ParseTime(rfc1123, "Mon, 02 Jan 2006 15:04:05 MST")
+	if err != nil {
+		t.Fatalf("date: TimeRFC1123#ParseTime failed (%v)", err)
+	}
+	d1 := TimeRFC1123{Time: ti}
+	t1, err := d1.MarshalText()
+	if err != nil {
+		t.Fatalf("date: TimeRFC1123#MarshalText failed (%v)", err)
+	}
+
+	d2 := TimeRFC1123{}
+	if err = d2.UnmarshalText(t1); err != nil {
+		t.Fatalf("date: TimeRFC1123#UnmarshalText failed (%v)", err)
+	}
+
+	if !reflect.DeepEqual(d1, d2) {
+		t.Fatalf("date: Round-trip Text failed (%v, %v)", d1, d2)
+	}
+}
+
+func TestTimeToTimeRFC1123(t *testing.T) {
+	ti, err := ParseTime(rfc1123, "Mon, 02 Jan 2006 15:04:05 MST")
+	d := TimeRFC1123{ti}
+	if err != nil {
+		t.Fatalf("date: TimeRFC1123#ParseTime failed (%v)", err)
+	}
+	var _ time.Time = d.ToTime()
+}

vendor/github.com/Azure/go-autorest/autorest/date/unixtime.go

@@ -0,0 +1,123 @@
+package date
+
+// Copyright 2017 Microsoft Corporation
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/json"
+	"time"
+)
+
+// unixEpoch is the moment in time that should be treated as timestamp 0.
+var unixEpoch = time.Date(1970, time.January, 1, 0, 0, 0, 0, time.UTC)
+
+// UnixTime marshals and unmarshals a time that is represented as the number
+// of seconds (ignoring skip-seconds) since the Unix Epoch.
+type UnixTime time.Time
+
+// Duration returns the time as a Duration since the UnixEpoch.
+func (t UnixTime) Duration() time.Duration {
+	return time.Time(t).Sub(unixEpoch)
+}
+
+// NewUnixTimeFromSeconds creates a UnixTime as a number of seconds from the UnixEpoch.
+func NewUnixTimeFromSeconds(seconds float64) UnixTime {
+	return NewUnixTimeFromDuration(time.Duration(seconds * float64(time.Second)))
+}
+
+// NewUnixTimeFromNanoseconds creates a UnixTime as a number of nanoseconds from the UnixEpoch.
+func NewUnixTimeFromNanoseconds(nanoseconds int64) UnixTime {
+	return NewUnixTimeFromDuration(time.Duration(nanoseconds))
+}
+
+// NewUnixTimeFromDuration creates a UnixTime as a duration of time since the UnixEpoch.
+func NewUnixTimeFromDuration(dur time.Duration) UnixTime {
+	return UnixTime(unixEpoch.Add(dur))
+}
+
+// UnixEpoch retreives the moment considered the Unix Epoch. I.e. The time represented by '0'
+func UnixEpoch() time.Time {
+	return unixEpoch
+}
+
+// MarshalJSON preserves the UnixTime as a JSON number conforming to Unix Timestamp requirements.
+// (i.e. the number of seconds since midnight January 1st, 1970 not considering leap seconds.)
+func (t UnixTime) MarshalJSON() ([]byte, error) {
+	buffer := &bytes.Buffer{}
+	enc := json.NewEncoder(buffer)
+	err := enc.Encode(float64(time.Time(t).UnixNano()) / 1e9)
+	if err != nil {
+		return nil, err
+	}
+	return buffer.Bytes(), nil
+}
+
+// UnmarshalJSON reconstitures a UnixTime saved as a JSON number of the number of seconds since
+// midnight January 1st, 1970.
+func (t *UnixTime) UnmarshalJSON(text []byte) error {
+	dec := json.NewDecoder(bytes.NewReader(text))
+
+	var secondsSinceEpoch float64
+	if err := dec.Decode(&secondsSinceEpoch); err != nil {
+		return err
+	}
+
+	*t = NewUnixTimeFromSeconds(secondsSinceEpoch)
+
+	return nil
+}
+
+// MarshalText stores the number of seconds since the Unix Epoch as a textual floating point number.
+func (t UnixTime) MarshalText() ([]byte, error) {
+	cast := time.Time(t)
+	return cast.MarshalText()
+}
+
+// UnmarshalText populates a UnixTime with a value stored textually as a floating point number of seconds since the Unix Epoch.
+func (t *UnixTime) UnmarshalText(raw []byte) error {
+	var unmarshaled time.Time
+
+	if err := unmarshaled.UnmarshalText(raw); err != nil {
+		return err
+	}
+
+	*t = UnixTime(unmarshaled)
+	return nil
+}
+
+// MarshalBinary converts a UnixTime into a binary.LittleEndian float64 of nanoseconds since the epoch.
+func (t UnixTime) MarshalBinary() ([]byte, error) {
+	buf := &bytes.Buffer{}
+
+	payload := int64(t.Duration())
+
+	if err := binary.Write(buf, binary.LittleEndian, &payload); err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+// UnmarshalBinary converts a from a binary.LittleEndian float64 of nanoseconds since the epoch into a UnixTime.
+func (t *UnixTime) UnmarshalBinary(raw []byte) error {
+	var nanosecondsSinceEpoch int64
+
+	if err := binary.Read(bytes.NewReader(raw), binary.LittleEndian, &nanosecondsSinceEpoch); err != nil {
+		return err
+	}
+	*t = NewUnixTimeFromNanoseconds(nanosecondsSinceEpoch)
+	return nil
+}

vendor/github.com/Azure/go-autorest/autorest/date/unixtime_test.go

@@ -0,0 +1,283 @@
+// +build go1.7
+
+package date
+
+// Copyright 2017 Microsoft Corporation
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/json"
+	"fmt"
+	"math"
+	"testing"
+	"time"
+)
+
+func ExampleUnixTime_MarshalJSON() {
+	epoch := UnixTime(UnixEpoch())
+	text, _ := json.Marshal(epoch)
+	fmt.Print(string(text))
+	// Output: 0
+}
+
+func ExampleUnixTime_UnmarshalJSON() {
+	var myTime UnixTime
+	json.Unmarshal([]byte("1.3e2"), &myTime)
+	fmt.Printf("%v", time.Time(myTime))
+	// Output: 1970-01-01 00:02:10 +0000 UTC
+}
+
+func TestUnixTime_MarshalJSON(t *testing.T) {
+	testCases := []time.Time{
+		UnixEpoch().Add(-1 * time.Second),                        // One second befote the Unix Epoch
+		time.Date(2017, time.April, 14, 20, 27, 47, 0, time.UTC), // The time this test was written
+		UnixEpoch(),
+		time.Date(1800, 01, 01, 0, 0, 0, 0, time.UTC),
+		time.Date(2200, 12, 29, 00, 01, 37, 82, time.UTC),
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.String(), func(subT *testing.T) {
+			var actual, expected float64
+			var marshaled []byte
+
+			target := UnixTime(tc)
+			expected = float64(target.Duration().Nanoseconds()) / 1e9
+
+			if temp, err := json.Marshal(target); err == nil {
+				marshaled = temp
+			} else {
+				subT.Error(err)
+				return
+			}
+
+			dec := json.NewDecoder(bytes.NewReader(marshaled))
+			if err := dec.Decode(&actual); err != nil {
+				subT.Error(err)
+				return
+			}
+
+			diff := math.Abs(actual - expected)
+			subT.Logf("\ngot :\t%g\nwant:\t%g\ndiff:\t%g", actual, expected, diff)
+			if diff > 1e-9 { //Must be within 1 nanosecond of one another
+				subT.Fail()
+			}
+		})
+	}
+}
+
+func TestUnixTime_UnmarshalJSON(t *testing.T) {
+	testCases := []struct {
+		text     string
+		expected time.Time
+	}{
+		{"1", UnixEpoch().Add(time.Second)},
+		{"0", UnixEpoch()},
+		{"1492203742", time.Date(2017, time.April, 14, 21, 02, 22, 0, time.UTC)}, // The time this test was written
+		{"-1", time.Date(1969, time.December, 31, 23, 59, 59, 0, time.UTC)},
+		{"1.5", UnixEpoch().Add(1500 * time.Millisecond)},
+		{"0e1", UnixEpoch()}, // See http://json.org for 'number' format definition.
+		{"1.3e+2", UnixEpoch().Add(130 * time.Second)},
+		{"1.6E-10", UnixEpoch()}, // This is so small, it should get truncated into the UnixEpoch
+		{"2E-6", UnixEpoch().Add(2 * time.Microsecond)},
+		{"1.289345e9", UnixEpoch().Add(1289345000 * time.Second)},
+		{"1e-9", UnixEpoch().Add(time.Nanosecond)},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.text, func(subT *testing.T) {
+			var rehydrated UnixTime
+			if err := json.Unmarshal([]byte(tc.text), &rehydrated); err != nil {
+				subT.Error(err)
+				return
+			}
+
+			if time.Time(rehydrated) != tc.expected {
+				subT.Logf("\ngot: \t%v\nwant:\t%v\ndiff:\t%v", time.Time(rehydrated), tc.expected, time.Time(rehydrated).Sub(tc.expected))
+				subT.Fail()
+			}
+		})
+	}
+}
+
+func TestUnixTime_JSONRoundTrip(t *testing.T) {
+	testCases := []time.Time{
+		UnixEpoch(),
+		time.Date(2005, time.November, 5, 0, 0, 0, 0, time.UTC), // The day V for Vendetta (film) was released.
+		UnixEpoch().Add(-6 * time.Second),
+		UnixEpoch().Add(800 * time.Hour),
+		UnixEpoch().Add(time.Nanosecond),
+		time.Date(2015, time.September, 05, 4, 30, 12, 9992, time.UTC),
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.String(), func(subT *testing.T) {
+			subject := UnixTime(tc)
+			var marshaled []byte
+			if temp, err := json.Marshal(subject); err == nil {
+				marshaled = temp
+			} else {
+				subT.Error(err)
+				return
+			}
+
+			var unmarshaled UnixTime
+			if err := json.Unmarshal(marshaled, &unmarshaled); err != nil {
+				subT.Error(err)
+			}
+
+			actual := time.Time(unmarshaled)
+			diff := actual.Sub(tc)
+			subT.Logf("\ngot :\t%s\nwant:\t%s\ndiff:\t%s", actual.String(), tc.String(), diff.String())
+
+			if diff > time.Duration(100) { // We lose some precision be working in floats. We shouldn't lose more than 100 nanoseconds.
+				subT.Fail()
+			}
+		})
+	}
+}
+
+func TestUnixTime_MarshalBinary(t *testing.T) {
+	testCases := []struct {
+		expected int64
+		subject  time.Time
+	}{
+		{0, UnixEpoch()},
+		{-15 * int64(time.Second), UnixEpoch().Add(-15 * time.Second)},
+		{54, UnixEpoch().Add(54 * time.Nanosecond)},
+	}
+
+	for _, tc := range testCases {
+		t.Run("", func(subT *testing.T) {
+			var marshaled []byte
+
+			if temp, err := UnixTime(tc.subject).MarshalBinary(); err == nil {
+				marshaled = temp
+			} else {
+				subT.Error(err)
+				return
+			}
+
+			var unmarshaled int64
+			if err := binary.Read(bytes.NewReader(marshaled), binary.LittleEndian, &unmarshaled); err != nil {
+				subT.Error(err)
+				return
+			}
+
+			if unmarshaled != tc.expected {
+				subT.Logf("\ngot: \t%d\nwant:\t%d", unmarshaled, tc.expected)
+				subT.Fail()
+			}
+		})
+	}
+}
+
+func TestUnixTime_BinaryRoundTrip(t *testing.T) {
+	testCases := []time.Time{
+		UnixEpoch(),
+		UnixEpoch().Add(800 * time.Minute),
+		UnixEpoch().Add(7 * time.Hour),
+		UnixEpoch().Add(-1 * time.Nanosecond),
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.String(), func(subT *testing.T) {
+			original := UnixTime(tc)
+			var marshaled []byte
+
+			if temp, err := original.MarshalBinary(); err == nil {
+				marshaled = temp
+			} else {
+				subT.Error(err)
+				return
+			}
+
+			var traveled UnixTime
+			if err := traveled.UnmarshalBinary(marshaled); err != nil {
+				subT.Error(err)
+				return
+			}
+
+			if traveled != original {
+				subT.Logf("\ngot: \t%s\nwant:\t%s", time.Time(original).String(), time.Time(traveled).String())
+				subT.Fail()
+			}
+		})
+	}
+}
+
+func TestUnixTime_MarshalText(t *testing.T) {
+	testCases := []time.Time{
+		UnixEpoch(),
+		UnixEpoch().Add(45 * time.Second),
+		UnixEpoch().Add(time.Nanosecond),
+		UnixEpoch().Add(-100000 * time.Second),
+	}
+
+	for _, tc := range testCases {
+		expected, _ := tc.MarshalText()
+		t.Run("", func(subT *testing.T) {
+			var marshaled []byte
+
+			if temp, err := UnixTime(tc).MarshalText(); err == nil {
+				marshaled = temp
+			} else {
+				subT.Error(err)
+				return
+			}
+
+			if string(marshaled) != string(expected) {
+				subT.Logf("\ngot: \t%s\nwant:\t%s", string(marshaled), string(expected))
+				subT.Fail()
+			}
+		})
+	}
+}
+
+func TestUnixTime_TextRoundTrip(t *testing.T) {
+	testCases := []time.Time{
+		UnixEpoch(),
+		UnixEpoch().Add(-1 * time.Nanosecond),
+		UnixEpoch().Add(1 * time.Nanosecond),
+		time.Date(2017, time.April, 17, 21, 00, 00, 00, time.UTC),
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.String(), func(subT *testing.T) {
+			unixTC := UnixTime(tc)
+
+			var marshaled []byte
+
+			if temp, err := unixTC.MarshalText(); err == nil {
+				marshaled = temp
+			} else {
+				subT.Error(err)
+				return
+			}
+
+			var unmarshaled UnixTime
+			if err := unmarshaled.UnmarshalText(marshaled); err != nil {
+				subT.Error(err)
+				return
+			}
+
+			if unmarshaled != unixTC {
+				t.Logf("\ngot: \t%s\nwant:\t%s", time.Time(unmarshaled).String(), tc.String())
+				t.Fail()
+			}
+		})
+	}
+}

vendor/github.com/Azure/go-autorest/autorest/date/utility.go

@@ -0,0 +1,25 @@
+package date
+
+// Copyright 2017 Microsoft Corporation
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+
+import (
+	"strings"
+	"time"
+)
+
+// ParseTime to parse Time string to specified format.
+func ParseTime(format string, t string) (d time.Time, err error) {
+	return time.Parse(format, strings.ToUpper(t))
+}