1// Copyright 2016 The Go Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5package ptypes
6
7import (
8	"math"
9	"testing"
10	"time"
11
12	"github.com/golang/protobuf/proto"
13
14	tspb "github.com/golang/protobuf/ptypes/timestamp"
15)
16
17var tests = []struct {
18	ts    *tspb.Timestamp
19	valid bool
20	t     time.Time
21}{
22	// The timestamp representing the Unix epoch date.
23	{&tspb.Timestamp{Seconds: 0, Nanos: 0}, true, utcDate(1970, 1, 1)},
24	// The smallest representable timestamp.
25	{&tspb.Timestamp{Seconds: math.MinInt64, Nanos: math.MinInt32}, false,
26		time.Unix(math.MinInt64, math.MinInt32).UTC()},
27	// The smallest representable timestamp with non-negative nanos.
28	{&tspb.Timestamp{Seconds: math.MinInt64, Nanos: 0}, false, time.Unix(math.MinInt64, 0).UTC()},
29	// The earliest valid timestamp.
30	{&tspb.Timestamp{Seconds: minValidSeconds, Nanos: 0}, true, utcDate(1, 1, 1)},
31	//"0001-01-01T00:00:00Z"},
32	// The largest representable timestamp.
33	{&tspb.Timestamp{Seconds: math.MaxInt64, Nanos: math.MaxInt32}, false,
34		time.Unix(math.MaxInt64, math.MaxInt32).UTC()},
35	// The largest representable timestamp with nanos in range.
36	{&tspb.Timestamp{Seconds: math.MaxInt64, Nanos: 1e9 - 1}, false,
37		time.Unix(math.MaxInt64, 1e9-1).UTC()},
38	// The largest valid timestamp.
39	{&tspb.Timestamp{Seconds: maxValidSeconds - 1, Nanos: 1e9 - 1}, true,
40		time.Date(9999, 12, 31, 23, 59, 59, 1e9-1, time.UTC)},
41	// The smallest invalid timestamp that is larger than the valid range.
42	{&tspb.Timestamp{Seconds: maxValidSeconds, Nanos: 0}, false, time.Unix(maxValidSeconds, 0).UTC()},
43	// A date before the epoch.
44	{&tspb.Timestamp{Seconds: -281836800, Nanos: 0}, true, utcDate(1961, 1, 26)},
45	// A date after the epoch.
46	{&tspb.Timestamp{Seconds: 1296000000, Nanos: 0}, true, utcDate(2011, 1, 26)},
47	// A date after the epoch, in the middle of the day.
48	{&tspb.Timestamp{Seconds: 1296012345, Nanos: 940483}, true,
49		time.Date(2011, 1, 26, 3, 25, 45, 940483, time.UTC)},
50}
51
52func TestValidateTimestamp(t *testing.T) {
53	for _, s := range tests {
54		got := validateTimestamp(s.ts)
55		if (got == nil) != s.valid {
56			t.Errorf("validateTimestamp(%v) = %v, want %v", s.ts, got, s.valid)
57		}
58	}
59}
60
61func TestTimestamp(t *testing.T) {
62	for _, s := range tests {
63		got, err := Timestamp(s.ts)
64		if (err == nil) != s.valid {
65			t.Errorf("Timestamp(%v) error = %v, but valid = %t", s.ts, err, s.valid)
66		} else if s.valid && got != s.t {
67			t.Errorf("Timestamp(%v) = %v, want %v", s.ts, got, s.t)
68		}
69	}
70	// Special case: a nil Timestamp is an error, but returns the 0 Unix time.
71	got, err := Timestamp(nil)
72	want := time.Unix(0, 0).UTC()
73	if got != want {
74		t.Errorf("Timestamp(nil) = %v, want %v", got, want)
75	}
76	if err == nil {
77		t.Errorf("Timestamp(nil) error = nil, expected error")
78	}
79}
80
81func TestTimestampProto(t *testing.T) {
82	for _, s := range tests {
83		got, err := TimestampProto(s.t)
84		if (err == nil) != s.valid {
85			t.Errorf("TimestampProto(%v) error = %v, but valid = %t", s.t, err, s.valid)
86		} else if s.valid && !proto.Equal(got, s.ts) {
87			t.Errorf("TimestampProto(%v) = %v, want %v", s.t, got, s.ts)
88		}
89	}
90	// No corresponding special case here: no time.Time results in a nil Timestamp.
91}
92
93func TestTimestampString(t *testing.T) {
94	for _, test := range []struct {
95		ts   *tspb.Timestamp
96		want string
97	}{
98		// Not much testing needed because presumably time.Format is
99		// well-tested.
100		{&tspb.Timestamp{Seconds: 0, Nanos: 0}, "1970-01-01T00:00:00Z"},
101	} {
102		got := TimestampString(test.ts)
103		if got != test.want {
104			t.Errorf("TimestampString(%v) = %q, want %q", test.ts, got, test.want)
105		}
106	}
107}
108
109func utcDate(year, month, day int) time.Time {
110	return time.Date(year, time.Month(month), day, 0, 0, 0, 0, time.UTC)
111}
112
113func TestTimestampNow(t *testing.T) {
114	// Bracket the expected time.
115	before := time.Now()
116	ts := TimestampNow()
117	after := time.Now()
118
119	tm, err := Timestamp(ts)
120	if err != nil {
121		t.Errorf("between %v and %v\nTimestampNow() = %v\nwhich is invalid (%v)", before, after, ts, err)
122	}
123	if tm.Before(before) || tm.After(after) {
124		t.Errorf("between %v and %v\nTimestamp(TimestampNow()) = %v", before, after, tm)
125	}
126}
127