Debian Codegraph @

parsers/kdl/kdl_test.go

raw
1 package kdl
2
3 import (
4 "sort"
5 "strings"
6 "testing"
7
8 "github.com/stretchr/testify/assert"
9 )
10
11 func TestKDL_Unmarshal(t *testing.T) {
12 testCases := []struct {
13 name string
14 input []byte
15 keys []string
16 values []any
17 isErr bool
18 }{
19 {
20 name: "Empty KDL",
21 input: []byte(``),
22 },
23 {
24 name: "Valid KDL",
25 input: []byte(`key "val" ; name "test" ; number 2.0`),
26 keys: []string{"key", "name", "number"},
27 values: []any{"val", "test", 2.0},
28 },
29 {
30 name: "Invalid KDL - syntax error",
31 input: []byte(`node1 key="val`),
32 isErr: true,
33 },
34 {
35 name: "Complex KDL - Different types",
36 input: []byte(`
37 array 1.0 2.0 3.0
38 boolean true
39 color "gold"
40 "null" null
41 number 123
42 object a="b" c="d" e=2.7 f=true
43 string "Hello World"
44 `),
45 keys: []string{"array", "boolean", "color", "null", "number", "object", "string"},
46 values: []any{[]any{1.0, 2.0, 3.0},
47 true,
48 "gold",
49 nil,
50 int64(123),
51 map[string]any{"a": "b", "c": "d", "e": 2.7, "f": true},
52 "Hello World"},
53 },
54 {
55 name: "Invalid KDL - missing value",
56 input: []byte(`node1 boolean=`),
57 isErr: true,
58 },
59 {
60 name: "Complex KDL - Nested map",
61 input: []byte(`key "value"
62 "1" "skipped"
63 map key="skipped" key="value"
64 nested_map {
65 map key="value" 17 {
66 list "item1" "item2" "item3"
67 mixup "y"=1 2 3 4
68 first "first"=1 2 3 4
69 child "test"=1 2 3 4 { "y" 5 ; "d" 6 ; }
70 }
71 }
72 `),
73 keys: []string{"key", "1", "map", "nested_map"},
74 values: []any{
75 "value",
76 "skipped",
77 map[string]any{
78 "key": "value",
79 },
80 map[string]any{
81 "map": map[string]any{
82 "0": int64(17),
83 "key": "value",
84 "list": []any{
85 "item1",
86 "item2",
87 "item3",
88 },
89 "mixup": map[string]any{
90 "y": int64(1),
91 "0": int64(2),
92 "1": int64(3),
93 "2": int64(4),
94 },
95 "first": map[string]any{
96 "first": int64(1),
97 "0": int64(2),
98 "1": int64(3),
99 "2": int64(4),
100 },
101 "child": map[string]any{
102 "test": int64(1),
103 "0": int64(2),
104 "1": int64(3),
105 "2": int64(4),
106 "y": int64(5),
107 "d": int64(6),
108 },
109 },
110 },
111 },
112 },
113 }
114
115 k := Parser() // Assuming Parser() is implemented for KDL
116
117 for _, tc := range testCases {
118 t.Run(tc.name, func(t *testing.T) {
119 out, err := k.Unmarshal(tc.input)
120 if tc.isErr {
121 assert.NotNil(t, err)
122 } else {
123 assert.Nil(t, err)
124 for i, k := range tc.keys {
125 v := out[k]
126 assert.Equal(t, tc.values[i], v)
127 }
128 }
129 })
130 }
131 }
132
133 func TestKDL_Marshal(t *testing.T) {
134 testCases := []struct {
135 name string
136 input map[string]any
137 stringifiedOutput string
138 isErr bool
139 }{
140 {
141 name: "Empty KDL",
142 input: map[string]any{},
143 stringifiedOutput: ``,
144 },
145 {
146 name: "Valid KDL",
147 input: map[string]any{
148 "key": "val",
149 "name": "test",
150 "number": 2.0,
151 },
152 stringifiedOutput: `key "val"
153 name "test"
154 number 2.0
155 `,
156 },
157 {
158 name: "Complex KDL - Different types",
159 input: map[string]any{
160 "null": nil,
161 "boolean": true,
162 "color": "gold",
163 "number": int64(123),
164 "string": "Hello World",
165 // "array": []any{1, 2, 3, 4, 5}, // https://github.com/sblinch/kdl-go/issues/3
166 "object": map[string]any{"a": "b", "c": "d"},
167 },
168 stringifiedOutput: `boolean true
169 color "gold"
170 number 123
171 string "Hello World"
172 object a="b" c="d"
173 null null
174 `,
175 },
176 }
177
178 k := Parser() // Assuming Parser() is implemented for KDL
179
180 for _, tc := range testCases {
181 t.Run(tc.name, func(t *testing.T) {
182 out, err := k.Marshal(tc.input)
183 if tc.isErr {
184 assert.NotNil(t, err)
185 } else {
186 assert.Nil(t, err)
187 assert.Equal(t, sortLines(tc.stringifiedOutput), sortLines(string(out)))
188 }
189 })
190 }
191 }
192
193 // kdl marshal is not guaranteed to produce the same output every time
194 // so we sort the lines to compare the output.
195 func sortLines(s string) string {
196 lines := strings.Split(s, "\n")
197 sort.Strings(lines)
198 for i, l := range lines {
199 if strings.HasPrefix(l, "object") {
200 // object a="b" c="d" should be sorted to be able to compare and
201 // remove flakiness.
202 parts := strings.Split(l, " ")
203 sort.Strings(parts[1:])
204 lines[i] = strings.Join(parts, " ")
205 }
206 }
207 return strings.Join(lines, "\n")
208 }