test.sh - sfeed_tests - sfeed tests and RSS and Atom files
(HTM) git clone git://git.codemadness.org/sfeed_tests
(DIR) Log
(DIR) Files
(DIR) Refs
(DIR) README
(DIR) 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 SIGTERM)"
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 say feeds function is not defined.
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, probably no access
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" # no access
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 returns 0
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 doesn't have permission
257 # to TMPDIR it will just silently use /tmp (this is of course stupid, failing the UNIX
258 # "fail early" principle).
259 TMPDIR=/noaccess "$SFEED_UPDATE" "$rc" >"$log_stdout" 2>"$log_stderr"
260 expect "1" "$?" "exit statuscode"
261
262 TMPDIR="/tmp" "$SFEED_UPDATE" "$rc" >"$log_stdout" 2>"$log_stderr"
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_stderr"
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_stderr"
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 encountered"
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 should
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 replaced to underscore.
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/name with spaces" | tr -d '\n')
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:///dev/null3|3|funky/name|file:///dev/null4|funky_name|funky*name|file:///dev/null5|funky*name|name with spaces|file:///dev/null6|name with spaces|'\
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|5|from-utf-6|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 title #45 title #5"\
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/null2|basesiteurl|3|file:///dev/null3|file:///dev/null3|4|file:///dev/null4|file:///dev/null4|5|file:///dev/null5|file:///dev/null5|'\
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 should
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 spaces" | tr -d '\n')
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|name with _ in it|name with _ in it.filter|name with spaces|name with spaces|name with spaces.filter|'\
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 spaces" | tr -d '\n')
989 expect '112233name with / in itname with / in itname with spacesname 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 invalid"
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 values are invalid"
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