convenience_test.go
1package ygo_test
2
3import (
4 "testing"
5
6 "git.kilimanjaro.io/ygo"
7)
8
9func TestMapGetString(t *testing.T) {
10 doc, err := ygo.NewDoc()
11 if err != nil {
12 t.Fatalf("failed to create doc: %v", err)
13 }
14 defer doc.Destroy()
15
16 m, err := doc.GetMap("test")
17 if err != nil {
18 t.Fatalf("failed to get map: %v", err)
19 }
20 defer m.Destroy()
21
22 // Insert test data
23 err = doc.WithWriteTransaction(func(txn *ygo.Transaction) error {
24 m.Insert(txn, "name", ygo.String("Alice"))
25 return nil
26 })
27 if err != nil {
28 t.Fatalf("transaction failed: %v", err)
29 }
30
31 // Test GetString
32 var name string
33 err = doc.WithReadTransaction(func(txn *ygo.Transaction) error {
34 var err error
35 name, err = m.GetString(txn, "name")
36 return err
37 })
38 if err != nil {
39 t.Fatalf("GetString failed: %v", err)
40 }
41 if name != "Alice" {
42 t.Errorf("expected Alice, got %s", name)
43 }
44}
45
46func TestMapGetInt(t *testing.T) {
47 doc, err := ygo.NewDoc()
48 if err != nil {
49 t.Fatalf("failed to create doc: %v", err)
50 }
51 defer doc.Destroy()
52
53 m, err := doc.GetMap("test")
54 if err != nil {
55 t.Fatalf("failed to get map: %v", err)
56 }
57 defer m.Destroy()
58
59 // Insert test data
60 err = doc.WithWriteTransaction(func(txn *ygo.Transaction) error {
61 m.Insert(txn, "age", ygo.Int(30))
62 return nil
63 })
64 if err != nil {
65 t.Fatalf("transaction failed: %v", err)
66 }
67
68 // Test GetInt
69 var age int64
70 err = doc.WithReadTransaction(func(txn *ygo.Transaction) error {
71 var err error
72 age, err = m.GetInt(txn, "age")
73 return err
74 })
75 if err != nil {
76 t.Fatalf("GetInt failed: %v", err)
77 }
78 if age != 30 {
79 t.Errorf("expected 30, got %d", age)
80 }
81}
82
83func TestMapGetFloat(t *testing.T) {
84 doc, err := ygo.NewDoc()
85 if err != nil {
86 t.Fatalf("failed to create doc: %v", err)
87 }
88 defer doc.Destroy()
89
90 m, err := doc.GetMap("test")
91 if err != nil {
92 t.Fatalf("failed to get map: %v", err)
93 }
94 defer m.Destroy()
95
96 // Insert test data
97 err = doc.WithWriteTransaction(func(txn *ygo.Transaction) error {
98 m.Insert(txn, "pi", ygo.Float(3.14))
99 return nil
100 })
101 if err != nil {
102 t.Fatalf("transaction failed: %v", err)
103 }
104
105 // Test GetFloat
106 var pi float64
107 err = doc.WithReadTransaction(func(txn *ygo.Transaction) error {
108 var err error
109 pi, err = m.GetFloat(txn, "pi")
110 return err
111 })
112 if err != nil {
113 t.Fatalf("GetFloat failed: %v", err)
114 }
115 if pi != 3.14 {
116 t.Errorf("expected 3.14, got %f", pi)
117 }
118}
119
120func TestMapGetBool(t *testing.T) {
121 doc, err := ygo.NewDoc()
122 if err != nil {
123 t.Fatalf("failed to create doc: %v", err)
124 }
125 defer doc.Destroy()
126
127 m, err := doc.GetMap("test")
128 if err != nil {
129 t.Fatalf("failed to get map: %v", err)
130 }
131 defer m.Destroy()
132
133 // Insert test data
134 err = doc.WithWriteTransaction(func(txn *ygo.Transaction) error {
135 m.Insert(txn, "active", ygo.Bool(true))
136 return nil
137 })
138 if err != nil {
139 t.Fatalf("transaction failed: %v", err)
140 }
141
142 // Test GetBool
143 var active bool
144 err = doc.WithReadTransaction(func(txn *ygo.Transaction) error {
145 var err error
146 active, err = m.GetBool(txn, "active")
147 return err
148 })
149 if err != nil {
150 t.Fatalf("GetBool failed: %v", err)
151 }
152 if !active {
153 t.Errorf("expected true, got %v", active)
154 }
155}
156
157func TestMapForEach(t *testing.T) {
158 doc, err := ygo.NewDoc()
159 if err != nil {
160 t.Fatalf("failed to create doc: %v", err)
161 }
162 defer doc.Destroy()
163
164 m, err := doc.GetMap("test")
165 if err != nil {
166 t.Fatalf("failed to get map: %v", err)
167 }
168 defer m.Destroy()
169
170 // Insert test data
171 err = doc.WithWriteTransaction(func(txn *ygo.Transaction) error {
172 m.Insert(txn, "a", ygo.String("1"))
173 m.Insert(txn, "b", ygo.String("2"))
174 m.Insert(txn, "c", ygo.String("3"))
175 return nil
176 })
177 if err != nil {
178 t.Fatalf("transaction failed: %v", err)
179 }
180
181 // Test ForEach
182 var count int
183 err = doc.WithReadTransaction(func(txn *ygo.Transaction) error {
184 return m.ForEach(txn, func(key string, value *ygo.Output) error {
185 count++
186 return nil
187 })
188 })
189 if err != nil {
190 t.Fatalf("ForEach failed: %v", err)
191 }
192 if count != 3 {
193 t.Errorf("expected 3 entries, got %d", count)
194 }
195}
196
197func TestMapForEachEarlyExit(t *testing.T) {
198 doc, err := ygo.NewDoc()
199 if err != nil {
200 t.Fatalf("failed to create doc: %v", err)
201 }
202 defer doc.Destroy()
203
204 m, err := doc.GetMap("test")
205 if err != nil {
206 t.Fatalf("failed to get map: %v", err)
207 }
208 defer m.Destroy()
209
210 // Insert test data
211 err = doc.WithWriteTransaction(func(txn *ygo.Transaction) error {
212 m.Insert(txn, "a", ygo.String("1"))
213 m.Insert(txn, "b", ygo.String("2"))
214 m.Insert(txn, "c", ygo.String("3"))
215 return nil
216 })
217 if err != nil {
218 t.Fatalf("transaction failed: %v", err)
219 }
220
221 // Test ForEach with early exit
222 var count int
223 testErr := ygo.ErrKeyNotFound // Just use any error for testing
224 err = doc.WithReadTransaction(func(txn *ygo.Transaction) error {
225 return m.ForEach(txn, func(key string, value *ygo.Output) error {
226 count++
227 if count >= 2 {
228 return testErr
229 }
230 return nil
231 })
232 })
233 if err != testErr {
234 t.Fatalf("expected ForEach to return test error, got: %v", err)
235 }
236 if count != 2 {
237 t.Errorf("expected iteration to stop at 2, got %d", count)
238 }
239}
240
241func TestArrayForEach(t *testing.T) {
242 doc, err := ygo.NewDoc()
243 if err != nil {
244 t.Fatalf("failed to create doc: %v", err)
245 }
246 defer doc.Destroy()
247
248 arr, err := doc.GetArray("test")
249 if err != nil {
250 t.Fatalf("failed to get array: %v", err)
251 }
252 defer arr.Destroy()
253
254 // Insert test data
255 err = doc.WithWriteTransaction(func(txn *ygo.Transaction) error {
256 arr.Push(txn, ygo.Int(10))
257 arr.Push(txn, ygo.Int(20))
258 arr.Push(txn, ygo.Int(30))
259 return nil
260 })
261 if err != nil {
262 t.Fatalf("transaction failed: %v", err)
263 }
264
265 // Test ForEach
266 var sum int64
267 err = doc.WithReadTransaction(func(txn *ygo.Transaction) error {
268 return arr.ForEach(txn, func(index uint32, value *ygo.Output) error {
269 if v, ok := value.Int(); ok {
270 sum += v
271 }
272 return nil
273 })
274 })
275 if err != nil {
276 t.Fatalf("ForEach failed: %v", err)
277 }
278 if sum != 60 {
279 t.Errorf("expected sum 60, got %d", sum)
280 }
281}
282
283func TestMapInput(t *testing.T) {
284 // Test MapInput with data
285 data := map[string]ygo.Input{
286 "name": ygo.String("Alice"),
287 "age": ygo.Int(30),
288 }
289 input, err := ygo.MapInput(data)
290 if err != nil {
291 t.Fatalf("MapInput failed: %v", err)
292 }
293
294 doc, err := ygo.NewDoc()
295 if err != nil {
296 t.Fatalf("failed to create doc: %v", err)
297 }
298 defer doc.Destroy()
299
300 m, err := doc.GetMap("test")
301 if err != nil {
302 t.Fatalf("failed to get map: %v", err)
303 }
304 defer m.Destroy()
305
306 // Insert the map input
307 err = doc.WithWriteTransaction(func(txn *ygo.Transaction) error {
308 return m.Insert(txn, "data", input)
309 })
310 if err != nil {
311 t.Fatalf("transaction failed: %v", err)
312 }
313
314 // Verify we can read it back
315 var name string
316 err = doc.WithReadTransaction(func(txn *ygo.Transaction) error {
317 dataMap, err := m.GetNestedMap(txn, "data")
318 if err != nil {
319 return err
320 }
321 defer dataMap.Destroy()
322 name, err = dataMap.GetString(txn, "name")
323 return err
324 })
325 if err != nil {
326 t.Fatalf("GetNestedMap failed: %v", err)
327 }
328 if name != "Alice" {
329 t.Errorf("expected Alice, got %s", name)
330 }
331}
332
333func TestJSONObject(t *testing.T) {
334 // Test JSONObject with data
335 data := map[string]ygo.Input{
336 "name": ygo.String("Bob"),
337 "age": ygo.Int(25),
338 }
339 input, err := ygo.JSONObject(data)
340 if err != nil {
341 t.Fatalf("JSONObject failed: %v", err)
342 }
343
344 doc, err := ygo.NewDoc()
345 if err != nil {
346 t.Fatalf("failed to create doc: %v", err)
347 }
348 defer doc.Destroy()
349
350 m, err := doc.GetMap("test")
351 if err != nil {
352 t.Fatalf("failed to get map: %v", err)
353 }
354 defer m.Destroy()
355
356 // Insert the JSON object input
357 err = doc.WithWriteTransaction(func(txn *ygo.Transaction) error {
358 return m.Insert(txn, "data", input)
359 })
360 if err != nil {
361 t.Fatalf("transaction failed: %v", err)
362 }
363
364 // Verify we can read it back as a JSON map
365 err = doc.WithReadTransaction(func(txn *ygo.Transaction) error {
366 out, err := m.Get(txn, "data")
367 if err != nil {
368 return err
369 }
370 defer out.Destroy()
371
372 if out.Tag() != ygo.TagJSONMap {
373 t.Errorf("expected TagJSONMap, got %v", out.Tag())
374 }
375 return nil
376 })
377 if err != nil {
378 t.Fatalf("Get failed: %v", err)
379 }
380}
