git.notmuchmail.org Git - notmuch/blob - test/test-lib.sh

   1 #
   2 # Copyright (c) 2005 Junio C Hamano
   3 # Copyright (c) 2010 Notmuch Developers
   4 #
   5 # This program is free software: you can redistribute it and/or modify
   6 # it under the terms of the GNU General Public License as published by
   7 # the Free Software Foundation, either version 2 of the License, or
   8 # (at your option) any later version.
   9 #
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU General Public License
  16 # along with this program.  If not, see https://www.gnu.org/licenses/ .
  17
  18 if [ ${BASH_VERSINFO[0]} -lt 4 ]; then
  19     echo "Error: The notmuch test suite requires a bash version >= 4.0"
  20     echo "due to use of associative arrays within the test suite."
  21     echo "Please try again with a newer bash (or help us fix the"
  22     echo "test suite to be more portable). Thanks."
  23     exit 1
  24 fi
  25
  26 # Make sure echo builtin does not expand backslash-escape sequences by default.
  27 shopt -u xpg_echo
  28
  29 # Ensure NOTMUCH_SRCDIR and NOTMUCH_BUILDDIR are set.
  30 . $(dirname "$0")/export-dirs.sh || exit 1
  31
  32 # It appears that people try to run tests without building...
  33 if [[ ! -x "$NOTMUCH_BUILDDIR/notmuch" ]]; then
  34         echo >&2 'You do not seem to have built notmuch yet.'
  35         exit 1
  36 fi
  37
  38 this_test=${0##*/}
  39 this_test=${this_test%.sh}
  40 this_test_bare=${this_test#T[0-9][0-9][0-9]-}
  41
  42 # if --tee was passed, write the output not only to the terminal, but
  43 # additionally to the file test-results/$BASENAME.out, too.
  44 case "$GIT_TEST_TEE_STARTED, $* " in
  45 done,*)
  46         # do not redirect again
  47         ;;
  48 *' --tee '*|*' --va'*)
  49         mkdir -p test-results
  50         BASE=test-results/$this_test
  51         (GIT_TEST_TEE_STARTED=done "$BASH" "$0" "$@" 2>&1;
  52          echo $? > $BASE.exit) | tee $BASE.out
  53         test "$(cat $BASE.exit)" = 0
  54         exit
  55         ;;
  56 esac
  57
  58 # STDIN from /dev/null. EOF for readers (and ENOTTY for tty related ioctls).
  59 exec </dev/null
  60
  61 # Save STDOUT to fd 6 and STDERR to fd 7.
  62 exec 6>&1 7>&2
  63 # Make xtrace debugging (when used) use redirected STDERR, with verbose lead:
  64 BASH_XTRACEFD=7
  65 export PS4='+(${BASH_SOURCE}:${LINENO}): ${FUNCNAME[0]:+${FUNCNAME[0]}(): }'
  66
  67 # Keep the original TERM for say_color and test_emacs
  68 ORIGINAL_TERM=$TERM
  69
  70 # Set SMART_TERM to vt100 for known dumb/unknown terminal.
  71 # Otherwise use whatever TERM is currently used so that
  72 # users' actual TERM environments are being used in tests.
  73 case ${TERM-} in
  74         '' | dumb | unknown )
  75                 SMART_TERM=vt100 ;;
  76         *)
  77                 SMART_TERM=$TERM ;;
  78 esac
  79
  80 # For repeatability, reset the environment to known value.
  81 LANG=C
  82 LC_ALL=C
  83 PAGER=cat
  84 TZ=UTC
  85 TERM=dumb
  86 export LANG LC_ALL PAGER TERM TZ
  87 GIT_TEST_CMP=${GIT_TEST_CMP:-diff -u}
  88 if [[ ( -n "$TEST_EMACS" && -z "$TEST_EMACSCLIENT" ) || \
  89       ( -z "$TEST_EMACS" && -n "$TEST_EMACSCLIENT" ) ]]; then
  90     echo "error: must specify both or neither of TEST_EMACS and TEST_EMACSCLIENT" >&2
  91     exit 1
  92 fi
  93 TEST_EMACS=${TEST_EMACS:-${EMACS:-emacs}}
  94 TEST_EMACSCLIENT=${TEST_EMACSCLIENT:-emacsclient}
  95 TEST_GDB=${TEST_GDB:-gdb}
  96 TEST_CC=${TEST_CC:-cc}
  97 TEST_CFLAGS=${TEST_CFLAGS:-"-g -O0"}
  98 TEST_SHIM_CFLAGS=${TEST_SHIM_CFLAGS:-"-fpic -shared"}
  99 TEST_SHIM_LDFLAGS=${TEST_SHIM_LDFLAGS:-"-ldl"}
 100
 101 # Protect ourselves from common misconfiguration to export
 102 # CDPATH into the environment
 103 unset CDPATH
 104
 105 unset GREP_OPTIONS
 106
 107 # For emacsclient
 108 unset ALTERNATE_EDITOR
 109
 110 # for reproducibility
 111 unset EMAIL
 112
 113 add_gnupg_home ()
 114 {
 115     [ -e "${GNUPGHOME}/gpg.conf" ] && return
 116     _gnupg_exit () { gpgconf --kill all 2>/dev/null || true; }
 117     at_exit_function _gnupg_exit
 118     mkdir -p -m 0700 "$GNUPGHOME"
 119     gpg --no-tty --import <$NOTMUCH_SRCDIR/test/gnupg-secret-key.asc >"$GNUPGHOME"/import.log 2>&1
 120     test_debug "cat $GNUPGHOME/import.log"
 121     if (gpg --quick-random --version >/dev/null 2>&1) ; then
 122         echo quick-random >> "$GNUPGHOME"/gpg.conf
 123     elif (gpg --debug-quick-random --version >/dev/null 2>&1) ; then
 124         echo debug-quick-random >> "$GNUPGHOME"/gpg.conf
 125     fi
 126     echo no-emit-version >> "$GNUPGHOME"/gpg.conf
 127
 128     # Change this if we ship a new test key
 129     FINGERPRINT="5AEAB11F5E33DCE875DDB75B6D92612D94E46381"
 130     SELF_USERID="Notmuch Test Suite <test_suite@notmuchmail.org> (INSECURE!)"
 131     printf '%s:6:\n' "$FINGERPRINT" | gpg --quiet --batch --no-tty --import-ownertrust
 132 }
 133
 134 add_gpgsm_home ()
 135 {
 136     local fpr
 137     [ -e "$GNUPGHOME/gpgsm.conf" ] && return
 138     _gnupg_exit () { gpgconf --kill all 2>/dev/null || true; }
 139     at_exit_function _gnupg_exit
 140     mkdir -p -m 0700 "$GNUPGHOME"
 141     openssl pkcs12 -export -passout pass: -inkey "$NOTMUCH_SRCDIR/test/smime/key+cert.pem" \
 142         < "$NOTMUCH_SRCDIR/test/smime/test.crt" | \
 143         gpgsm --batch --no-tty --no-common-certs-import --pinentry-mode=loopback --passphrase-fd 3 \
 144               --disable-dirmngr --import  >"$GNUPGHOME"/import.log 2>&1 3<<<''
 145     fpr=$(gpgsm --batch --list-key test_suite@notmuchmail.org | sed -n 's/.*fingerprint: //p')
 146     echo "$fpr S relax" >> "$GNUPGHOME/trustlist.txt"
 147     gpgsm --quiet --batch --no-tty --no-common-certs-import --disable-dirmngr --import < $NOTMUCH_SRCDIR/test/smime/ca.crt
 148     echo "4D:E0:FF:63:C0:E9:EC:01:29:11:C8:7A:EE:DA:3A:9A:7F:6E:C1:0D S" >> "$GNUPGHOME/trustlist.txt"
 149     printf '%s::1\n' include-certs disable-crl-checks | gpgconf --output /dev/null --change-options gpgsm
 150     gpgsm --batch --no-tty --no-common-certs-import --pinentry-mode=loopback --passphrase-fd 3 \
 151               --disable-dirmngr --import "$NOTMUCH_SRCDIR/test/smime/bob.p12" >>"$GNUPGHOME"/import.log 2>&1 3<<<''
 152     test_debug "cat $GNUPGHOME/import.log"
 153 }
 154
 155 # Each test should start with something like this, after copyright notices:
 156 #
 157 # test_description='Description of this test...
 158 # This test checks if command xyzzy does the right thing...
 159 # '
 160 # . ./test-lib.sh || exit 1
 161
 162 color=maybe
 163
 164 while test "$#" -ne 0
 165 do
 166         case "$1" in
 167         -d|--debug)
 168                 debug=t; shift ;;
 169         -i|--immediate)
 170                 immediate=t; shift ;;
 171         -h|--help)
 172                 help=t; shift ;;
 173         -v|--verbose)
 174                 verbose=t; shift ;;
 175         -q|--quiet)
 176                 quiet=t; shift ;;
 177         --with-dashes)
 178                 with_dashes=t; shift ;;
 179         --no-color)
 180                 color=; shift ;;
 181         --no-python)
 182                 # noop now...
 183                 shift ;;
 184         --valgrind)
 185                 valgrind=t; verbose=t; shift ;;
 186         --tee)
 187                 shift ;; # was handled already
 188         *)
 189                 echo "error: unknown test option '$1'" >&2; exit 1 ;;
 190         esac
 191 done
 192
 193 if test -n "$debug"; then
 194     print_subtest () {
 195         printf " %-4s" "[$((test_count - 1))]"
 196     }
 197 else
 198     print_subtest () {
 199         true
 200     }
 201 fi
 202
 203 test -n "$COLORS_WITHOUT_TTY" || [ -t 1 ] || color=
 204
 205 if [ -n "$color" ] && [ "$ORIGINAL_TERM" != 'dumb' ] && (
 206                 TERM=$ORIGINAL_TERM &&
 207                 export TERM &&
 208                 tput bold
 209                 tput setaf
 210                 tput sgr0
 211         ) >/dev/null 2>&1
 212 then
 213         color=t
 214 else
 215         color=
 216 fi
 217
 218 if test -n "$color"; then
 219         say_color () {
 220                 (
 221                 TERM=$ORIGINAL_TERM
 222                 export TERM
 223                 case "$1" in
 224                         error) tput bold; tput setaf 1;; # bold red
 225                         skip)  tput bold; tput setaf 2;; # bold green
 226                         pass)  tput setaf 2;;            # green
 227                         info)  tput setaf 3;;            # brown
 228                         *) test -n "$quiet" && return;;
 229                 esac
 230                 shift
 231                 printf " "
 232                 printf "$@"
 233                 tput sgr0
 234                 print_subtest
 235                 )
 236         }
 237 else
 238         say_color() {
 239                 test -z "$1" && test -n "$quiet" && return
 240                 shift
 241                 printf " "
 242                 printf "$@"
 243                 print_subtest
 244         }
 245 fi
 246
 247 error () {
 248         say_color error "error: $*\n"
 249         GIT_EXIT_OK=t
 250         exit 1
 251 }
 252
 253 say () {
 254         say_color info "$*"
 255 }
 256
 257 test "${test_description}" != "" ||
 258 error "Test script did not set test_description."
 259
 260 if test "$help" = "t"
 261 then
 262         echo "Tests ${test_description}"
 263         exit 0
 264 fi
 265
 266 test_description_printed=
 267 print_test_description ()
 268 {
 269         test -z "$test_description_printed" || return 0
 270         echo
 271         echo $this_test: "Testing ${test_description}"
 272         test_description_printed=1
 273 }
 274 if [ -z "$NOTMUCH_TEST_QUIET" ]
 275 then
 276         print_test_description
 277 fi
 278
 279 test_failure=0
 280 test_count=0
 281 test_fixed=0
 282 test_broken=0
 283 test_success=0
 284
 285 declare -a _exit_functions=()
 286
 287 at_exit_function () {
 288         _exit_functions=($1 ${_exit_functions[@]/$1})
 289 }
 290
 291 rm_exit_function () {
 292         _exit_functions=(${_exit_functions[@]/$1})
 293 }
 294
 295 _exit_common () {
 296         code=$?
 297         trap - EXIT
 298         set +ex
 299         for _fn in ${_exit_functions[@]}; do $_fn; done
 300         rm -rf "$TEST_TMPDIR"
 301 }
 302
 303 trap_exit () {
 304         _exit_common
 305         if test -n "$GIT_EXIT_OK"
 306         then
 307                 exit $code
 308         else
 309                 exec >&6
 310                 say_color error '%-6s' FATAL
 311                 echo " $test_subtest_name"
 312                 echo
 313                 echo "Unexpected exit while executing $0. Exit code $code."
 314                 exit 1
 315         fi
 316 }
 317
 318 trap_signal () {
 319         _exit_common
 320         echo >&6 "FATAL: $0: interrupted by signal" $((code - 128))
 321         exit $code
 322 }
 323
 324 die () {
 325         _exit_common
 326         exec >&6
 327         say_color error '%-6s' FATAL
 328         echo " $*"
 329         echo
 330         echo "Unexpected exit while executing $0."
 331         exit 1
 332 }
 333
 334 GIT_EXIT_OK=
 335 # Note: TEST_TMPDIR *NOT* exported!
 336 TEST_TMPDIR=$(mktemp -d "${TMPDIR:-/tmp}/notmuch-test-$$.XXXXXX")
 337 # Put GNUPGHOME in TMPDIR to avoid problems with long paths.
 338 export GNUPGHOME="${TEST_TMPDIR}/gnupg"
 339 trap 'trap_exit' EXIT
 340 trap 'trap_signal' HUP INT TERM
 341
 342 # Deliver a message with emacs and add it to the database
 343 #
 344 # Uses emacs to generate and deliver a message to the mail store.
 345 # Accepts arbitrary extra emacs/elisp functions to modify the message
 346 # before sending, which is useful to doing things like attaching files
 347 # to the message and encrypting/signing.
 348 emacs_deliver_message ()
 349 {
 350     local subject body smtp_dummy_pid smtp_dummy_port
 351     subject="$1"
 352     body="$2"
 353     shift 2
 354     # before we can send a message, we have to prepare the FCC maildir
 355     mkdir -p "$MAIL_DIR"/sent/{cur,new,tmp}
 356     # eval'ing smtp-dummy --background will set smtp_dummy_pid and -_port
 357     smtp_dummy_pid= smtp_dummy_port=
 358     eval `$TEST_DIRECTORY/smtp-dummy --background sent_message`
 359     test -n "$smtp_dummy_pid" || return 1
 360     test -n "$smtp_dummy_port" || return 1
 361
 362     test_emacs \
 363         "(let ((message-send-mail-function 'message-smtpmail-send-it)
 364                (mail-host-address \"example.com\")
 365                (smtpmail-smtp-server \"localhost\")
 366                (smtpmail-smtp-service \"${smtp_dummy_port}\"))
 367            (notmuch-mua-mail)
 368            (message-goto-to)
 369            (insert \"test_suite@notmuchmail.org\nDate: 01 Jan 2000 12:00:00 -0000\")
 370            (message-goto-subject)
 371            (insert \"${subject}\")
 372            (message-goto-body)
 373            (insert \"${body}\")
 374            $*
 375            (notmuch-mua-send-and-exit))"
 376
 377     # In case message was sent properly, client waits for confirmation
 378     # before exiting and resuming control here; therefore making sure
 379     # that server exits by sending (KILL) signal to it is safe.
 380     kill -9 $smtp_dummy_pid
 381     notmuch new >/dev/null
 382 }
 383
 384 # Pretend to deliver a message with emacs. Really save it to a file
 385 # and add it to the database
 386 #
 387 # Uses emacs to generate and deliver a message to the mail store.
 388 # Accepts arbitrary extra emacs/elisp functions to modify the message
 389 # before sending, which is useful to doing things like attaching files
 390 # to the message and encrypting/signing.
 391 #
 392 # If any GNU-style long-arguments (like --quiet or --decrypt=true) are
 393 # at the head of the argument list, they are sent directly to "notmuch
 394 # new" after message delivery
 395 emacs_fcc_message ()
 396 {
 397     local nmn_args subject body
 398     nmn_args=''
 399     while [[ "$1" =~ ^-- ]]; do
 400         nmn_args="$nmn_args $1"
 401         shift
 402     done
 403     subject="$1"
 404     body="$2"
 405     shift 2
 406     # before we can send a message, we have to prepare the FCC maildir
 407     mkdir -p "$MAIL_DIR"/sent/{cur,new,tmp}
 408
 409     test_emacs \
 410         "(let ((message-send-mail-function (lambda () t))
 411                (mail-host-address \"example.com\"))
 412            (notmuch-mua-mail)
 413            (message-goto-to)
 414            (insert \"test_suite@notmuchmail.org\nDate: 01 Jan 2000 12:00:00 -0000\")
 415            (message-goto-subject)
 416            (insert \"${subject}\")
 417            (message-goto-body)
 418            (insert \"${body}\")
 419            $*
 420            (let ((mml-secure-smime-sign-with-sender t)
 421                  (mml-secure-openpgp-sign-with-sender t))
 422              (notmuch-mua-send-and-exit)))" || return 1
 423     notmuch new $nmn_args >/dev/null
 424 }
 425
 426 # Add an existing, fixed corpus of email to the database.
 427 #
 428 # $1 is the corpus dir under corpora to add, using "default" if unset.
 429 #
 430 # The default corpus is based on about 50 messages from early in the
 431 # history of the notmuch mailing list, which allows for reliably
 432 # testing commands that need to operate on a not-totally-trivial
 433 # number of messages.
 434 add_email_corpus ()
 435 {
 436     local corpus
 437     corpus=${1:-default}
 438
 439     rm -rf ${MAIL_DIR}
 440     cp -a $NOTMUCH_SRCDIR/test/corpora/$corpus ${MAIL_DIR}
 441     notmuch new >/dev/null || die "'notmuch new' failed while adding email corpus"
 442 }
 443
 444 test_begin_subtest ()
 445 {
 446     if [ -n "$inside_subtest" ]; then
 447         exec 1>&6 2>&7          # Restore stdout and stderr
 448         error "bug in test script: Missing test_expect_equal in ${BASH_SOURCE[1]}:${BASH_LINENO[0]}"
 449     fi
 450     test_subtest_name="$1"
 451     test_reset_state_
 452     # Redirect test output to the previously prepared file descriptors
 453     # 3 and 4 (see below)
 454     if test "$verbose" != "t"; then exec 4>test.output 3>&4; fi
 455     exec >&3 2>&4
 456     inside_subtest=t
 457 }
 458
 459 # Pass test if two arguments match
 460 #
 461 # Note: Unlike all other test_expect_* functions, this function does
 462 # not accept a test name. Instead, the caller should call
 463 # test_begin_subtest before calling this function in order to set the
 464 # name.
 465 test_expect_equal ()
 466 {
 467         local output expected testname
 468         exec 1>&6 2>&7          # Restore stdout and stderr
 469         if [ -z "$inside_subtest" ]; then
 470                 error "bug in the test script: test_expect_equal without test_begin_subtest"
 471         fi
 472         inside_subtest=
 473         test "$#" = 2 ||
 474         error "bug in the test script: not 2 parameters to test_expect_equal"
 475
 476         output="$1"
 477         expected="$2"
 478         if ! test_skip "$test_subtest_name"
 479         then
 480                 if [ "$output" = "$expected" ]; then
 481                         test_ok_
 482                 else
 483                         testname=$this_test.$test_count
 484                         echo "$expected" > $testname.expected
 485                         echo "$output" > $testname.output
 486                         test_failure_ "$(diff -u $testname.expected $testname.output)"
 487                 fi
 488     fi
 489 }
 490
 491 # Like test_expect_equal, but takes two filenames.
 492 test_expect_equal_file ()
 493 {
 494         local file1 file2 testname basename1 basename2
 495         exec 1>&6 2>&7          # Restore stdout and stderr
 496         if [ -z "$inside_subtest" ]; then
 497                 error "bug in the test script: test_expect_equal_file without test_begin_subtest"
 498         fi
 499         inside_subtest=
 500         test "$#" = 2 ||
 501         error "bug in the test script: not 2 parameters to test_expect_equal_file"
 502
 503         file1="$1"
 504         file2="$2"
 505         if ! test_skip "$test_subtest_name"
 506         then
 507                 if diff -q "$file1" "$file2" >/dev/null ; then
 508                         test_ok_
 509                 else
 510                         testname=$this_test.$test_count
 511                         basename1=`basename "$file1"`
 512                         basename2=`basename "$file2"`
 513                         cp "$file1" "$testname.$basename1"
 514                         cp "$file2" "$testname.$basename2"
 515                         test_failure_ "$(diff -u "$testname.$basename1" "$testname.$basename2")"
 516                 fi
 517     fi
 518 }
 519
 520 # Like test_expect_equal, but arguments are JSON expressions to be
 521 # canonicalized before diff'ing.  If an argument cannot be parsed, it
 522 # is used unchanged so that there's something to diff against.
 523 test_expect_equal_json () {
 524     local script output expected
 525     # The test suite forces LC_ALL=C, but this causes Python 3 to
 526     # decode stdin as ASCII.  We need to read JSON in UTF-8, so
 527     # override Python's stdio encoding defaults.
 528     script='import json, sys; json.dump(json.load(sys.stdin), sys.stdout, sort_keys=True, indent=4)'
 529     output=$(echo "$1" | PYTHONIOENCODING=utf-8 $NOTMUCH_PYTHON -c "$script" \
 530         || echo "$1")
 531     expected=$(echo "$2" | PYTHONIOENCODING=utf-8 $NOTMUCH_PYTHON -c "$script" \
 532         || echo "$2")
 533     shift 2
 534     test_expect_equal "$output" "$expected" "$@"
 535 }
 536
 537 # Ensure that the argument is valid JSON data.
 538 test_valid_json () {
 539     PYTHONIOENCODING=utf-8 $NOTMUCH_PYTHON -c "import sys, json; json.load(sys.stdin)" <<<"$1"
 540     test_expect_equal "$?" 0
 541 }
 542
 543 # Sort the top-level list of JSON data from stdin.
 544 test_sort_json () {
 545     PYTHONIOENCODING=utf-8 $NOTMUCH_PYTHON -c \
 546         "import sys, json; json.dump(sorted(json.load(sys.stdin)),sys.stdout)"
 547 }
 548
 549 # test for json objects:
 550 # read the source of test/json_check_nodes.py (or the output when
 551 # invoking it without arguments) for an explanation of the syntax.
 552 test_json_nodes () {
 553         local output
 554         exec 1>&6 2>&7          # Restore stdout and stderr
 555         if [ -z "$inside_subtest" ]; then
 556                 error "bug in the test script: test_json_eval without test_begin_subtest"
 557         fi
 558         inside_subtest=
 559         test "$#" > 0 ||
 560             error "bug in the test script: test_json_nodes needs at least 1 parameter"
 561
 562         if ! test_skip "$test_subtest_name"
 563         then
 564             output=$(PYTHONIOENCODING=utf-8 $NOTMUCH_PYTHON -B "$NOTMUCH_SRCDIR"/test/json_check_nodes.py "$@")
 565                 if [ "$?" = 0 ]
 566                 then
 567                         test_ok_
 568                 else
 569                         test_failure_ "$output"
 570                 fi
 571         fi
 572 }
 573
 574 test_emacs_expect_t () {
 575         local result
 576         test "$#" = 1 ||
 577         error "bug in the test script: not 1 parameter to test_emacs_expect_t"
 578         if [ -z "$inside_subtest" ]; then
 579                 error "bug in the test script: test_emacs_expect_t without test_begin_subtest"
 580         fi
 581
 582         # Run the test.
 583         if ! test_skip "$test_subtest_name"
 584         then
 585                 test_emacs "(notmuch-test-run $1)" >/dev/null
 586
 587                 # Restore state after the test.
 588                 exec 1>&6 2>&7          # Restore stdout and stderr
 589                 inside_subtest=
 590
 591                 # Report success/failure.
 592                 result=$(cat OUTPUT)
 593                 if [ "$result" = t ]
 594                 then
 595                         test_ok_
 596                 else
 597                         test_failure_ "${result}"
 598                 fi
 599         else
 600                 # Restore state after the (non) test.
 601                 exec 1>&6 2>&7          # Restore stdout and stderr
 602                 inside_subtest=
 603         fi
 604 }
 605
 606 NOTMUCH_NEW ()
 607 {
 608     notmuch new "${@}" | grep -v -E -e '^Processed [0-9]*( total)? file|Found [0-9]* total file'
 609 }
 610
 611 NOTMUCH_DUMP_TAGS ()
 612 {
 613     # this relies on the default format being batch-tag, otherwise some tests will break
 614     notmuch dump --include=tags "${@}" | sed '/^#/d' | sort
 615 }
 616
 617 notmuch_drop_mail_headers ()
 618 {
 619     $NOTMUCH_PYTHON -c '
 620 import email, sys
 621 msg = email.message_from_file(sys.stdin)
 622 for hdr in sys.argv[1:]: del msg[hdr]
 623 print(msg.as_string(False))
 624 ' "$@"
 625 }
 626
 627 notmuch_exception_sanitize ()
 628 {
 629     perl -pe 's/(A Xapian exception occurred at .*[.]cc?):([0-9]*)/\1:XXX/'
 630 }
 631
 632 notmuch_search_sanitize ()
 633 {
 634     perl -pe 's/("?thread"?: ?)("?)................("?)/\1\2XXX\3/'
 635 }
 636
 637 notmuch_search_files_sanitize ()
 638 {
 639     notmuch_dir_sanitize
 640 }
 641
 642 notmuch_dir_sanitize ()
 643 {
 644     sed -e "s,$MAIL_DIR,MAIL_DIR," -e "s,${PWD},CWD,g" "$@"
 645 }
 646
 647 NOTMUCH_SHOW_FILENAME_SQUELCH='s,filename:.*/mail,filename:/XXX/mail,'
 648 notmuch_show_sanitize ()
 649 {
 650     sed -e "$NOTMUCH_SHOW_FILENAME_SQUELCH"
 651 }
 652 notmuch_show_sanitize_all ()
 653 {
 654     sed \
 655         -e 's| filename:.*| filename:XXXXX|' \
 656         -e 's| id:[^ ]* | id:XXXXX |' | \
 657         notmuch_date_sanitize
 658 }
 659
 660 notmuch_json_show_sanitize ()
 661 {
 662     sed \
 663         -e 's|"id": "[^"]*",|"id": "XXXXX",|g' \
 664         -e 's|"Date": "Fri, 05 Jan 2001 [^"]*0000"|"Date": "GENERATED_DATE"|g' \
 665         -e 's|"filename": "signature.asc",||g' \
 666         -e 's|"filename": \["/[^"]*"\],|"filename": \["YYYYY"\],|g' \
 667         -e 's|"timestamp": 97.......|"timestamp": 42|g' \
 668         -e 's|"content-length": [1-9][0-9]*|"content-length": "NONZERO"|g'
 669 }
 670
 671 notmuch_emacs_error_sanitize ()
 672 {
 673     local command
 674     command=$1
 675     shift
 676     for file in "$@"; do
 677         echo "=== $file ==="
 678         cat "$file"
 679     done | sed \
 680         -e 's/^\[.*\]$/[XXX]/' \
 681         -e "s|^\(command: \)\{0,1\}/.*/$command|\1YYY/$command|"
 682 }
 683
 684 notmuch_date_sanitize ()
 685 {
 686     sed \
 687         -e 's/^Date: Fri, 05 Jan 2001 .*0000/Date: GENERATED_DATE/'
 688 }
 689
 690 notmuch_uuid_sanitize ()
 691 {
 692     sed 's/[0-9a-f]\{8\}-[0-9a-f]\{4\}-[0-9a-f]\{4\}-[0-9a-f]\{4\}-[0-9a-f]\{12\}/UUID/g'
 693 }
 694
 695 notmuch_built_with_sanitize ()
 696 {
 697     sed 's/^built_with[.]\(.*\)=.*$/built_with.\1=something/'
 698 }
 699
 700 notmuch_passwd_sanitize ()
 701 {
 702     local user=$(id -un)
 703     local fqdn=$(hostname -f)
 704     local full_name=$(getent passwd $user | cut -d: -f 5 | cut -d, -f1)
 705     sed -e "s/$user/USERNAME/" -e "s/$fqdn/FQDN/" -e "s/$full_name/USER_FULL_NAME/"
 706 }
 707
 708 notmuch_config_sanitize ()
 709 {
 710     notmuch_dir_sanitize | notmuch_built_with_sanitize
 711 }
 712
 713 notmuch_show_part ()
 714 {
 715     awk '/^\014part}/{ f=0 }; { if (f) { print $0 } } /^\014part{ ID: '"$1"'/{ f=1 }'
 716 }
 717
 718 # End of notmuch helper functions
 719
 720 # Use test_set_prereq to tell that a particular prerequisite is available.
 721 #
 722 # The prerequisite can later be checked for by using test_have_prereq.
 723 #
 724 # The single parameter is the prerequisite tag (a simple word, in all
 725 # capital letters by convention).
 726
 727 test_set_prereq () {
 728         satisfied="$satisfied$1 "
 729 }
 730 satisfied=" "
 731
 732 test_have_prereq () {
 733         case $satisfied in
 734         *" $1 "*)
 735                 : yes, have it ;;
 736         *)
 737                 ! : nope ;;
 738         esac
 739 }
 740
 741 declare -A test_missing_external_prereq_
 742 declare -A test_subtest_missing_external_prereq_
 743
 744 # declare prerequisite for the given external binary
 745 test_declare_external_prereq () {
 746         local binary
 747         binary="$1"
 748         test "$#" = 2 && name=$2 || name="$binary(1)"
 749
 750         if ! hash $binary 2>/dev/null; then
 751                 test_missing_external_prereq_["${binary}"]=t
 752                 eval "
 753 $binary () {
 754         test_subtest_missing_external_prereq_[\"${name}\"]=t
 755         false
 756 }"
 757         fi
 758 }
 759
 760 # Explicitly require external prerequisite.  Useful when binary is
 761 # called indirectly (e.g. from emacs).
 762 # Returns success if dependency is available, failure otherwise.
 763 test_require_external_prereq () {
 764         local binary
 765         binary="$1"
 766         if [[ ${test_missing_external_prereq_["${binary}"]} == t ]]; then
 767                 # dependency is missing, call the replacement function to note it
 768                 eval "$binary"
 769         else
 770                 true
 771         fi
 772 }
 773
 774 # You are not expected to call test_ok_ and test_failure_ directly, use
 775 # the text_expect_* functions instead.
 776
 777 test_ok_ () {
 778         if test "$test_subtest_known_broken_" = "t"; then
 779                 test_known_broken_ok_
 780                 return
 781         fi
 782         test_success=$(($test_success + 1))
 783         if test -n "$NOTMUCH_TEST_QUIET"; then
 784                 return 0
 785         fi
 786         say_color pass "%-6s" "PASS"
 787         echo " $test_subtest_name"
 788 }
 789
 790 test_failure_ () {
 791         print_test_description
 792         if test "$test_subtest_known_broken_" = "t"; then
 793                 test_known_broken_failure_ "$@"
 794                 return
 795         fi
 796         test_failure=$(($test_failure + 1))
 797         test_failure_message_ "FAIL" "$test_subtest_name" "$@"
 798         test "$immediate" = "" || { GIT_EXIT_OK=t; exit 1; }
 799         return 1
 800 }
 801
 802 test_failure_message_ () {
 803         say_color error "%-6s" "$1"
 804         echo " $2"
 805         shift 2
 806         if [ "$#" != "0" ]; then
 807                 echo "$@" | sed -e 's/^/        /'
 808         fi
 809         if test "$verbose" != "t"; then cat test.output; fi
 810 }
 811
 812 test_known_broken_ok_ () {
 813         test_reset_state_
 814         test_fixed=$(($test_fixed+1))
 815         say_color pass "%-6s" "FIXED"
 816         echo " $test_subtest_name"
 817 }
 818
 819 test_known_broken_failure_ () {
 820         test_reset_state_
 821         test_broken=$(($test_broken+1))
 822         if [ -z "$NOTMUCH_TEST_QUIET" ]; then
 823                 test_failure_message_ "BROKEN" "$test_subtest_name" "$@"
 824         else
 825                 test_failure_message_ "BROKEN" "$test_subtest_name"
 826         fi
 827         return 1
 828 }
 829
 830 test_debug () {
 831         test "$debug" = "" || eval "$1"
 832 }
 833
 834 test_run_ () {
 835         test_cleanup=:
 836         if test "$verbose" != "t"; then exec 4>test.output 3>&4; fi
 837         eval >&3 2>&4 "$1"
 838         eval_ret=$?
 839         eval >&3 2>&4 "$test_cleanup"
 840         return 0
 841 }
 842
 843 test_skip () {
 844         test_count=$(($test_count+1))
 845         to_skip=
 846         for skp in $NOTMUCH_SKIP_TESTS
 847         do
 848                 case $this_test.$test_count in
 849                 $skp)
 850                         to_skip=t
 851                         break
 852                 esac
 853                 case $this_test_bare.$test_count in
 854                 $skp)
 855                         to_skip=t
 856                         break
 857                 esac
 858         done
 859         case "$to_skip" in
 860         t)
 861                 test_report_skip_ "$@"
 862                 ;;
 863         *)
 864                 test_check_missing_external_prereqs_ "$@"
 865                 ;;
 866         esac
 867 }
 868
 869 test_check_missing_external_prereqs_ () {
 870         if [[ ${#test_subtest_missing_external_prereq_[@]} != 0 ]]; then
 871                 say_color skip >&1 "missing prerequisites: "
 872                 echo ${!test_subtest_missing_external_prereq_[@]} >&1
 873                 test_report_skip_ "$@"
 874         else
 875                 false
 876         fi
 877 }
 878
 879 test_report_skip_ () {
 880         test_reset_state_
 881         say_color skip >&3 "skipping test:"
 882         echo " $@" >&3
 883         say_color skip "%-6s" "SKIP"
 884         echo " $1"
 885 }
 886
 887 test_subtest_known_broken () {
 888         test_subtest_known_broken_=t
 889 }
 890
 891 test_expect_success () {
 892         exec 1>&6 2>&7          # Restore stdout and stderr
 893         if [ -z "$inside_subtest" ]; then
 894                 error "bug in the test script: test_expect_success without test_begin_subtest"
 895         fi
 896         inside_subtest=
 897         test "$#" = 1 ||
 898         error "bug in the test script: not 1 parameters to test_expect_success"
 899
 900         if ! test_skip "$test_subtest_name"
 901         then
 902                 test_run_ "$1"
 903                 run_ret="$?"
 904                 # test_run_ may update missing external prerequisites
 905                 test_check_missing_external_prereqs_ "$@" ||
 906                 if [ "$run_ret" = 0 -a "$eval_ret" = 0 ]
 907                 then
 908                         test_ok_
 909                 else
 910                         test_failure_ "$1"
 911                 fi
 912         fi
 913 }
 914
 915 test_expect_code () {
 916         exec 1>&6 2>&7          # Restore stdout and stderr
 917         if [ -z "$inside_subtest" ]; then
 918                 error "bug in the test script: test_expect_code without test_begin_subtest"
 919         fi
 920         inside_subtest=
 921         test "$#" = 2 ||
 922         error "bug in the test script: not 2 parameters to test_expect_code"
 923
 924         if ! test_skip "$test_subtest_name"
 925         then
 926                 test_run_ "$2"
 927                 run_ret="$?"
 928                 # test_run_ may update missing external prerequisites,
 929                 test_check_missing_external_prereqs_ "$@" ||
 930                 if [ "$run_ret" = 0 -a "$eval_ret" = "$1" ]
 931                 then
 932                         test_ok_
 933                 else
 934                         test_failure_ "exit code $eval_ret, expected $1" "$2"
 935                 fi
 936         fi
 937 }
 938
 939 # This is not among top-level (test_expect_success)
 940 # but is a prefix that can be used in the test script, like:
 941 #
 942 #       test_expect_success 'complain and die' '
 943 #           do something &&
 944 #           do something else &&
 945 #           test_must_fail git checkout ../outerspace
 946 #       '
 947 #
 948 # Writing this as "! git checkout ../outerspace" is wrong, because
 949 # the failure could be due to a segv.  We want a controlled failure.
 950
 951 test_must_fail () {
 952         "$@"
 953         test $? -gt 0 -a $? -le 129 -o $? -gt 192
 954 }
 955
 956 # test_cmp is a helper function to compare actual and expected output.
 957 # You can use it like:
 958 #
 959 #       test_expect_success 'foo works' '
 960 #               echo expected >expected &&
 961 #               foo >actual &&
 962 #               test_cmp expected actual
 963 #       '
 964 #
 965 # This could be written as either "cmp" or "diff -u", but:
 966 # - cmp's output is not nearly as easy to read as diff -u
 967 # - not all diff versions understand "-u"
 968
 969 test_cmp() {
 970         $GIT_TEST_CMP "$@"
 971 }
 972
 973 # This function can be used to schedule some commands to be run
 974 # unconditionally at the end of the test to restore sanity:
 975 #
 976 #       test_expect_success 'test core.capslock' '
 977 #               git config core.capslock true &&
 978 #               test_when_finished "git config --unset core.capslock" &&
 979 #               hello world
 980 #       '
 981 #
 982 # That would be roughly equivalent to
 983 #
 984 #       test_expect_success 'test core.capslock' '
 985 #               git config core.capslock true &&
 986 #               hello world
 987 #               git config --unset core.capslock
 988 #       '
 989 #
 990 # except that the greeting and config --unset must both succeed for
 991 # the test to pass.
 992
 993 test_when_finished () {
 994         test_cleanup="{ $*
 995                 } && (exit \"\$eval_ret\"); eval_ret=\$?; $test_cleanup"
 996 }
 997
 998 test_done () {
 999         GIT_EXIT_OK=t
1000         test_results_dir="$TEST_DIRECTORY/test-results"
1001         mkdir -p "$test_results_dir"
1002         test_results_path="$test_results_dir/$this_test"
1003
1004         echo "total $test_count" >> $test_results_path
1005         echo "success $test_success" >> $test_results_path
1006         echo "fixed $test_fixed" >> $test_results_path
1007         echo "broken $test_broken" >> $test_results_path
1008         echo "failed $test_failure" >> $test_results_path
1009         echo "" >> $test_results_path
1010
1011         [ -n "$EMACS_SERVER" ] && test_emacs '(kill-emacs)'
1012
1013         if [ "$test_failure" = "0" ]; then
1014             if [ "$test_broken" = "0" ]; then
1015                 rm -rf "$remove_tmp"
1016             fi
1017             exit 0
1018         else
1019             exit 1
1020         fi
1021 }
1022
1023 emacs_generate_script () {
1024         # Construct a little test script here for the benefit of the user,
1025         # (who can easily run "run_emacs" to get the same emacs environment
1026         # for investigating any failures).
1027         cat <<EOF >"$TMP_DIRECTORY/run_emacs"
1028 #!/bin/sh
1029 export PATH=$PATH
1030 export NOTMUCH_CONFIG=$NOTMUCH_CONFIG
1031
1032 # Here's what we are using here:
1033 #
1034 # --quick               Use minimal customization. This implies --no-init-file,
1035 #                       --no-site-file and (emacs 24) --no-site-lisp
1036 #
1037 # --directory           Ensure that the local elisp sources are found
1038 #
1039 # --load                Force loading of notmuch.el and test-lib.el
1040
1041 exec ${TEST_EMACS} --quick \
1042         --directory "$NOTMUCH_BUILDDIR/emacs" --load notmuch.el \
1043         --directory "$NOTMUCH_SRCDIR/test" --load test-lib.el \
1044         "\$@"
1045 EOF
1046         chmod a+x "$TMP_DIRECTORY/run_emacs"
1047 }
1048
1049 test_emacs () {
1050         # test dependencies beforehand to avoid the waiting loop below
1051         missing_dependencies=
1052         test_require_external_prereq dtach || missing_dependencies=1
1053         test_require_external_prereq emacs || missing_dependencies=1
1054         test_require_external_prereq ${TEST_EMACSCLIENT} || missing_dependencies=1
1055         test -z "$missing_dependencies" || return
1056
1057         if [ -z "$EMACS_SERVER" ]; then
1058                 emacs_tests="$NOTMUCH_SRCDIR/test/${this_test_bare}.el"
1059                 if [ -f "$emacs_tests" ]; then
1060                         load_emacs_tests="--eval '(load \"$emacs_tests\")'"
1061                 else
1062                         load_emacs_tests=
1063                 fi
1064                 server_name="notmuch-test-suite-$$"
1065                 # start a detached session with an emacs server
1066                 # user's TERM (or 'vt100' in case user's TERM is known dumb
1067                 # or unknown) is given to dtach which assumes a minimally
1068                 # VT100-compatible terminal -- and emacs inherits that
1069                 TERM=$SMART_TERM dtach -n "$TEST_TMPDIR/emacs-dtach-socket.$$" \
1070                         sh -c "stty rows 24 cols 80; exec '$TMP_DIRECTORY/run_emacs' \
1071                                 --no-window-system \
1072                                 $load_emacs_tests \
1073                                 --eval '(setq server-name \"$server_name\")' \
1074                                 --eval '(server-start)' \
1075                                 --eval '(orphan-watchdog $$)'" || return
1076                 EMACS_SERVER="$server_name"
1077                 # wait until the emacs server is up
1078                 until test_emacs '()' >/dev/null 2>/dev/null; do
1079                         sleep 1
1080                 done
1081         fi
1082
1083         # Clear test-output output file.  Most Emacs tests end with a
1084         # call to (test-output).  If the test code fails with an
1085         # exception before this call, the output file won't get
1086         # updated.  Since we don't want to compare against an output
1087         # file from another test, so start out with an empty file.
1088         rm -f OUTPUT
1089         touch OUTPUT
1090
1091         ${TEST_EMACSCLIENT} --socket-name="$EMACS_SERVER" --eval "(notmuch-test-progn $*)"
1092 }
1093
1094 test_python() {
1095     # Note: if there is need to print debug information from python program,
1096     # use stdout = os.fdopen(6, 'w') or stderr = os.fdopen(7, 'w')
1097     PYTHONPATH="$NOTMUCH_SRCDIR/bindings/python${PYTHONPATH:+:$PYTHONPATH}" \
1098         $NOTMUCH_PYTHON -B - > OUTPUT
1099 }
1100
1101 test_ruby() {
1102     MAIL_DIR=$MAIL_DIR $NOTMUCH_RUBY -I "$NOTMUCH_BUILDDIR/bindings/ruby"> OUTPUT
1103 }
1104
1105 test_C () {
1106     local exec_file test_file
1107     exec_file="test${test_count}"
1108     test_file="${exec_file}.c"
1109     cat > ${test_file}
1110     ${TEST_CC} ${TEST_CFLAGS} -I${NOTMUCH_SRCDIR}/test -I${NOTMUCH_SRCDIR}/lib -o ${exec_file} ${test_file} -L${NOTMUCH_BUILDDIR}/lib/ -lnotmuch -ltalloc
1111     echo "== stdout ==" > OUTPUT.stdout
1112     echo "== stderr ==" > OUTPUT.stderr
1113     ./${exec_file} "$@" 1>>OUTPUT.stdout 2>>OUTPUT.stderr
1114     notmuch_dir_sanitize OUTPUT.stdout OUTPUT.stderr | notmuch_exception_sanitize > OUTPUT
1115 }
1116
1117 make_shim () {
1118     local base_name test_file shim_file
1119     base_name="$1"
1120     test_file="${base_name}.c"
1121     shim_file="${base_name}.so"
1122     cat > ${test_file}
1123     ${TEST_CC} ${TEST_CFLAGS} ${TEST_SHIM_CFLAGS} -I${NOTMUCH_SRCDIR}/test -I${NOTMUCH_SRCDIR}/lib -o ${shim_file} ${test_file} ${TEST_SHIM_LDFLAGS}
1124 }
1125
1126 notmuch_with_shim () {
1127     local base_name shim_file
1128     base_name="$1"
1129     shift
1130     shim_file="${base_name}.so"
1131     LD_PRELOAD=${LD_PRELOAD:+:$LD_PRELOAD}:./${shim_file} notmuch-shared "$@"
1132 }
1133
1134 # Creates a script that counts how much time it is executed and calls
1135 # notmuch.  $notmuch_counter_command is set to the path to the
1136 # generated script.  Use notmuch_counter_value() function to get the
1137 # current counter value.
1138 notmuch_counter_reset () {
1139         notmuch_counter_command="$TMP_DIRECTORY/notmuch_counter"
1140         if [ ! -x "$notmuch_counter_command" ]; then
1141                 notmuch_counter_state_path="$TMP_DIRECTORY/notmuch_counter.state"
1142                 cat >"$notmuch_counter_command" <<EOF || return
1143 #!/bin/sh
1144
1145 read count < "$notmuch_counter_state_path"
1146 echo \$((count + 1)) > "$notmuch_counter_state_path"
1147
1148 exec notmuch "\$@"
1149 EOF
1150                 chmod +x "$notmuch_counter_command" || return
1151         fi
1152
1153         echo 0 > "$notmuch_counter_state_path"
1154 }
1155
1156 # Returns the current notmuch counter value.
1157 notmuch_counter_value () {
1158         if [ -r "$notmuch_counter_state_path" ]; then
1159                 read count < "$notmuch_counter_state_path"
1160         else
1161                 count=0
1162         fi
1163         echo $count
1164 }
1165
1166 test_reset_state_ () {
1167         test -z "$test_init_done_" && test_init_
1168
1169         test_subtest_known_broken_=
1170         test_subtest_missing_external_prereq_=()
1171 }
1172
1173 # called once before the first subtest
1174 test_init_ () {
1175         test_init_done_=t
1176
1177         # skip all tests if there were external prerequisites missing during init
1178         test_check_missing_external_prereqs_ "all tests in $this_test" && test_done
1179 }
1180
1181
1182 # Where to run the tests
1183 TEST_DIRECTORY=$NOTMUCH_BUILDDIR/test
1184
1185 . "$NOTMUCH_SRCDIR/test/test-lib-common.sh" || exit 1
1186
1187 emacs_generate_script
1188
1189
1190 # Use -P to resolve symlinks in our working directory so that the cwd
1191 # in subprocesses like git equals our $PWD (for pathname comparisons).
1192 cd -P "$TMP_DIRECTORY" || error "Cannot set up test environment"
1193
1194 if test "$verbose" = "t"
1195 then
1196         exec 4>&2 3>&1
1197 else
1198         exec 4>test.output 3>&4
1199 fi
1200
1201 for skp in $NOTMUCH_SKIP_TESTS
1202 do
1203         to_skip=
1204         for skp in $NOTMUCH_SKIP_TESTS
1205         do
1206                 case "$this_test" in
1207                 $skp)
1208                         to_skip=t
1209                         break
1210                 esac
1211                 case "$this_test_bare" in
1212                 $skp)
1213                         to_skip=t
1214                         break
1215                 esac
1216         done
1217         case "$to_skip" in
1218         t)
1219                 say_color skip >&3 "skipping test $this_test altogether"
1220                 say_color skip "skip all tests in $this_test"
1221                 test_done
1222         esac
1223 done
1224
1225 # Provide an implementation of the 'yes' utility
1226 yes () {
1227         if test $# = 0
1228         then
1229                 y=y
1230         else
1231                 y="$*"
1232         fi
1233
1234         while echo "$y"
1235         do
1236                 :
1237         done
1238 }
1239
1240 # Fix some commands on Windows
1241 case $(uname -s) in
1242 *MINGW*)
1243         # Windows has its own (incompatible) sort and find
1244         sort () {
1245                 /usr/bin/sort "$@"
1246         }
1247         find () {
1248                 /usr/bin/find "$@"
1249         }
1250         sum () {
1251                 md5sum "$@"
1252         }
1253         # git sees Windows-style pwd
1254         pwd () {
1255                 builtin pwd -W
1256         }
1257         # no POSIX permissions
1258         # backslashes in pathspec are converted to '/'
1259         # exec does not inherit the PID
1260         ;;
1261 *)
1262         test_set_prereq POSIXPERM
1263         test_set_prereq BSLASHPSPEC
1264         test_set_prereq EXECKEEPSPID
1265         ;;
1266 esac
1267
1268 test -z "$NO_PERL" && test_set_prereq PERL
1269 test -z "$NO_PYTHON" && test_set_prereq PYTHON
1270
1271 # test whether the filesystem supports symbolic links
1272 ln -s x y 2>/dev/null && test -h y 2>/dev/null && test_set_prereq SYMLINKS
1273 rm -f y
1274
1275 # declare prerequisites for external binaries used in tests
1276 test_declare_external_prereq dtach
1277 test_declare_external_prereq emacs
1278 test_declare_external_prereq ${TEST_EMACSCLIENT}
1279 test_declare_external_prereq ${TEST_GDB}
1280 test_declare_external_prereq gpg
1281 test_declare_external_prereq openssl
1282 test_declare_external_prereq gpgsm
1283 test_declare_external_prereq ${NOTMUCH_PYTHON}
1284 test_declare_external_prereq xapian-metadata
1285 test_declare_external_prereq xapian-delve