Debian Codegraph @

parsers/yaml/yaml_test.go

raw
1 package yaml
2
3 import (
4 "testing"
5
6 "github.com/stretchr/testify/assert"
7 )
8
9 func TestYAML_Unmarshal(t *testing.T) {
10
11 testCases := []struct {
12 name string
13 input []byte
14 keys []string
15 values []any
16 isErr bool
17 }{
18 {
19 name: "Empty YAML",
20 input: []byte(`{}`),
21 },
22 {
23 name: "Valid YAML",
24 input: []byte(`key: val
25 name: test
26 number: 2`),
27 keys: []string{"key", "name", "number"},
28 values: []any{"val", "test", 2},
29 },
30 {
31 name: "Invalid YAML - wrong indentation",
32 input: []byte(`key: val
33 name: test
34 number: 2`),
35 isErr: true,
36 },
37 {
38 name: "Complex YAML - All types",
39 input: []byte(`---
40 array:
41 - 1
42 - 2
43 - 3
44 boolean: true
45 color: gold
46 'null':
47 number: 123
48 object:
49 a: b
50 c: d
51 string: Hello World`),
52 keys: []string{"array", "boolean", "color", "null", "number", "object", "string"},
53 values: []any{[]any{1, 2, 3},
54 true,
55 "gold",
56 nil,
57 123,
58 map[string]any{"a": "b", "c": "d"},
59 "Hello World"},
60 },
61 {
62 name: "Valid YAML - With comments",
63 input: []byte(`---
64 key: #Here is a single-line comment
65 - value line 5
66 #Here is a
67 #multi-line comment
68 - value line 13`),
69 keys: []string{"key"},
70 values: []any{[]any{"value line 5", "value line 13"}},
71 },
72 }
73
74 y := Parser()
75
76 for _, tc := range testCases {
77 t.Run(tc.name, func(t *testing.T) {
78 out, err := y.Unmarshal(tc.input)
79 if tc.isErr {
80 assert.NotNil(t, err)
81 } else {
82 assert.Nil(t, err)
83 for i, k := range tc.keys {
84 v := out[k]
85 assert.Equal(t, tc.values[i], v)
86 }
87 }
88 })
89 }
90 }
91
92 func TestYAML_Marshal(t *testing.T) {
93 testCases := []struct {
94 name string
95 input map[string]any
96 output []byte
97 isErr bool
98 }{
99 {
100 name: "Empty YAML",
101 input: map[string]any{},
102 output: []byte(`{}
103 `),
104 },
105 {
106 name: "Valid YAML",
107 input: map[string]any{
108 "key": "val",
109 "name": "test",
110 "number": 2,
111 },
112 output: []byte(`key: val
113 name: test
114 number: 2
115 `),
116 },
117 {
118 name: "Complex YAML - All types",
119 input: map[string]any{
120 "array": []any{1, 2, 3, 4, 5},
121 "boolean": true,
122 "color": "gold",
123 "null": nil,
124 "number": 123,
125 "object": map[string]any{"a": "b", "c": "d"},
126 "string": "Hello World",
127 },
128 output: []byte(`array:
129 - 1
130 - 2
131 - 3
132 - 4
133 - 5
134 boolean: true
135 color: gold
136 "null": null
137 number: 123
138 object:
139 a: b
140 c: d
141 string: Hello World
142 `),
143 },
144 }
145
146 y := Parser()
147
148 for _, tc := range testCases {
149 t.Run(tc.name, func(t *testing.T) {
150 out, err := y.Marshal(tc.input)
151 if tc.isErr {
152 assert.NotNil(t, err)
153 } else {
154 assert.Nil(t, err)
155 assert.Equal(t, tc.output, out)
156 }
157 })
158 }
159 }