zoom/time_test.go at main · fabiustech/zoom · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
package zoom

import (
	"bytes"
	"encoding/json"
	"testing"
	"time"
)

func TestNullTimePointer(t *testing.T) {
	type structure struct {
		Time *Time `json:"time"`
	}
	var (
		js       = []byte(`{ "time": null }`)
		parsed   = structure{}
		expected *Time
	)

	if err := json.Unmarshal(js, &parsed); err != nil {
		t.Error(err)
	}

	actual := parsed.Time

	if actual != expected {
		t.Errorf("expected %v, got %v", expected, actual)
	}
}

func TestNullTime(t *testing.T) {
	type structure struct {
		Time Time `json:"time"`
	}
	var (
		js       = []byte(`{ "time": null }`)
		parsed   = structure{}
		expected = time.Time{}
	)

	if err := json.Unmarshal(js, &parsed); err != nil {
		t.Error(err)
	}

	actual := parsed.Time.Time

	if actual != expected {
		t.Errorf("expected %v, got %v", expected, actual)
	}
}

func TestEmptyStringTime(t *testing.T) {
	type structure struct {
		Time Time `json:"time"`
	}
	var (
		js       = []byte(`{ "time": "" }`)
		parsed   = structure{}
		expected = time.Time{}
	)

	if err := json.Unmarshal(js, &parsed); err != nil {
		t.Error(err)
	}

	actual := parsed.Time.Time

	if actual != expected {
		t.Errorf("expected %v, got %v", expected, actual)
	}
}

func TestInvalidTime(t *testing.T) {
	type structure struct {
		Time Time `json:"time"`
	}
	var (
		js     = []byte(`{ "time": "bogus" }`)
		parsed = structure{}
	)

	if err := json.Unmarshal(js, &parsed); err == nil {
		t.Error("expected error parsing bogus time, got nil")
	}
}

func TestValidTime(t *testing.T) {
	type structure struct {
		Time Time `json:"time"`
	}
	var (
		js       = []byte(`{ "time": "` + nowStr + `" }`)
		parsed   = structure{}
		expected = now.Time
	)

	if err := json.Unmarshal(js, &parsed); err != nil {
		t.Error(err)
	}

	actual := parsed.Time.Time

	if !actual.Equal(expected) {
		t.Errorf("expected %+v, got %+v", expected, actual)
	}
}

func TestTimeToString(t *testing.T) {
	type structure struct {
		Time Time `json:"time"`
	}
	var (
		struc    = structure{Time{now.Time}}
		expected = []byte(`{"time":"` + nowStr + `"}`)
	)

	actual, err := json.Marshal(struc)
	if err != nil {
		t.Errorf("got err marshaling json: %s\n", err)
	}

	if bytes.Compare(actual, expected) != 0 {
		t.Errorf("expected %s, got %s", string(expected), string(actual))
	}
}