1 package ldvalue
2
3 import (
4 "encoding/json"
5 "fmt"
6 "testing"
7
8 "github.com/launchdarkly/go-jsonstream/v3/jreader"
9 "github.com/launchdarkly/go-jsonstream/v3/jwriter"
10
11 "github.com/stretchr/testify/assert"
12 )
13
14 func TestValueJSONMarshalUnmarshal(t *testing.T) {
15 items := []struct {
16 value Value
17 json string
18 }{
19 {Null(), nullAsJSON},
20 {Bool(true), "true"},
21 {Bool(false), "false"},
22 {Int(1), "1"},
23 {Float64(1), "1"},
24 {Float64(2.5), "2.5"},
25 {String("x"), `"x"`},
26 {ArrayOf(), `[]`},
27 {ArrayBuild().Add(Bool(true)).Add(String("x")).Build(), `[true,"x"]`},
28 {ObjectBuild().Build(), `{}`},
29 {ObjectBuild().Set("a", Bool(true)).Build(), `{"a":true}`},
30 }
31 for _, item := range items {
32 t.Run(fmt.Sprintf("type %s, json %v", item.value.Type(), item.json), func(t *testing.T) {
33 j, err := json.Marshal(item.value)
34 assert.NoError(t, err)
35 assert.Equal(t, item.json, string(j))
36
37 assert.Equal(t, item.json, item.value.JSONString())
38 assert.Equal(t, json.RawMessage(item.json), item.value.AsRaw())
39
40 var v Value
41 err = json.Unmarshal([]byte(item.json), &v)
42 assert.NoError(t, err)
43 assert.Equal(t, item.value, v)
44
45 assert.Equal(t, item.value, Parse([]byte(item.json)))
46
47 r := jreader.NewReader([]byte(item.json))
48 var v1 Value
49 v1.ReadFromJSONReader(&r)
50 assert.NoError(t, r.Error())
51 assert.Equal(t, item.value, v1)
52
53 w := jwriter.NewWriter()
54 item.value.WriteToJSONWriter(&w)
55 bytes := w.Bytes()
56 assert.NoError(t, w.Error())
57 assert.Equal(t, item.json, string(bytes))
58 })
59 }
60 }
61
62 func TestMarshalRaw(t *testing.T) {
63
64 for _, params := range []struct {
65 desc string
66 input json.RawMessage
67 output string
68 }{
69 {"valid JSON", json.RawMessage(`{"a":1}`), `{"a":1}`},
70 {"zero-length", json.RawMessage{}, `null`},
71 {"nil", json.RawMessage(nil), `null`},
72 } {
73 t.Run(params.desc, func(t *testing.T) {
74 value := Raw(params.input)
75
76 bytes, err := json.Marshal(value)
77 assert.NoError(t, err)
78 assert.Equal(t, params.output, string(bytes))
79
80 w := jwriter.NewWriter()
81 value.WriteToJSONWriter(&w)
82 assert.NoError(t, w.Error())
83 assert.Equal(t, params.output, string(w.Bytes()))
84 })
85 }
86 }
87
88 func TestValueUnmarshalErrorConditions(t *testing.T) {
89 var v Value
90 for _, data := range [][]byte{
91 nil,
92 {},
93 []byte("what"),
94 []byte("["),
95 []byte("[what"),
96 []byte("{"),
97 []byte("{what"),
98 []byte(`{"no":what`),
99 []byte(`1,`),
100 } {
101 assert.Error(t, json.Unmarshal(data, &v))
102 assert.Equal(t, Null(), Parse(data))
103 }
104 }
105
106 func TestValueArrayJSONMarshalUnmarshal(t *testing.T) {
107 items := []struct {
108 valueArray ValueArray
109 json string
110 }{
111 {ValueArray{}, nullAsJSON},
112 {ValueArrayBuild().Build(), `[]`},
113 {ValueArrayOf(String("a"), String("b")), `["a","b"]`},
114 }
115 for _, item := range items {
116 t.Run(fmt.Sprintf("json %v", item.json), func(t *testing.T) {
117 j, err := json.Marshal(item.valueArray)
118 assert.NoError(t, err)
119 assert.Equal(t, item.json, string(j))
120
121 assert.Equal(t, item.json, item.valueArray.JSONString())
122
123 var a ValueArray
124 err = json.Unmarshal([]byte(item.json), &a)
125 assert.NoError(t, err)
126 assert.Equal(t, item.valueArray, a)
127
128 r := jreader.NewReader([]byte(item.json))
129 a = ValueArray{}
130 a.ReadFromJSONReader(&r)
131 assert.NoError(t, r.Error())
132 assert.Equal(t, item.valueArray, a)
133
134 w := jwriter.NewWriter()
135 item.valueArray.WriteToJSONWriter(&w)
136 assert.NoError(t, w.Error())
137 assert.Equal(t, item.json, string(w.Bytes()))
138 })
139 }
140
141 for _, badJSON := range []string{"true", "1", `"x"`, "{}"} {
142 err := json.Unmarshal([]byte(badJSON), &ValueArray{})
143 assert.Error(t, err)
144 assert.IsType(t, &json.UnmarshalTypeError{}, err)
145 }
146 }
147
148 func TestValueMapJSONMarshalUnmarshal(t *testing.T) {
149 items := []struct {
150 valueMap ValueMap
151 json string
152 }{
153 {ValueMap{}, nullAsJSON},
154 {ValueMapBuild().Build(), `{}`},
155 {ValueMapBuild().Set("a", Bool(true)).Build(), `{"a":true}`},
156 }
157 for _, item := range items {
158 t.Run(fmt.Sprintf("json %v", item.json), func(t *testing.T) {
159 j, err := json.Marshal(item.valueMap)
160 assert.NoError(t, err)
161 assert.Equal(t, item.json, string(j))
162
163 assert.Equal(t, item.json, item.valueMap.JSONString())
164
165 var m ValueMap
166 err = json.Unmarshal([]byte(item.json), &m)
167 assert.NoError(t, err)
168 assert.Equal(t, item.valueMap, m)
169
170 r := jreader.NewReader([]byte(item.json))
171 m = ValueMap{}
172 m.ReadFromJSONReader(&r)
173 assert.NoError(t, r.Error())
174 assert.Equal(t, item.valueMap, m)
175
176 w := jwriter.NewWriter()
177 item.valueMap.WriteToJSONWriter(&w)
178 assert.NoError(t, w.Error())
179 assert.Equal(t, item.json, string(w.Bytes()))
180 })
181 }
182
183 for _, badJSON := range []string{"true", "1", `"x"`, "[]"} {
184 err := json.Unmarshal([]byte(badJSON), &ValueMap{})
185 assert.Error(t, err)
186 assert.IsType(t, &json.UnmarshalTypeError{}, err)
187 }
188 }
189
View as plain text