Skip to content

Commit ae25fc6

Browse files
sejrsejr
authored
feat(uuid): Added support for NullUUID (#76)
1 parent 655bf50 commit ae25fc6

File tree

2 files changed

+358
-0
lines changed

2 files changed

+358
-0
lines changed

‎null.go

+120
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,120 @@
1+
// Copyright 2021 Google Inc. 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+
5+
package uuid
6+
7+
import (
8+
"bytes"
9+
"database/sql/driver"
10+
"encoding/json"
11+
"fmt"
12+
)
13+
14+
// NullUUID represents a UUID that may be null.
15+
// NullUUID implements the Scanner interface so
16+
// it can be used as a scan destination:
17+
//
18+
// var u uuid.NullUUID
19+
// err := db.QueryRow("SELECT name FROM foo WHERE id=?", id).Scan(&u)
20+
// ...
21+
// if u.Valid {
22+
// // use u.UUID
23+
// } else {
24+
// // NULL value
25+
// }
26+
//
27+
type NullUUID struct {
28+
UUID UUID
29+
Valid bool // Valid is true if UUID is not NULL
30+
}
31+
32+
// Scan implements the Scanner interface.
33+
func (nu *NullUUID) Scan(value interface{}) error {
34+
if value == nil {
35+
nu.UUID, nu.Valid = Nil, false
36+
return nil
37+
}
38+
39+
err := nu.UUID.Scan(value)
40+
if err != nil {
41+
nu.Valid = false
42+
return err
43+
}
44+
45+
nu.Valid = true
46+
return nil
47+
}
48+
49+
// Value implements the driver Valuer interface.
50+
func (nu NullUUID) Value() (driver.Value, error) {
51+
if !nu.Valid {
52+
return nil, nil
53+
}
54+
// Delegate to UUID Value function
55+
return nu.UUID.Value()
56+
}
57+
58+
// MarshalBinary implements encoding.BinaryMarshaler.
59+
func (nu NullUUID) MarshalBinary() ([]byte, error) {
60+
if nu.Valid {
61+
return nu.UUID[:], nil
62+
}
63+
64+
return []byte(nil), nil
65+
}
66+
67+
// UnmarshalBinary implements encoding.BinaryUnmarshaler.
68+
func (nu *NullUUID) UnmarshalBinary(data []byte) error {
69+
if len(data) != 16 {
70+
return fmt.Errorf("invalid UUID (got %d bytes)", len(data))
71+
}
72+
copy(nu.UUID[:], data)
73+
nu.Valid = true
74+
return nil
75+
}
76+
77+
// MarshalText implements encoding.TextMarshaler.
78+
func (nu NullUUID) MarshalText() ([]byte, error) {
79+
if nu.Valid {
80+
return nu.UUID.MarshalText()
81+
}
82+
83+
return []byte{110, 117, 108, 108}, nil
84+
}
85+
86+
// UnmarshalText implements encoding.TextUnmarshaler.
87+
func (nu *NullUUID) UnmarshalText(data []byte) error {
88+
id, err := ParseBytes(data)
89+
if err != nil {
90+
nu.Valid = false
91+
return err
92+
}
93+
nu.UUID = id
94+
nu.Valid = true
95+
return nil
96+
}
97+
98+
// MarshalJSON implements json.Marshaler.
99+
func (nu NullUUID) MarshalJSON() ([]byte, error) {
100+
if nu.Valid {
101+
return json.Marshal(nu.UUID)
102+
}
103+
104+
return json.Marshal(nil)
105+
}
106+
107+
// UnmarshalJSON implements json.Unmarshaler.
108+
func (nu *NullUUID) UnmarshalJSON(data []byte) error {
109+
null := []byte{110, 117, 108, 108}
110+
if bytes.Equal(data, null) {
111+
return nil // valid null UUID
112+
}
113+
114+
var u UUID
115+
// tossing as we know u is valid
116+
_ = json.Unmarshal(data, &u)
117+
nu.Valid = true
118+
nu.UUID = u
119+
return nil
120+
}

‎null_test.go

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

0 commit comments

Comments
 (0)