@@ -101,3 +101,203 @@ func TestVM_EvaluateSnippet_memory_importer(t *testing.T) {
101 101 102 102
require.Equal(t, "evaluated", out)
103 103
}
104 + 105 +
func Test_regexSubst(t *testing.T) {
106 +
cases := []struct {
107 +
name string
108 +
in []interface{}
109 +
expected string
110 +
isErr bool
111 +
}{
112 +
{
113 +
name: "valid regex",
114 +
in: []interface{}{
115 +
"ee",
116 +
"tree",
117 +
"oll",
118 +
},
119 +
expected: "troll",
120 +
},
121 +
{
122 +
name: "invalid regex",
123 +
in: []interface{}{
124 +
"[",
125 +
"tree",
126 +
"oll",
127 +
},
128 +
isErr: true,
129 +
},
130 +
}
131 + 132 +
for _, tc := range cases {
133 +
t.Run(tc.name, func(t *testing.T) {
134 +
out, err := regexSubst(tc.in)
135 +
if tc.isErr {
136 +
require.Error(t, err)
137 +
return
138 +
}
139 + 140 +
require.NoError(t, err)
141 + 142 +
s, ok := out.(string)
143 +
require.True(t, ok)
144 + 145 +
require.Equal(t, tc.expected, s)
146 +
})
147 +
}
148 +
}
149 + 150 +
func Test_regexMatch(t *testing.T) {
151 +
in := []interface{}{"ee", "tree"}
152 +
out, err := regexMatch(in)
153 +
require.NoError(t, err)
154 + 155 +
tf, ok := out.(bool)
156 +
require.True(t, ok)
157 +
require.True(t, tf)
158 +
}
159 + 160 +
func Test_escapeStringRegex(t *testing.T) {
161 +
in := []interface{}{"[foo]"}
162 +
out, err := escapeStringRegex(in)
163 +
require.NoError(t, err)
164 + 165 +
s, ok := out.(string)
166 +
require.True(t, ok)
167 + 168 +
require.Equal(t, `\[foo\]`, s)
169 +
}
170 + 171 +
func Test_parseYAML(t *testing.T) {
172 +
cases := []struct {
173 +
name string
174 +
in []interface{}
175 +
expected interface{}
176 +
isErr bool
177 +
}{
178 +
{
179 +
name: "valid yaml",
180 +
in: []interface{}{"---\nfoo: bar"},
181 +
expected: []interface{}{
182 +
map[string]interface{}{
183 +
"foo": "bar",
184 +
},
185 +
},
186 +
},
187 +
}
188 + 189 +
for _, tc := range cases {
190 +
t.Run(tc.name, func(t *testing.T) {
191 +
out, err := parseYAML(tc.in)
192 +
if tc.isErr {
193 +
require.Error(t, err)
194 +
return
195 +
}
196 + 197 +
require.NoError(t, err)
198 + 199 +
require.Equal(t, tc.expected, out)
200 +
})
201 +
}
202 +
}
203 + 204 +
func Test_parseJSON(t *testing.T) {
205 +
cases := []struct {
206 +
name string
207 +
in []interface{}
208 +
expected interface{}
209 +
isErr bool
210 +
}{
211 +
{
212 +
name: "valid JSON",
213 +
in: []interface{}{`{ "foo": "bar" }`},
214 +
expected: map[string]interface{}{
215 +
"foo": "bar",
216 +
},
217 +
},
218 +
}
219 + 220 +
for _, tc := range cases {
221 +
t.Run(tc.name, func(t *testing.T) {
222 +
out, err := parseJSON(tc.in)
223 +
if tc.isErr {
224 +
require.Error(t, err)
225 +
return
226 +
}
227 + 228 +
require.NoError(t, err)
229 + 230 +
require.Equal(t, tc.expected, out)
231 +
})
232 +
}
233 +
}
234 + 235 +
func TestParseJson(t *testing.T) {
236 +
vm := NewVM()
237 + 238 +
_, err := vm.EvaluateSnippet("failtest", `std.native("parseJson")("barf{")`)
239 +
require.Error(t, err)
240 + 241 +
x, err := vm.EvaluateSnippet("test", `std.native("parseJson")("null")`)
242 +
require.NoError(t, err)
243 +
assert.Equal(t, "null\n", x)
244 + 245 +
x, err = vm.EvaluateSnippet("test", `
246 +
local a = std.native("parseJson")('{"foo": 3, "bar": 4}');
247 +
a.foo + a.bar`)
248 +
require.NoError(t, err)
249 +
assert.Equal(t, "7\n", x)
250 +
}
251 + 252 +
func TestParseYaml(t *testing.T) {
253 +
vm := NewVM()
254 + 255 +
_, err := vm.EvaluateSnippet("failtest", `std.native("parseYaml")("[barf")`)
256 +
require.Error(t, err)
257 + 258 +
x, err := vm.EvaluateSnippet("test", `std.native("parseYaml")("")`)
259 +
require.NoError(t, err)
260 +
assert.Equal(t, "[ ]\n", x)
261 + 262 +
x, err = vm.EvaluateSnippet("test", `
263 +
local a = std.native("parseYaml")("foo:\n- 3\n- 4\n")[0];
264 +
a.foo[0] + a.foo[1]`)
265 +
require.NoError(t, err)
266 +
assert.Equal(t, "7\n", x)
267 + 268 +
x, err = vm.EvaluateSnippet("test", `
269 +
local a = std.native("parseYaml")("---\nhello\n---\nworld");
270 +
a[0] + a[1]`)
271 +
require.NoError(t, err)
272 +
assert.Equal(t, "\"helloworld\"\n", x)
273 +
}
274 + 275 +
func Test_regexMatch_fun(t *testing.T) {
276 +
vm := NewVM()
277 + 278 +
_, err := vm.EvaluateSnippet("failtest", `std.native("regexMatch")("[f", "foo")`)
279 +
require.Error(t, err)
280 + 281 +
x, err := vm.EvaluateSnippet("test", `std.native("regexMatch")("foo.*", "seafood")`)
282 +
require.NoError(t, err)
283 +
assert.Equal(t, "true\n", x)
284 + 285 +
x, err = vm.EvaluateSnippet("test", `std.native("regexMatch")("bar.*", "seafood")`)
286 +
require.NoError(t, err)
287 +
assert.Equal(t, "false\n", x)
288 +
}
289 + 290 +
func TestRegexSubst(t *testing.T) {
291 +
vm := NewVM()
292 + 293 +
_, err := vm.EvaluateSnippet("failtest", `std.native("regexSubst")("[f",s "foo", "bar")`)
294 +
require.Error(t, err)
295 + 296 +
x, err := vm.EvaluateSnippet("test", `std.native("regexSubst")("a(x*)b", "-ab-axxb-", "T")`)
297 +
require.NoError(t, err)
298 +
assert.Equal(t, "\"-T-T-\"\n", x)
299 + 300 +
x, err = vm.EvaluateSnippet("test", `std.native("regexSubst")("a(x*)b", "-ab-axxb-", "${1}W")`)
301 +
require.NoError(t, err)
302 +
assert.Equal(t, "\"-W-xxW-\"\n", x)
303 +
}
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4