1 package yamlmap
2
3 import (
4 "testing"
5
6 "github.com/stretchr/testify/assert"
7 )
8
9 func TestMapAddEntry(t *testing.T) {
10 tests := []struct {
11 name string
12 key string
13 value string
14 wantValue string
15 wantLength int
16 }{
17 {
18 name: "add entry with key that is not present",
19 key: "notPresent",
20 value: "test1",
21 wantValue: "test1",
22 wantLength: 10,
23 },
24 {
25 name: "add entry with key that is already present",
26 key: "erroneous",
27 value: "test2",
28 wantValue: "same",
29 wantLength: 10,
30 },
31 }
32
33 for _, tt := range tests {
34 m := testMap()
35 t.Run(tt.name, func(t *testing.T) {
36 m.AddEntry(tt.key, StringValue(tt.value))
37 entry, err := m.FindEntry(tt.key)
38 assert.NoError(t, err)
39 assert.Equal(t, tt.wantValue, entry.Value)
40 assert.Equal(t, tt.wantLength, len(m.Content))
41 assert.True(t, m.IsModified())
42 })
43 }
44 }
45
46 func TestMapEmpty(t *testing.T) {
47 m := blankMap()
48 assert.Equal(t, true, m.Empty())
49 m.AddEntry("test", StringValue("test"))
50 assert.Equal(t, false, m.Empty())
51 }
52
53 func TestMapFindEntry(t *testing.T) {
54 tests := []struct {
55 name string
56 key string
57 output string
58 wantErr bool
59 }{
60 {
61 name: "find key",
62 key: "valid",
63 output: "present",
64 },
65 {
66 name: "find key that is not present",
67 key: "invalid",
68 wantErr: true,
69 },
70 {
71 name: "find key with blank value",
72 key: "blank",
73 output: "",
74 },
75 {
76 name: "find key that has same content as a value",
77 key: "same",
78 output: "logical",
79 },
80 }
81
82 for _, tt := range tests {
83 m := testMap()
84 t.Run(tt.name, func(t *testing.T) {
85 out, err := m.FindEntry(tt.key)
86 if tt.wantErr {
87 assert.EqualError(t, err, "not found")
88 assert.False(t, m.IsModified())
89 return
90 }
91 assert.NoError(t, err)
92 assert.Equal(t, tt.output, out.Value)
93 assert.False(t, m.IsModified())
94 })
95 }
96 }
97
98 func TestMapFindEntryModified(t *testing.T) {
99 m := testMap()
100 entry, err := m.FindEntry("valid")
101 assert.NoError(t, err)
102 assert.Equal(t, "present", entry.Value)
103 entry.Value = "test"
104 assert.Equal(t, "test", entry.Value)
105 entry2, err := m.FindEntry("valid")
106 assert.NoError(t, err)
107 assert.Equal(t, "test", entry2.Value)
108 }
109
110 func TestMapKeys(t *testing.T) {
111 tests := []struct {
112 name string
113 m *Map
114 wantKeys []string
115 }{
116 {
117 name: "keys for full map",
118 m: testMap(),
119 wantKeys: []string{"valid", "erroneous", "blank", "same"},
120 },
121 {
122 name: "keys for empty map",
123 m: blankMap(),
124 wantKeys: []string{},
125 },
126 }
127 for _, tt := range tests {
128 t.Run(tt.name, func(t *testing.T) {
129 keys := tt.m.Keys()
130 assert.Equal(t, tt.wantKeys, keys)
131 assert.False(t, tt.m.IsModified())
132 })
133 }
134 }
135
136 func TestMapRemoveEntry(t *testing.T) {
137 tests := []struct {
138 name string
139 key string
140 wantLength int
141 wantErr bool
142 }{
143 {
144 name: "remove key",
145 key: "erroneous",
146 wantLength: 6,
147 },
148 {
149 name: "remove key that is not present",
150 key: "invalid",
151 wantLength: 8,
152 wantErr: true,
153 },
154 {
155 name: "remove key that has same content as a value",
156 key: "same",
157 wantLength: 6,
158 },
159 }
160
161 for _, tt := range tests {
162 m := testMap()
163 t.Run(tt.name, func(t *testing.T) {
164 err := m.RemoveEntry(tt.key)
165 if tt.wantErr {
166 assert.EqualError(t, err, "not found")
167 assert.False(t, m.IsModified())
168 } else {
169 assert.NoError(t, err)
170 assert.True(t, m.IsModified())
171 }
172 assert.Equal(t, tt.wantLength, len(m.Content))
173 _, err = m.FindEntry(tt.key)
174 assert.EqualError(t, err, "not found")
175 })
176 }
177 }
178
179 func TestMapSetEntry(t *testing.T) {
180 tests := []struct {
181 name string
182 key string
183 value *Map
184 wantLength int
185 }{
186 {
187 name: "sets key that is not present",
188 key: "not",
189 value: StringValue("present"),
190 wantLength: 10,
191 },
192 {
193 name: "sets key that is present",
194 key: "erroneous",
195 value: StringValue("not same"),
196 wantLength: 8,
197 },
198 }
199 for _, tt := range tests {
200 m := testMap()
201 t.Run(tt.name, func(t *testing.T) {
202 m.SetEntry(tt.key, tt.value)
203 assert.True(t, m.IsModified())
204 assert.Equal(t, tt.wantLength, len(m.Content))
205 e, err := m.FindEntry(tt.key)
206 assert.NoError(t, err)
207 assert.Equal(t, tt.value.Value, e.Value)
208 })
209 }
210 }
211
212 func TestUnmarshal(t *testing.T) {
213 tests := []struct {
214 name string
215 data []byte
216 wantErr string
217 wantEmpty bool
218 }{
219 {
220 name: "valid yaml",
221 data: []byte(`{test: "data"}`),
222 },
223 {
224 name: "empty yaml",
225 data: []byte(``),
226 wantEmpty: true,
227 },
228 {
229 name: "invalid yaml",
230 data: []byte(`{test: `),
231 wantErr: "invalid yaml",
232 },
233 {
234 name: "invalid format",
235 data: []byte(`data`),
236 wantErr: "invalid format",
237 },
238 }
239 for _, tt := range tests {
240 t.Run(tt.name, func(t *testing.T) {
241 m, err := Unmarshal(tt.data)
242 if tt.wantErr != "" {
243 assert.EqualError(t, err, tt.wantErr)
244 assert.Nil(t, m)
245 return
246 }
247 assert.NoError(t, err)
248 assert.Equal(t, tt.wantEmpty, m.Empty())
249 })
250 }
251 }
252
253 func testMap() *Map {
254 var data = `
255 valid: present
256 erroneous: same
257 blank:
258 same: logical
259 `
260 m, _ := Unmarshal([]byte(data))
261 return m
262 }
263
264 func blankMap() *Map {
265 return MapValue()
266 }
267
View as plain text