1
2
3
4
5 package uuid
6
7 import (
8 "bytes"
9 "encoding/json"
10 "testing"
11 )
12
13 func TestNullUUIDScan(t *testing.T) {
14 var u UUID
15 var nu NullUUID
16
17 uNilErr := u.Scan(nil)
18 nuNilErr := nu.Scan(nil)
19 if uNilErr != nil &&
20 nuNilErr != nil &&
21 uNilErr.Error() != nuNilErr.Error() {
22 t.Errorf("expected errors to be equal, got %s, %s", uNilErr, nuNilErr)
23 }
24
25 uInvalidStringErr := u.Scan("test")
26 nuInvalidStringErr := nu.Scan("test")
27 if uInvalidStringErr != nil &&
28 nuInvalidStringErr != nil &&
29 uInvalidStringErr.Error() != nuInvalidStringErr.Error() {
30 t.Errorf("expected errors to be equal, got %s, %s", uInvalidStringErr, nuInvalidStringErr)
31 }
32
33 valid := "12345678-abcd-1234-abcd-0123456789ab"
34 uValidErr := u.Scan(valid)
35 nuValidErr := nu.Scan(valid)
36 if uValidErr != nuValidErr {
37 t.Errorf("expected errors to be equal, got %s, %s", uValidErr, nuValidErr)
38 }
39 }
40
41 func TestNullUUIDValue(t *testing.T) {
42 var u UUID
43 var nu NullUUID
44
45 nuValue, nuErr := nu.Value()
46 if nuErr != nil {
47 t.Errorf("expected nil err, got err %s", nuErr)
48 }
49 if nuValue != nil {
50 t.Errorf("expected nil value, got non-nil %s", nuValue)
51 }
52
53 u = MustParse("12345678-abcd-1234-abcd-0123456789ab")
54 nu = NullUUID{
55 UUID: MustParse("12345678-abcd-1234-abcd-0123456789ab"),
56 Valid: true,
57 }
58
59 uValue, uErr := u.Value()
60 nuValue, nuErr = nu.Value()
61 if uErr != nil {
62 t.Errorf("expected nil err, got err %s", uErr)
63 }
64 if nuErr != nil {
65 t.Errorf("expected nil err, got err %s", nuErr)
66 }
67 if uValue != nuValue {
68 t.Errorf("expected uuid %s and nulluuid %s to be equal ", uValue, nuValue)
69 }
70 }
71
72 func TestNullUUIDMarshalText(t *testing.T) {
73 tests := []struct {
74 nullUUID NullUUID
75 }{
76 {
77 nullUUID: NullUUID{},
78 },
79 {
80 nullUUID: NullUUID{
81 UUID: MustParse("12345678-abcd-1234-abcd-0123456789ab"),
82 Valid: true,
83 },
84 },
85 }
86 for _, test := range tests {
87 var uText []byte
88 var uErr error
89 nuText, nuErr := test.nullUUID.MarshalText()
90 if test.nullUUID.Valid {
91 uText, uErr = test.nullUUID.UUID.MarshalText()
92 } else {
93 uText = []byte("null")
94 }
95 if nuErr != uErr {
96 t.Errorf("expected error %e, got %e", nuErr, uErr)
97 }
98 if !bytes.Equal(nuText, uText) {
99 t.Errorf("expected text data %s, got %s", string(nuText), string(uText))
100 }
101 }
102 }
103
104 func TestNullUUIDUnmarshalText(t *testing.T) {
105 tests := []struct {
106 nullUUID NullUUID
107 }{
108 {
109 nullUUID: NullUUID{},
110 },
111 {
112 nullUUID: NullUUID{
113 UUID: MustParse("12345678-abcd-1234-abcd-0123456789ab"),
114 Valid: true,
115 },
116 },
117 }
118 for _, test := range tests {
119 var uText []byte
120 var uErr error
121 nuText, nuErr := test.nullUUID.MarshalText()
122 if test.nullUUID.Valid {
123 uText, uErr = test.nullUUID.UUID.MarshalText()
124 } else {
125 uText = []byte("null")
126 }
127 if nuErr != uErr {
128 t.Errorf("expected error %e, got %e", nuErr, uErr)
129 }
130 if !bytes.Equal(nuText, uText) {
131 t.Errorf("expected text data %s, got %s", string(nuText), string(uText))
132 }
133 }
134 }
135
136 func TestNullUUIDMarshalBinary(t *testing.T) {
137 tests := []struct {
138 nullUUID NullUUID
139 }{
140 {
141 nullUUID: NullUUID{},
142 },
143 {
144 nullUUID: NullUUID{
145 UUID: MustParse("12345678-abcd-1234-abcd-0123456789ab"),
146 Valid: true,
147 },
148 },
149 }
150 for _, test := range tests {
151 var uBinary []byte
152 var uErr error
153 nuBinary, nuErr := test.nullUUID.MarshalBinary()
154 if test.nullUUID.Valid {
155 uBinary, uErr = test.nullUUID.UUID.MarshalBinary()
156 } else {
157 uBinary = []byte(nil)
158 }
159 if nuErr != uErr {
160 t.Errorf("expected error %e, got %e", nuErr, uErr)
161 }
162 if !bytes.Equal(nuBinary, uBinary) {
163 t.Errorf("expected binary data %s, got %s", string(nuBinary), string(uBinary))
164 }
165 }
166 }
167
168 func TestNullUUIDMarshalJSON(t *testing.T) {
169 jsonNull, _ := json.Marshal(nil)
170 jsonUUID, _ := json.Marshal(MustParse("12345678-abcd-1234-abcd-0123456789ab"))
171 tests := []struct {
172 nullUUID NullUUID
173 expected []byte
174 expectedErr error
175 }{
176 {
177 nullUUID: NullUUID{},
178 expected: jsonNull,
179 expectedErr: nil,
180 },
181 {
182 nullUUID: NullUUID{
183 UUID: MustParse(string(jsonUUID)),
184 Valid: true,
185 },
186 expected: []byte(`"12345678-abcd-1234-abcd-0123456789ab"`),
187 expectedErr: nil,
188 },
189 }
190 for _, test := range tests {
191 data, err := json.Marshal(&test.nullUUID)
192 if err != test.expectedErr {
193 t.Errorf("expected error %e, got %e", test.expectedErr, err)
194 }
195 if !bytes.Equal(data, test.expected) {
196 t.Errorf("expected json data %s, got %s", string(test.expected), string(data))
197 }
198 }
199 }
200
201 func TestNullUUIDUnmarshalJSON(t *testing.T) {
202 jsonNull, _ := json.Marshal(nil)
203 jsonUUID, _ := json.Marshal(MustParse("12345678-abcd-1234-abcd-0123456789ab"))
204
205 var nu NullUUID
206 err := json.Unmarshal(jsonNull, &nu)
207 if err != nil || nu.Valid {
208 t.Errorf("expected nil when unmarshaling null, got %s", err)
209 }
210 err = json.Unmarshal(jsonUUID, &nu)
211 if err != nil || !nu.Valid {
212 t.Errorf("expected nil when unmarshaling null, got %s", err)
213 }
214 }
215
View as plain text