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