test.sh - sfeed_tests - sfeed tests and RSS and Atom files | |
git clone git://git.codemadness.org/sfeed_tests | |
Log | |
Files | |
Refs | |
README | |
LICENSE | |
--- | |
test.sh (28852B) | |
--- | |
1 #!/bin/sh | |
2 | |
3 SFEED_UPDATE="$(command -v sfeed_update)" | |
4 [ "$SFEED_UPDATE" != "" ] || exit 1 | |
5 | |
6 # expect(expect, got, [extra]) | |
7 expect() { | |
8 if [ "$1" != "$2" ]; then | |
9 extra="$3" | |
10 [ "$extra" = "" ] || extra="($extra)" | |
11 echo "Expected \"$1\", but got \"$2\" $extra" >&2 | |
12 | |
13 # DEBUG | |
14 echo "Last stdout:" | |
15 cat "$log_stdout" | |
16 echo "" | |
17 echo "Last stderr:" | |
18 cat "$log_stderr" | |
19 exit 1 | |
20 fi | |
21 } | |
22 | |
23 init_test() { | |
24 rc="$(mktemp /tmp/rc_XXXXXXXX)" | |
25 log_stdout="$(mktemp /tmp/stdout_XXXXXXXX)" | |
26 log_stderr="$(mktemp /tmp/stderr_XXXXXXXX)" | |
27 feedpath="$(mktemp -d /tmp/feedpath_XXXXXXXX)" | |
28 } | |
29 | |
30 # create an rc file with some defaults for testing. | |
31 createrc() { | |
32 cat <<! | |
33 # override default iconv: do not use text decoding. | |
34 convertencoding() { | |
35 cat | |
36 } | |
37 # override default cURL: local files are tested. | |
38 fetch() { | |
39 cat "\${2#file://}" 2>/dev/null | |
40 } | |
41 ! | |
42 # add the rest. | |
43 cat | |
44 } | |
45 | |
46 cleanup() { | |
47 rm -rf "$feedpath" "$log_stdout" "$log_stderr" "$rc" | |
48 } | |
49 | |
50 # test normal execution, all succesful. | |
51 test_normal() { | |
52 init_test | |
53 | |
54 createrc > "$rc" <<! | |
55 sfeedpath="$feedpath" | |
56 | |
57 feeds() { | |
58 # feed <name> <feedurl> [basesiteurl] [encoding] | |
59 feed "1" "file:///dev/null" | |
60 feed "2" "file:///dev/null" | |
61 feed "3" "file:///dev/null" | |
62 } | |
63 ! | |
64 | |
65 "$SFEED_UPDATE" "$rc" >"$log_stdout" 2>"$log_stderr" | |
66 expect "0" "$?" "exit statuscode" | |
67 | |
68 linecount=$(wc -l < "$log_stdout") | |
69 linecount=$((linecount+0)) | |
70 expect "3" "$linecount" "all 3 lines should be written to stdout" | |
71 | |
72 linecount=$(wc -l < "$log_stderr") | |
73 linecount=$((linecount+0)) | |
74 expect "0" "$linecount" "0 lines should be written to stderr" | |
75 | |
76 test -d "$feedpath" | |
77 expect "0" "$?" "directory should exist: $feedpath" | |
78 | |
79 for i in 1 2 3; do | |
80 f="$feedpath/$i" | |
81 test -f "$f" | |
82 expect "0" "$?" "file should exist: $f" | |
83 done | |
84 | |
85 cleanup | |
86 | |
87 echo "test_normal: test OK" >&2 | |
88 } | |
89 | |
90 # test execution where a feed failed. | |
91 test_one_fail() { | |
92 init_test | |
93 | |
94 createrc > "$rc" <<! | |
95 sfeedpath="$feedpath" | |
96 | |
97 feeds() { | |
98 # feed <name> <feedurl> [basesiteurl] [encoding] | |
99 feed "1" "file:///dev/null" | |
100 feed "2" "file:///dev/null_fail" | |
101 feed "3" "file:///dev/null" | |
102 } | |
103 ! | |
104 | |
105 "$SFEED_UPDATE" "$rc" >"$log_stdout" 2> "$log_stderr" | |
106 expect "1" "$?" "exit statuscode" | |
107 | |
108 linecount=$(wc -l < "$log_stdout") | |
109 linecount=$((linecount+0)) | |
110 expect "2" "$linecount" "2 lines should be written to stdout" | |
111 | |
112 linecount=$(wc -l < "$log_stderr") | |
113 linecount=$((linecount+0)) | |
114 expect "1" "$linecount" "1 line should be written to stderr" | |
115 | |
116 test -d "$feedpath" | |
117 expect "0" "$?" "directory should exist: $feedpath" | |
118 | |
119 for i in 1 2 3; do | |
120 f="$feedpath/$i" | |
121 test -f "$f" | |
122 expect "0" "$?" "file should exist: $f" | |
123 done | |
124 | |
125 cleanup | |
126 | |
127 echo "test_one_fail: test OK" >&2 | |
128 } | |
129 | |
130 # test SIGTERM | |
131 test_sigterm() { | |
132 init_test | |
133 | |
134 tmp=$(mktemp '/tmp/sfeed_sigterm_cleanup_XXXXXXXX') | |
135 | |
136 createrc > "$rc" <<! | |
137 sfeedpath="$feedpath" | |
138 | |
139 # override | |
140 feed() { | |
141 _feed "\$@" | |
142 sleep 2 | |
143 } | |
144 | |
145 cleanup() { | |
146 echo "I'm created on SIGTERM" > "$tmp" | |
147 } | |
148 | |
149 feeds() { | |
150 # feed <name> <feedurl> [basesiteurl] [encoding] | |
151 feed "1" "file:///dev/null" | |
152 feed "2" "file:///dev/null" | |
153 feed "3" "file:///dev/null" | |
154 } | |
155 ! | |
156 | |
157 "$SFEED_UPDATE" "$rc" >"$log_stdout" 2> "$log_stderr" & | |
158 pid="$!" | |
159 { | |
160 sleep 1 | |
161 kill -TERM "$pid" | |
162 } & | |
163 wait "$pid" | |
164 # NOTE: 143 - 15 (SIGTERM) = 128 | |
165 expect "143" "$?" "exit statuscode" | |
166 | |
167 test -d "$feedpath" | |
168 expect "0" "$?" "directory should exist: $feedpath" | |
169 | |
170 # test that cleanup is called on SIGTERM | |
171 test -f "$tmp" | |
172 expect "0" "$?" "file should exist (test for cleanup function on… | |
173 | |
174 rm -f "$tmp" | |
175 cleanup | |
176 | |
177 echo "test_sigterm: test OK" >&2 | |
178 } | |
179 | |
180 test_config_invocation() { | |
181 init_test | |
182 | |
183 rcempty="$(mktemp /tmp/sfeed_emptyrc_XXXXXXXX)" | |
184 | |
185 "$SFEED_UPDATE" "$rcempty" >/dev/null 2> "$log_stderr" # should… | |
186 expect "1" "$?" "exit statuscode" | |
187 msg='does not contain a "feeds" function' | |
188 fgrep -q "$msg" < "$log_stderr" | |
189 expect "0" "$?" "stderr must contain text $msg" | |
190 | |
191 "$SFEED_UPDATE" /dev/null >/dev/null 2> "$log_stderr" | |
192 expect "1" "$?" "exit statuscode" | |
193 msg='Configuration file "/dev/null" cannot be read.' | |
194 fgrep -q "$msg" < "$log_stderr" | |
195 expect "0" "$?" "stderr must contain text $msg" | |
196 | |
197 "$SFEED_UPDATE" nonexistant >/dev/null 2> "$log_stderr" | |
198 expect "1" "$?" "exit statuscode" | |
199 msg='Configuration file "nonexistant" cannot be read.' | |
200 fgrep -q "$msg" < "$log_stderr" | |
201 expect "0" "$?" "stderr must contain text $msg" | |
202 | |
203 # invalid: must not be a directory. | |
204 "$SFEED_UPDATE" `pwd` >/dev/null 2> "$log_stderr" # directory | |
205 expect "1" "$?" "exit statuscode" | |
206 msg='" cannot be read.' | |
207 fgrep -q "$msg" < "$log_stderr" | |
208 expect "0" "$?" "stderr must contain text $msg" | |
209 | |
210 # invalid: must not be a directory. | |
211 "$SFEED_UPDATE" /root >/dev/null 2> "$log_stderr" # directory, p… | |
212 expect "1" "$?" "exit statuscode" | |
213 msg='Configuration file "/root" cannot be read.' | |
214 fgrep -q "$msg" < "$log_stderr" | |
215 expect "0" "$?" "stderr must contain text $msg" | |
216 | |
217 "$SFEED_UPDATE" /root/.sfeed/sfeedrc >/dev/null 2> "$log_stderr"… | |
218 expect "1" "$?" "exit statuscode" | |
219 msg='Configuration file "/root/.sfeed/sfeedrc" cannot be read.' | |
220 fgrep -q "$msg" < "$log_stderr" | |
221 expect "0" "$?" "stderr must contain text $msg" | |
222 | |
223 rctmp="$(mktemp /tmp/rctmp_XXXXXXXX)" | |
224 cp "$rc" "$rctmp" | |
225 chmod 000 "$rctmp" # no access | |
226 | |
227 "$SFEED_UPDATE" "$rctmp" >/dev/null 2> "$log_stderr" # no access | |
228 expect "1" "$?" "exit statuscode" | |
229 if [ -r "$rctmp" ]; then | |
230 # on haikuos test -r on a file with chmod 000 still retu… | |
231 msg='does not contain a "feeds" function' | |
232 else | |
233 msg="Configuration file \"${rctmp}\" cannot be read." | |
234 fi | |
235 fgrep -q "$msg" < "$log_stderr" | |
236 expect "0" "$?" "stderr must contain text $msg" | |
237 | |
238 chmod 644 "$rctmp" | |
239 rm -f "$rctmp" "$rcempty" | |
240 cleanup | |
241 | |
242 echo "test_config_invocation: test OK" >&2 | |
243 } | |
244 | |
245 test_tmpdir() { | |
246 init_test | |
247 | |
248 createrc > "$rc" <<! | |
249 sfeedpath="$feedpath" | |
250 | |
251 feeds() { | |
252 true | |
253 } | |
254 ! | |
255 | |
256 # NOTE: (2023-12-28) this fails on OpenIndiana, because when it … | |
257 # to TMPDIR it will just silently use /tmp (this is of course st… | |
258 # "fail early" principle). | |
259 TMPDIR=/noaccess "$SFEED_UPDATE" "$rc" >"$log_stdout" 2>"$log_st… | |
260 expect "1" "$?" "exit statuscode" | |
261 | |
262 TMPDIR="/tmp" "$SFEED_UPDATE" "$rc" >"$log_stdout" 2>"$log_stder… | |
263 expect "0" "$?" "exit statuscode" | |
264 | |
265 cleanup | |
266 | |
267 echo "test_tmpdir: test OK" >&2 | |
268 } | |
269 | |
270 test_tmpdir_cleanup() { | |
271 init_test | |
272 | |
273 tmp="$(mktemp -d 'sfeed_tmpdir_XXXXXXXX')" | |
274 | |
275 createrc > "$rc" <<! | |
276 sfeedpath="$feedpath" | |
277 | |
278 #cleanup() { | |
279 # true | |
280 #} | |
281 | |
282 feeds() { | |
283 true | |
284 } | |
285 ! | |
286 | |
287 TMPDIR="$tmp" "$SFEED_UPDATE" "$rc" >"$log_stdout" 2>"$log_stder… | |
288 expect "0" "$?" "exit statuscode" | |
289 | |
290 # global expand, normally it should contain only one dir. | |
291 testdir="" | |
292 for d in "$tmp/"*/; do | |
293 testdir="$d" | |
294 done | |
295 | |
296 test -d "$testdir" | |
297 expect "1" "$?" "feeds directory should not exist" | |
298 | |
299 test -f "$testdir/jobs" | |
300 expect "1" "$?" "jobs file should not exist" | |
301 | |
302 rm -r "$tmp" | |
303 cleanup | |
304 | |
305 echo "test_tmpdir_cleanup: test OK" >&2 | |
306 } | |
307 | |
308 test_override_cleanup() { | |
309 init_test | |
310 | |
311 tmp="$(mktemp -d 'sfeed_tmpdir_XXXXXXXX')" | |
312 | |
313 createrc > "$rc" <<! | |
314 sfeedpath="$feedpath" | |
315 | |
316 cleanup() { | |
317 true | |
318 } | |
319 | |
320 feeds() { | |
321 true | |
322 } | |
323 ! | |
324 | |
325 TMPDIR="$tmp" "$SFEED_UPDATE" "$rc" >"$log_stdout" 2>"$log_stder… | |
326 expect "0" "$?" "exit statuscode" | |
327 | |
328 # global expand, normally it should contain only one dir. | |
329 testdir="" | |
330 for d in "$tmp/"*/; do | |
331 testdir="$d" | |
332 done | |
333 | |
334 test -d "$testdir" | |
335 expect "0" "$?" "feeds directory should still exist" | |
336 | |
337 test -f "$testdir/jobs" | |
338 expect "0" "$?" "jobs file should still exist" | |
339 | |
340 test -f "$testdir/ok" | |
341 expect "0" "$?" "status file should still exist" | |
342 | |
343 rm -r "$tmp" | |
344 cleanup | |
345 | |
346 echo "test_override_cleanup: test OK" >&2 | |
347 } | |
348 | |
349 test_parameters() { | |
350 init_test | |
351 | |
352 expectfile="$(mktemp /tmp/expect_XXXXXXXX)" | |
353 | |
354 cat > "$expectfile" <<! | |
355 |||| | |
356 |feedurl|basesiteurl|encoding| | |
357 1|||| | |
358 2|feedurl||| | |
359 3|feedurl|basesiteurl|| | |
360 4|feedurl|basesiteurl|encoding| | |
361 5|feedurl||encoding| | |
362 6|||encoding| | |
363 7||basesiteurl|encoding| | |
364 8|feedurl||| | |
365 9|feedurl|basesiteurl|| | |
366 ! | |
367 | |
368 createrc > "$rc" <<! | |
369 sfeedpath="$feedpath" | |
370 maxjobs=1 # must be run sequential | |
371 | |
372 _feed() { | |
373 printf '%s|%s|%s|%s|\n' "\$1" "\$2" "\$3" "\$4" | |
374 } | |
375 | |
376 feeds() { | |
377 # feed <name> <feedurl> [basesiteurl] [encoding] | |
378 feed "" "" "" "" | |
379 feed "" "feedurl" "basesiteurl" "encoding" | |
380 feed "1" "" "" "" | |
381 feed "2" "feedurl" "" "" | |
382 feed "3" "feedurl" "basesiteurl" "" | |
383 feed "4" "feedurl" "basesiteurl" "encoding" | |
384 feed "5" "feedurl" "" "encoding" | |
385 feed "6" "" "" "encoding" | |
386 feed "7" "" "basesiteurl" "encoding" | |
387 feed "8" "feedurl" | |
388 feed "9" "feedurl" "basesiteurl" | |
389 } | |
390 ! | |
391 | |
392 "$SFEED_UPDATE" "$rc" >"$log_stdout" 2>"$log_stderr" | |
393 expect "0" "$?" "exit statuscode" | |
394 | |
395 # NOTE: on OpenIndiana this writes to stdout "No differences enc… | |
396 # *this is of course stupid). | |
397 diff -u "$log_stdout" "$expectfile" | |
398 expect "0" "$?" "exit statuscode" | |
399 | |
400 cleanup | |
401 rm -f "$expectfile" | |
402 | |
403 echo "test_parameters: test OK" >&2 | |
404 } | |
405 | |
406 test_override_fetch() { | |
407 init_test | |
408 | |
409 paramfile="$(mktemp /tmp/fetch_param_XXXXXXXX)" | |
410 | |
411 createrc > "$rc" <<! | |
412 sfeedpath="$feedpath" | |
413 maxjobs=1 # must be run sequential | |
414 | |
415 # fetch(name, url, feedfile) | |
416 fetch() { | |
417 # test name, url parameters. | |
418 # dirname of feedfile is random, test only the base name which s… | |
419 # match the feed name, with some characters replaced. | |
420 b="\${3##*/}" | |
421 printf '%s|%s|%s|\n' "\$1" "\$2" "\$b" >> "$paramfile" | |
422 | |
423 case "\$1" in | |
424 1) | |
425 echo "<item><title>a</title></item>";; | |
426 2) | |
427 echo "<item><title>b</title></item>";; | |
428 3) | |
429 echo "<item><title>c</title></item>";; | |
430 # test / in names, allowed, but path name for feed itself are re… | |
431 "funky/name") | |
432 echo "<item><title>d</title></item>";; | |
433 "funky*name") | |
434 echo "<item><title>e</title></item>";; | |
435 # test spaces in names | |
436 "name with spaces") | |
437 echo "<item><title>f</title></item>";; | |
438 esac | |
439 } | |
440 | |
441 feeds() { | |
442 # feed <name> <feedurl> [basesiteurl] [encoding] | |
443 feed "1" "file:///dev/null1" | |
444 feed "2" "file:///dev/null2" | |
445 feed "3" "file:///dev/null3" | |
446 feed "funky/name" "file:///dev/null4" | |
447 feed "funky*name" "file:///dev/null5" | |
448 feed "name with spaces" "file:///dev/null6" | |
449 } | |
450 ! | |
451 | |
452 "$SFEED_UPDATE" "$rc" >"$log_stdout" 2>"$log_stderr" | |
453 expect "0" "$?" "exit statuscode" | |
454 | |
455 result=$(cut -f 2 "$feedpath/1" "$feedpath/2" "$feedpath/3" \ | |
456 "$feedpath/funky_name" "$feedpath/funky*name" "$feedpath… | |
457 expect "abcdef" "$result" "results of feed files" | |
458 | |
459 paramstr=$(cat "$paramfile" | tr -d '\n') | |
460 expect '1|file:///dev/null1|1|2|file:///dev/null2|2|3|file:///de… | |
461 "$paramstr" "test parameters" | |
462 | |
463 cleanup | |
464 rm -f "$paramfile" | |
465 | |
466 echo "test_override_fetch: test OK" >&2 | |
467 } | |
468 | |
469 test_override_convertencoding() { | |
470 init_test | |
471 | |
472 paramfile="$(mktemp /tmp/convertencoding_param_XXXXXXXX)" | |
473 | |
474 createrc > "$rc" <<! | |
475 sfeedpath="$feedpath" | |
476 maxjobs=1 | |
477 | |
478 fetch() { | |
479 echo | |
480 } | |
481 | |
482 parse() { | |
483 cat | |
484 } | |
485 | |
486 # convertencoding(name, from, to) | |
487 convertencoding() { | |
488 printf '%s|%s|%s|\n' "\$1" "\$2" "\$3" >> "$paramfile" | |
489 | |
490 # to parameter is always "utf-8". | |
491 test "\$3" != "utf-8" && return 1 | |
492 | |
493 case "\$1" in | |
494 1) | |
495 echo "a";; | |
496 2) | |
497 echo "b";; | |
498 3) | |
499 echo "c";; | |
500 4) | |
501 echo "d";; | |
502 5) | |
503 echo "e";; | |
504 esac | |
505 } | |
506 | |
507 feeds() { | |
508 # feed <name> <feedurl> [basesiteurl] [encoding] | |
509 feed "1" "file:///dev/null1" "" "" | |
510 feed "2" "file:///dev/null2" "" "utf-8" | |
511 feed "3" "file:///dev/null3" "" "iso-8859-1" | |
512 feed "4" "file:///dev/null4" "" "utf-69" | |
513 feed "5" "file:///dev/null5" "" "from-utf-6" | |
514 } | |
515 ! | |
516 | |
517 "$SFEED_UPDATE" "$rc" >"$log_stdout" 2>"$log_stderr" | |
518 expect "0" "$?" "exit statuscode" | |
519 | |
520 linecount=$(wc -l < "$log_stdout") | |
521 linecount=$((linecount+0)) | |
522 expect "5" "$linecount" "5 lines should be written to stdout" | |
523 | |
524 linecount=$(wc -l < "$log_stderr") | |
525 linecount=$((linecount+0)) | |
526 expect "0" "$linecount" "0 line should be written to stderr" | |
527 | |
528 result=$(cut -f 2 "$feedpath/1" "$feedpath/2" "$feedpath/3" \ | |
529 "$feedpath/4" "$feedpath/5" | tr -d '\n') | |
530 expect "abcde" "$result" "results of feed files" | |
531 | |
532 paramstr=$(cat "$paramfile" | tr -d '\n') | |
533 expect '1||utf-8|2|utf-8|utf-8|3|iso-8859-1|utf-8|4|utf-69|utf-8… | |
534 "$paramstr" "test parameters" | |
535 | |
536 cleanup | |
537 rm -f "$paramfile" | |
538 | |
539 echo "test_override_convertencoding: test OK" >&2 | |
540 } | |
541 | |
542 test_fail_fetch() { | |
543 init_test | |
544 | |
545 createrc > "$rc" <<! | |
546 sfeedpath="$feedpath" | |
547 maxjobs=1 | |
548 | |
549 fetch() { | |
550 test "\$1" = "2" && return 1 | |
551 true | |
552 } | |
553 | |
554 feeds() { | |
555 # feed <name> <feedurl> [basesiteurl] [encoding] | |
556 feed "1" "file:///dev/null" | |
557 feed "2" "file:///dev/null" | |
558 feed "3" "file:///dev/null" | |
559 } | |
560 ! | |
561 | |
562 "$SFEED_UPDATE" "$rc" >"$log_stdout" 2> "$log_stderr" | |
563 expect "1" "$?" "exit statuscode" | |
564 | |
565 linecount=$(wc -l < "$log_stdout") | |
566 linecount=$((linecount+0)) | |
567 expect "2" "$linecount" "2 lines should be written to stdout" | |
568 | |
569 linecount=$(wc -l < "$log_stderr") | |
570 linecount=$((linecount+0)) | |
571 expect "1" "$linecount" "1 line should be written to stderr" | |
572 | |
573 grep -q "] 2 .* FAIL (FETCH)" < "$log_stderr" | |
574 expect "0" "$?" 'stderr should contain "FAIL (FETCH)"' | |
575 | |
576 test -d "$feedpath" | |
577 expect "0" "$?" "directory should exist: $feedpath" | |
578 | |
579 for i in 1 2 3; do | |
580 f="$feedpath/$i" | |
581 test -f "$f" | |
582 expect "0" "$?" "file should exist: $f" | |
583 done | |
584 | |
585 cleanup | |
586 | |
587 echo "test_fail_fetch: test OK" >&2 | |
588 } | |
589 | |
590 test_fail_convertencoding() { | |
591 init_test | |
592 | |
593 createrc > "$rc" <<! | |
594 sfeedpath="$feedpath" | |
595 maxjobs=1 | |
596 | |
597 convertencoding() { | |
598 test "\$1" = "2" && return 1 | |
599 true | |
600 } | |
601 | |
602 feeds() { | |
603 # feed <name> <feedurl> [basesiteurl] [encoding] | |
604 feed "1" "file:///dev/null" | |
605 feed "2" "file:///dev/null" | |
606 feed "3" "file:///dev/null" | |
607 } | |
608 ! | |
609 | |
610 "$SFEED_UPDATE" "$rc" >"$log_stdout" 2> "$log_stderr" | |
611 expect "1" "$?" "exit statuscode" | |
612 | |
613 linecount=$(wc -l < "$log_stdout") | |
614 linecount=$((linecount+0)) | |
615 expect "2" "$linecount" "2 lines should be written to stdout" | |
616 | |
617 linecount=$(wc -l < "$log_stderr") | |
618 linecount=$((linecount+0)) | |
619 expect "1" "$linecount" "1 line should be written to stderr" | |
620 | |
621 grep -q "] 2 .* FAIL (ENCODING)" < "$log_stderr" | |
622 expect "0" "$?" 'stderr should contain "FAIL (ENCODING)"' | |
623 | |
624 test -d "$feedpath" | |
625 expect "0" "$?" "directory should exist: $feedpath" | |
626 | |
627 for i in 1 2 3; do | |
628 f="$feedpath/$i" | |
629 test -f "$f" | |
630 expect "0" "$?" "file should exist: $f" | |
631 done | |
632 | |
633 cleanup | |
634 | |
635 echo "test_fail_convertencoding: test OK" >&2 | |
636 } | |
637 | |
638 test_override_parse() { | |
639 init_test | |
640 | |
641 paramfile="$(mktemp /tmp/parse_param_XXXXXXXX)" | |
642 | |
643 createrc > "$rc" <<! | |
644 sfeedpath="$feedpath" | |
645 maxjobs=1 | |
646 | |
647 fetch() { | |
648 echo | |
649 } | |
650 | |
651 convertencoding() { | |
652 cat | |
653 } | |
654 | |
655 # parse(name, feedurl, basesiteurl) | |
656 parse() { | |
657 printf '%s|%s|%s|\n' "\$1" "\$2" "\$3" >> "$paramfile" | |
658 | |
659 echo "\$1 title #\$1" | |
660 } | |
661 | |
662 feeds() { | |
663 # feed <name> <feedurl> [basesiteurl] [encoding] | |
664 feed "1" "file:///dev/null1" "" "" | |
665 feed "2" "file:///dev/null2" "basesiteurl" "utf-8" | |
666 feed "3" "file:///dev/null3" "" "iso-8859-1" | |
667 feed "4" "file:///dev/null4" "" "utf-69" | |
668 feed "5" "file:///dev/null5" "" "from-utf-6" | |
669 } | |
670 ! | |
671 | |
672 "$SFEED_UPDATE" "$rc" >"$log_stdout" 2>"$log_stderr" | |
673 expect "0" "$?" "exit statuscode" | |
674 | |
675 linecount=$(wc -l < "$log_stdout") | |
676 linecount=$((linecount+0)) | |
677 expect "5" "$linecount" "5 lines should be written to stdout" | |
678 | |
679 linecount=$(wc -l < "$log_stderr") | |
680 linecount=$((linecount+0)) | |
681 expect "0" "$linecount" "0 line should be written to stderr" | |
682 | |
683 result=$(cat "$feedpath/1" "$feedpath/2" "$feedpath/3" \ | |
684 "$feedpath/4" "$feedpath/5" | tr -d '\n') | |
685 expect "1 title #12 title #23 title #34 … | |
686 "$result" "results of feed files" | |
687 | |
688 paramstr=$(cat "$paramfile" | tr -d '\n') | |
689 expect '1|file:///dev/null1|file:///dev/null1|2|file:///dev/null… | |
690 "$paramstr" "test parameters" | |
691 | |
692 cleanup | |
693 rm -f "$paramfile" | |
694 | |
695 echo "test_override_parse: test OK" >&2 | |
696 } | |
697 | |
698 test_fail_parse() { | |
699 init_test | |
700 | |
701 createrc > "$rc" <<! | |
702 sfeedpath="$feedpath" | |
703 maxjobs=1 | |
704 | |
705 parse() { | |
706 test "\$1" = "2" && return 1 | |
707 true | |
708 } | |
709 | |
710 feeds() { | |
711 # feed <name> <feedurl> [basesiteurl] [encoding] | |
712 feed "1" "file:///dev/null" | |
713 feed "2" "file:///dev/null" | |
714 feed "3" "file:///dev/null" | |
715 } | |
716 ! | |
717 | |
718 "$SFEED_UPDATE" "$rc" >"$log_stdout" 2> "$log_stderr" | |
719 expect "1" "$?" "exit statuscode" | |
720 | |
721 linecount=$(wc -l < "$log_stdout") | |
722 linecount=$((linecount+0)) | |
723 expect "2" "$linecount" "2 lines should be written to stdout" | |
724 | |
725 linecount=$(wc -l < "$log_stderr") | |
726 linecount=$((linecount+0)) | |
727 expect "1" "$linecount" "1 line should be written to stderr" | |
728 | |
729 grep -q "] 2 .* FAIL (PARSE)" < "$log_stderr" | |
730 expect "0" "$?" 'stderr should contain "FAIL (PARSE)"' | |
731 | |
732 test -d "$feedpath" | |
733 expect "0" "$?" "directory should exist: $feedpath" | |
734 | |
735 for i in 1 2 3; do | |
736 f="$feedpath/$i" | |
737 test -f "$f" | |
738 expect "0" "$?" "file should exist: $f" | |
739 done | |
740 | |
741 cleanup | |
742 | |
743 echo "test_fail_parse: test OK" >&2 | |
744 } | |
745 | |
746 test_override_filter() { | |
747 init_test | |
748 | |
749 paramfile="$(mktemp /tmp/filter_param_XXXXXXXX)" | |
750 | |
751 createrc > "$rc" <<! | |
752 sfeedpath="$feedpath" | |
753 maxjobs=1 | |
754 | |
755 fetch() { | |
756 echo "\$1" | |
757 } | |
758 | |
759 convertencoding() { | |
760 cat | |
761 } | |
762 | |
763 # filter(name) | |
764 filter() { | |
765 printf '%s|\n' "\$1" >> "$paramfile" | |
766 | |
767 sed 's@^@BLA@g' | |
768 } | |
769 | |
770 parse() { | |
771 cat | |
772 } | |
773 | |
774 feeds() { | |
775 # feed <name> <feedurl> [basesiteurl] [encoding] | |
776 feed "1" "file:///dev/null1" "" "" | |
777 feed "2" "file:///dev/null2" "basesiteurl" "utf-8" | |
778 feed "3" "file:///dev/null3" "" "iso-8859-1" | |
779 feed "4" "file:///dev/null4" "" "utf-69" | |
780 feed "5" "file:///dev/null5" "" "from-utf-6" | |
781 } | |
782 ! | |
783 | |
784 "$SFEED_UPDATE" "$rc" >"$log_stdout" 2>"$log_stderr" | |
785 expect "0" "$?" "exit statuscode" | |
786 | |
787 linecount=$(wc -l < "$log_stdout") | |
788 linecount=$((linecount+0)) | |
789 expect "5" "$linecount" "5 lines should be written to stdout" | |
790 | |
791 linecount=$(wc -l < "$log_stderr") | |
792 linecount=$((linecount+0)) | |
793 expect "0" "$linecount" "0 line should be written to stderr" | |
794 | |
795 result=$(cat "$feedpath/1" "$feedpath/2" "$feedpath/3" \ | |
796 "$feedpath/4" "$feedpath/5" | tr -d '\n') | |
797 expect 'BLA1BLA2BLA3BLA4BLA5'\ | |
798 "$result" "results of feed files" | |
799 | |
800 paramstr=$(cat "$paramfile" | tr -d '\n') | |
801 expect '1|2|3|4|5|'\ | |
802 "$paramstr" "test parameters" | |
803 | |
804 cleanup | |
805 rm -f "$paramfile" | |
806 | |
807 echo "test_override_filter: test OK" >&2 | |
808 } | |
809 | |
810 test_fail_filter() { | |
811 init_test | |
812 | |
813 createrc > "$rc" <<! | |
814 sfeedpath="$feedpath" | |
815 maxjobs=1 | |
816 | |
817 filter() { | |
818 test "\$1" = "2" && return 1 | |
819 true | |
820 } | |
821 | |
822 feeds() { | |
823 # feed <name> <feedurl> [basesiteurl] [encoding] | |
824 feed "1" "file:///dev/null" | |
825 feed "2" "file:///dev/null" | |
826 feed "3" "file:///dev/null" | |
827 } | |
828 ! | |
829 | |
830 "$SFEED_UPDATE" "$rc" >"$log_stdout" 2> "$log_stderr" | |
831 expect "1" "$?" "exit statuscode" | |
832 | |
833 linecount=$(wc -l < "$log_stdout") | |
834 linecount=$((linecount+0)) | |
835 expect "2" "$linecount" "2 lines should be written to stdout" | |
836 | |
837 linecount=$(wc -l < "$log_stderr") | |
838 linecount=$((linecount+0)) | |
839 expect "1" "$linecount" "1 line should be written to stderr" | |
840 | |
841 grep -q "] 2 .* FAIL (FILTER)" < "$log_stderr" | |
842 expect "0" "$?" 'stderr should contain "FAIL (FILTER)"' | |
843 | |
844 test -d "$feedpath" | |
845 expect "0" "$?" "directory should exist: $feedpath" | |
846 | |
847 for i in 1 2 3; do | |
848 f="$feedpath/$i" | |
849 test -f "$f" | |
850 expect "0" "$?" "file should exist: $f" | |
851 done | |
852 | |
853 cleanup | |
854 | |
855 echo "test_fail_filter: test OK" >&2 | |
856 } | |
857 | |
858 test_nothing_to_merge() { | |
859 init_test | |
860 | |
861 createrc > "$rc" <<! | |
862 sfeedpath="$feedpath" | |
863 maxjobs=1 | |
864 | |
865 # filter must output some data, otherwise there is nothing to merge. | |
866 #filter() { | |
867 # echo a | |
868 #} | |
869 | |
870 merge() { | |
871 test "\$1" = "2" && return 1 | |
872 return 0 | |
873 } | |
874 | |
875 feeds() { | |
876 # feed <name> <feedurl> [basesiteurl] [encoding] | |
877 feed "1" "file:///dev/null" | |
878 feed "2" "file:///dev/null" | |
879 feed "3" "file:///dev/null" | |
880 } | |
881 ! | |
882 | |
883 # feed 2 isn't called (nothing to merge) so should return exit 0. | |
884 "$SFEED_UPDATE" "$rc" >"$log_stdout" 2> "$log_stderr" | |
885 expect "0" "$?" "exit statuscode" | |
886 | |
887 linecount=$(wc -l < "$log_stdout") | |
888 linecount=$((linecount+0)) | |
889 expect "3" "$linecount" "3 lines should be written to stdout" | |
890 | |
891 linecount=$(wc -l < "$log_stderr") | |
892 linecount=$((linecount+0)) | |
893 expect "0" "$linecount" "0 line should be written to stderr" | |
894 | |
895 grep -q "] 2 .* FAIL (MERGE)" < "$log_stderr" | |
896 expect "1" "$?" 'stderr should not contain "FAIL (MERGE)"' | |
897 | |
898 test -d "$feedpath" | |
899 expect "0" "$?" "directory should exist: $feedpath" | |
900 | |
901 for i in 1 2 3; do | |
902 f="$feedpath/$i" | |
903 test -f "$f" | |
904 expect "0" "$?" "file should exist: $f" | |
905 done | |
906 | |
907 cleanup | |
908 | |
909 echo "test_nothing_to_merge: test OK" >&2 | |
910 } | |
911 | |
912 test_override_merge() { | |
913 init_test | |
914 | |
915 paramfile="$(mktemp /tmp/merge_param_XXXXXXXX)" | |
916 | |
917 createrc > "$rc" <<! | |
918 sfeedpath="$feedpath" | |
919 maxjobs=1 | |
920 | |
921 # merge(name, oldfile, newfile) | |
922 merge() { | |
923 # dirname of feedfile is random, test only the base name which s… | |
924 # match the feed name, with some characters replaced. | |
925 b2="\${2##*/}" | |
926 b3="\${3##*/}" | |
927 | |
928 printf '%s|%s|%s|\n' "\$1" "\$b2" "\$b3" >> "$paramfile" | |
929 | |
930 cat "\$2" "\$3" | |
931 } | |
932 | |
933 order() { | |
934 cat | |
935 } | |
936 | |
937 fetch() { | |
938 echo "\$1" | |
939 } | |
940 | |
941 convertencoding() { | |
942 cat | |
943 } | |
944 | |
945 filter() { | |
946 cat | |
947 } | |
948 | |
949 parse() { | |
950 cat | |
951 } | |
952 | |
953 feeds() { | |
954 # feed <name> <feedurl> [basesiteurl] [encoding] | |
955 feed "1" "file:///dev/null1" "" "" | |
956 feed "2" "file:///dev/null2" "basesiteurl" "utf-8" | |
957 feed "3" "file:///dev/null3" "" "iso-8859-1" | |
958 feed "name with / in it" "file:///dev/null4" "" "utf-69" | |
959 feed "name with spaces" "file:///dev/null5" "" "from-utf-6" | |
960 } | |
961 ! | |
962 | |
963 "$SFEED_UPDATE" "$rc" >"$log_stdout" 2>"$log_stderr" | |
964 expect "0" "$?" "exit statuscode" | |
965 | |
966 linecount=$(wc -l < "$log_stdout") | |
967 linecount=$((linecount+0)) | |
968 expect "5" "$linecount" "5 lines should be written to stdout" | |
969 | |
970 linecount=$(wc -l < "$log_stderr") | |
971 linecount=$((linecount+0)) | |
972 expect "0" "$linecount" "0 line should be written to stderr" | |
973 | |
974 result=$(cat "$feedpath/1" "$feedpath/2" "$feedpath/3" \ | |
975 "$feedpath/name with _ in it" "$feedpath/name with space… | |
976 expect '123name with / in itname with spaces'\ | |
977 "$result" "results of feed files" | |
978 | |
979 paramstr=$(cat "$paramfile" | tr -d '\n') | |
980 expect '1|1|1.filter|2|2|2.filter|3|3|3.filter|name with / in it… | |
981 "$paramstr" "test parameters" | |
982 | |
983 # run another, should concat the results (in merge function). | |
984 "$SFEED_UPDATE" "$rc" >"$log_stdout" 2>"$log_stderr" | |
985 expect "0" "$?" "exit statuscode" | |
986 | |
987 result=$(cat "$feedpath/1" "$feedpath/2" "$feedpath/3" \ | |
988 "$feedpath/name with _ in it" "$feedpath/name with space… | |
989 expect '112233name with / in itname with / in itname with spaces… | |
990 "$result" "results of feed files" | |
991 | |
992 cleanup | |
993 rm -f "$paramfile" | |
994 | |
995 echo "test_override_merge: test OK" >&2 | |
996 } | |
997 | |
998 test_fail_merge() { | |
999 init_test | |
1000 | |
1001 createrc > "$rc" <<! | |
1002 sfeedpath="$feedpath" | |
1003 maxjobs=1 | |
1004 | |
1005 # filter must output some data, otherwise there is nothing to merge. | |
1006 filter() { | |
1007 echo a | |
1008 } | |
1009 | |
1010 merge() { | |
1011 test "\$1" = "2" && return 1 | |
1012 return 0 | |
1013 } | |
1014 | |
1015 feeds() { | |
1016 # feed <name> <feedurl> [basesiteurl] [encoding] | |
1017 feed "1" "file:///dev/null" | |
1018 feed "2" "file:///dev/null" | |
1019 feed "3" "file:///dev/null" | |
1020 } | |
1021 ! | |
1022 | |
1023 "$SFEED_UPDATE" "$rc" >"$log_stdout" 2> "$log_stderr" | |
1024 expect "1" "$?" "exit statuscode" | |
1025 | |
1026 linecount=$(wc -l < "$log_stdout") | |
1027 linecount=$((linecount+0)) | |
1028 expect "2" "$linecount" "2 lines should be written to stdout" | |
1029 | |
1030 linecount=$(wc -l < "$log_stderr") | |
1031 linecount=$((linecount+0)) | |
1032 expect "1" "$linecount" "1 line should be written to stderr" | |
1033 | |
1034 grep -q "] 2 .* FAIL (MERGE)" < "$log_stderr" | |
1035 expect "0" "$?" 'stderr should contain "FAIL (MERGE)"' | |
1036 | |
1037 test -d "$feedpath" | |
1038 expect "0" "$?" "directory should exist: $feedpath" | |
1039 | |
1040 for i in 1 2 3; do | |
1041 f="$feedpath/$i" | |
1042 test -f "$f" | |
1043 expect "0" "$?" "file should exist: $f" | |
1044 done | |
1045 | |
1046 cleanup | |
1047 | |
1048 echo "test_fail_merge: test OK" >&2 | |
1049 } | |
1050 | |
1051 test_override_order() { | |
1052 init_test | |
1053 | |
1054 paramfile="$(mktemp /tmp/order_param_XXXXXXXX)" | |
1055 | |
1056 createrc > "$rc" <<! | |
1057 sfeedpath="$feedpath" | |
1058 maxjobs=1 | |
1059 | |
1060 fetch() { | |
1061 echo | |
1062 } | |
1063 | |
1064 convertencoding() { | |
1065 cat | |
1066 } | |
1067 | |
1068 parse() { | |
1069 echo "9\$1 title #\$1" | |
1070 echo "7\$1 title #\$1" | |
1071 echo "8\$1 title #\$1" | |
1072 } | |
1073 | |
1074 filter() { | |
1075 cat | |
1076 } | |
1077 | |
1078 merge() { | |
1079 cat "\$3" | |
1080 } | |
1081 | |
1082 # order(name) | |
1083 order() { | |
1084 printf '%s|\n' "\$1" >> "$paramfile" | |
1085 | |
1086 sort -k1,1rn | |
1087 } | |
1088 | |
1089 feeds() { | |
1090 # feed <name> <feedurl> [basesiteurl] [encoding] | |
1091 feed "5" "file:///dev/null5" "" "from-utf-6" | |
1092 feed "2" "file:///dev/null2" "basesiteurl" "utf-8" | |
1093 feed "1" "file:///dev/null1" "" "" | |
1094 feed "3" "file:///dev/null3" "" "iso-8859-1" | |
1095 feed "4" "file:///dev/null4" "" "utf-69" | |
1096 | |
1097 } | |
1098 ! | |
1099 | |
1100 "$SFEED_UPDATE" "$rc" >"$log_stdout" 2>"$log_stderr" | |
1101 expect "0" "$?" "exit statuscode" | |
1102 | |
1103 linecount=$(wc -l < "$log_stdout") | |
1104 linecount=$((linecount+0)) | |
1105 expect "5" "$linecount" "5 lines should be written to stdout" | |
1106 | |
1107 linecount=$(wc -l < "$log_stderr") | |
1108 linecount=$((linecount+0)) | |
1109 expect "0" "$linecount" "0 line should be written to stderr" | |
1110 | |
1111 result=$(cat "$feedpath/1" | tr -d '\n') | |
1112 expect '91 title #181 title #171 title #1'\ | |
1113 "$result" "results of feed files" | |
1114 | |
1115 paramstr=$(cat "$paramfile" | tr -d '\n') | |
1116 expect '5|2|1|3|4|'\ | |
1117 "$paramstr" "test parameters" | |
1118 | |
1119 cleanup | |
1120 rm -f "$paramfile" | |
1121 | |
1122 echo "test_override_order: test OK" >&2 | |
1123 } | |
1124 | |
1125 test_fail_order() { | |
1126 init_test | |
1127 | |
1128 createrc > "$rc" <<! | |
1129 sfeedpath="$feedpath" | |
1130 maxjobs=1 | |
1131 | |
1132 # filter must output some data, otherwise there is nothing to merge. | |
1133 filter() { | |
1134 echo a | |
1135 } | |
1136 | |
1137 order() { | |
1138 test "\$1" = "2" && return 1 | |
1139 true | |
1140 } | |
1141 | |
1142 feeds() { | |
1143 # feed <name> <feedurl> [basesiteurl] [encoding] | |
1144 feed "1" "file:///dev/null" | |
1145 feed "2" "file:///dev/null" | |
1146 feed "3" "file:///dev/null" | |
1147 } | |
1148 ! | |
1149 | |
1150 "$SFEED_UPDATE" "$rc" >"$log_stdout" 2> "$log_stderr" | |
1151 expect "1" "$?" "exit statuscode" | |
1152 | |
1153 linecount=$(wc -l < "$log_stdout") | |
1154 linecount=$((linecount+0)) | |
1155 expect "2" "$linecount" "2 lines should be written to stdout" | |
1156 | |
1157 linecount=$(wc -l < "$log_stderr") | |
1158 linecount=$((linecount+0)) | |
1159 expect "1" "$linecount" "1 line should be written to stderr" | |
1160 | |
1161 grep -q "] 2 .* FAIL (ORDER)" < "$log_stderr" | |
1162 expect "0" "$?" 'stderr should contain "FAIL (ORDER)"' | |
1163 | |
1164 test -d "$feedpath" | |
1165 expect "0" "$?" "directory should exist: $feedpath" | |
1166 | |
1167 for i in 1 2 3; do | |
1168 f="$feedpath/$i" | |
1169 test -f "$f" | |
1170 expect "0" "$?" "file should exist: $f" | |
1171 done | |
1172 | |
1173 cleanup | |
1174 | |
1175 echo "test_fail_order: test OK" >&2 | |
1176 } | |
1177 | |
1178 # basic test for SFEED_UPDATE_INCLUDE=1 | |
1179 test_include() { | |
1180 init_test | |
1181 | |
1182 script="$(mktemp)" | |
1183 | |
1184 createrc > "$rc" <<! | |
1185 sfeedpath="$feedpath" | |
1186 maxjobs=1 # must be run sequential | |
1187 | |
1188 feeds() { | |
1189 # feed <name> <feedurl> [basesiteurl] [encoding] | |
1190 feed "1" "file:///dev/null" | |
1191 feed "2" "file:///dev/null_fail" | |
1192 feed "3" "file:///dev/null" | |
1193 } | |
1194 ! | |
1195 | |
1196 # include sfeed_update and call it in the normal way. | |
1197 cat > "$script" <<! | |
1198 #!/bin/sh | |
1199 SFEED_UPDATE_INCLUDE=1 . "$SFEED_UPDATE" | |
1200 main "\$@" | |
1201 ! | |
1202 | |
1203 chmod +x "$script" | |
1204 "$script" "$rc" >"$log_stdout" 2> "$log_stderr" | |
1205 expect "1" "$?" "exit statuscode" | |
1206 | |
1207 linecount=$(wc -l < "$log_stdout") | |
1208 linecount=$((linecount+0)) | |
1209 expect "2" "$linecount" "2 lines should be written to stdout" | |
1210 | |
1211 linecount=$(wc -l < "$log_stderr") | |
1212 linecount=$((linecount+0)) | |
1213 expect "1" "$linecount" "1 line should be written to stderr" | |
1214 | |
1215 test -d "$feedpath" | |
1216 expect "0" "$?" "directory should exist: $feedpath" | |
1217 | |
1218 for i in 1 2 3; do | |
1219 f="$feedpath/$i" | |
1220 test -f "$f" | |
1221 expect "0" "$?" "file should exist: $f" | |
1222 done | |
1223 | |
1224 rm -f "$script" | |
1225 cleanup | |
1226 | |
1227 echo "test_include: test OK" >&2 | |
1228 } | |
1229 | |
1230 # basic test for SFEED_UPDATE_INCLUDE=1 and config variables. | |
1231 test_include_config_vars() { | |
1232 init_test | |
1233 | |
1234 script="$(mktemp)" | |
1235 | |
1236 createrc > "$rc" <<! | |
1237 sfeedpath="$feedpath" | |
1238 maxjobs=1 | |
1239 | |
1240 # do not set defaults | |
1241 _feed() { | |
1242 printf '%s\t%s\n' "\$sfeedpath" "\$maxjobs" | |
1243 } | |
1244 | |
1245 feeds() { | |
1246 # feed <name> <feedurl> [basesiteurl] [encoding] | |
1247 feed "1" "file:///dev/null" | |
1248 } | |
1249 ! | |
1250 | |
1251 # include sfeed_update and call it in the normal way. | |
1252 cat > "$script" <<! | |
1253 #!/bin/sh | |
1254 SFEED_UPDATE_INCLUDE=1 . "$SFEED_UPDATE" | |
1255 main "\$@" | |
1256 ! | |
1257 | |
1258 chmod +x "$script" | |
1259 "$script" "$rc" >"$log_stdout" 2> "$log_stderr" | |
1260 expect "0" "$?" "exit statuscode" | |
1261 | |
1262 linecount=$(wc -l < "$log_stderr") | |
1263 linecount=$((linecount+0)) | |
1264 expect "0" "$linecount" "0 lines should be written to stderr" | |
1265 | |
1266 content="$(cat "$log_stdout")" | |
1267 expect "$content" "$feedpath 1" "config values are invali… | |
1268 | |
1269 rm -f "$script" | |
1270 cleanup | |
1271 | |
1272 echo "test_include_config_vars: test OK" >&2 | |
1273 } | |
1274 | |
1275 # basic test for SFEED_UPDATE_INCLUDE=1 and default config values for | |
1276 # variables. | |
1277 test_include_config_vars_default() { | |
1278 init_test | |
1279 | |
1280 script="$(mktemp)" | |
1281 | |
1282 createrc > "$rc" <<! | |
1283 # do not set defaults | |
1284 _feed() { | |
1285 printf '%s\t%s\n' "\$sfeedpath" "\$maxjobs" | |
1286 } | |
1287 | |
1288 feeds() { | |
1289 # feed <name> <feedurl> [basesiteurl] [encoding] | |
1290 feed "1" "file:///dev/null" | |
1291 } | |
1292 ! | |
1293 | |
1294 # include sfeed_update and call it in the normal way. | |
1295 cat > "$script" <<! | |
1296 #!/bin/sh | |
1297 SFEED_UPDATE_INCLUDE=1 . "$SFEED_UPDATE" | |
1298 main "\$@" | |
1299 ! | |
1300 | |
1301 chmod +x "$script" | |
1302 "$script" "$rc" >"$log_stdout" 2> "$log_stderr" | |
1303 expect "0" "$?" "exit statuscode" | |
1304 | |
1305 linecount=$(wc -l < "$log_stderr") | |
1306 linecount=$((linecount+0)) | |
1307 expect "0" "$linecount" "0 lines should be written to stderr" | |
1308 | |
1309 content="$(cat "$log_stdout")" | |
1310 expect "$content" "$HOME/.sfeed/feeds 16" "default config… | |
1311 | |
1312 rm -f "$script" | |
1313 cleanup | |
1314 | |
1315 echo "test_include_config_vars_default: test OK" >&2 | |
1316 } | |
1317 | |
1318 test_normal | |
1319 test_one_fail | |
1320 test_tmpdir | |
1321 test_tmpdir_cleanup | |
1322 test_config_invocation | |
1323 test_parameters | |
1324 | |
1325 test_fail_fetch | |
1326 test_fail_convertencoding | |
1327 test_fail_parse | |
1328 test_fail_filter | |
1329 test_fail_merge | |
1330 test_fail_order | |
1331 | |
1332 test_nothing_to_merge | |
1333 | |
1334 test_override_cleanup | |
1335 test_override_fetch | |
1336 test_override_convertencoding | |
1337 test_override_parse | |
1338 test_override_filter | |
1339 test_override_merge | |
1340 test_override_order | |
1341 | |
1342 test_include | |
1343 test_include_config_vars | |
1344 test_include_config_vars_default | |
1345 | |
1346 echo "Testing SIGTERM (has some delay)..." | |
1347 | |
1348 # NOTE: SIGINT can't reliably be tested. | |
1349 test_sigterm |