From 760c644a1d9f55c91b74521b112958966e00ea31 Mon Sep 17 00:00:00 2001 From: "Jason A. Donenfeld" Date: Tue, 22 Apr 2014 18:35:11 +0200 Subject: Import Von's tests, with cleanups. --- tests/README | 11 + tests/TODO.txt | 30 ++ tests/aggregate-results.sh | 57 +++ tests/fake-editor-change-password.sh | 25 ++ tests/gnupg/pubring.gpg | Bin 0 -> 1183 bytes tests/gnupg/random_seed | Bin 0 -> 600 bytes tests/gnupg/secring.gpg | Bin 0 -> 2485 bytes tests/gnupg/trustdb.gpg | Bin 0 -> 1280 bytes tests/setup.sh | 169 +++++++++ tests/sharness.sh | 711 +++++++++++++++++++++++++++++++++++ tests/t0001-sanity-checks.sh | 16 + tests/t0005-init-failing.sh | 11 + tests/t0010-generate-tests.sh | 16 + tests/t0020-show-tests.sh | 18 + tests/t0050-mv-tests.sh | 18 + tests/t0060-rm-tests.sh | 20 + tests/t0100-insert-tests.sh | 15 + tests/t0200-edit-tests.sh | 17 + 18 files changed, 1134 insertions(+) create mode 100644 tests/README create mode 100644 tests/TODO.txt create mode 100755 tests/aggregate-results.sh create mode 100755 tests/fake-editor-change-password.sh create mode 100644 tests/gnupg/pubring.gpg create mode 100644 tests/gnupg/random_seed create mode 100644 tests/gnupg/secring.gpg create mode 100644 tests/gnupg/trustdb.gpg create mode 100755 tests/setup.sh create mode 100644 tests/sharness.sh create mode 100755 tests/t0001-sanity-checks.sh create mode 100755 tests/t0005-init-failing.sh create mode 100755 tests/t0010-generate-tests.sh create mode 100755 tests/t0020-show-tests.sh create mode 100755 tests/t0050-mv-tests.sh create mode 100755 tests/t0060-rm-tests.sh create mode 100755 tests/t0100-insert-tests.sh create mode 100755 tests/t0200-edit-tests.sh (limited to 'tests') diff --git a/tests/README b/tests/README new file mode 100644 index 0000000..970af69 --- /dev/null +++ b/tests/README @@ -0,0 +1,11 @@ +password-store Test Suite +========================= + +Uses : + * sharness.sh + * aggregate-results.sh + +To run all tests, run 'make test' from the parent directory. + +To debug an individual test, run it directly with '-v', e.g.: + $ ./t0001-sanity-checks.sh -v diff --git a/tests/TODO.txt b/tests/TODO.txt new file mode 100644 index 0000000..6610044 --- /dev/null +++ b/tests/TODO.txt @@ -0,0 +1,30 @@ +Harness: + + * Generate new gpg key programatically + + +Tests to add: + + * pass mv [directory to file] + * pass mv [file to directory] + * pass mv [file to file] + * pass mv [directory to directory] + * pass mv [X to new directory (by having the argument end in "/")] + * pass mv [X to existing directory] + * pass cp [all the above] + * pass [all the above, but reencrypting when source and destination have different .gpg-id settings] + * pass init [reencryption with different key] + * pass grep + * pass find + * pass rm + * pass init -p [plus reencryption with different key] + * pass insert, pass ls + * pass insert, pass show + * pass insert [with -e, with -m, without either] + * pass insert, cp, mv, rm, generate [with -f, without -f, on existing] + * pass generate [with -n vs without -n] + * pass edit [using shm vs not using shm] + * pass git init + * git operations on all commands + * Are empty folders pruned for rm, cp, mv, init (when "" is the argument) [with git, and without git] + * Are git commits happening as planned? Are they being signed when signing is enabled? diff --git a/tests/aggregate-results.sh b/tests/aggregate-results.sh new file mode 100755 index 0000000..958cbea --- /dev/null +++ b/tests/aggregate-results.sh @@ -0,0 +1,57 @@ +#!/bin/sh +# +# Copyright (c) 2008-2012 Git project +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see http://www.gnu.org/licenses/ . + +failed_tests= +fixed=0 +success=0 +failed=0 +broken=0 +total=0 + +while read file; do + while read type value; do + case $type in + '') + continue ;; + fixed) + fixed=$(($fixed + $value)) ;; + success) + success=$(($success + $value)) ;; + failed) + failed=$(($failed + $value)) + if test $value != 0; then + test_name=$(expr "$file" : 'test-results/\(.*\)\.[0-9]*\.counts') + failed_tests="$failed_tests $test_name" + fi + ;; + broken) + broken=$(($broken + $value)) ;; + total) + total=$(($total + $value)) ;; + esac + done <"$file" +done + +if test -n "$failed_tests"; then + printf "\nfailed test(s):$failed_tests\n\n" +fi + +printf "%-8s%d\n" fixed $fixed +printf "%-8s%d\n" success $success +printf "%-8s%d\n" failed $failed +printf "%-8s%d\n" broken $broken +printf "%-8s%d\n" total $total diff --git a/tests/fake-editor-change-password.sh b/tests/fake-editor-change-password.sh new file mode 100755 index 0000000..bfae8e1 --- /dev/null +++ b/tests/fake-editor-change-password.sh @@ -0,0 +1,25 @@ +#!/bin/sh +# Fake editor program for testing 'pass edit'. +# Changes password to 'Hello World', leaving rest of file intact. +# +# Intended use: +# export FAKE_EDITOR_PASSWORD="blah blah blah" +# export EDITOR=fake-editor-change-password.sh +# $EDITOR +# +# Arguments: +# Returns: 0 on success, 1 on error + +if [[ $# -ne 1 ]]; then + echo "Usage: $0 " + exit 1 +fi + +filename=$1 ; shift ; +new_password="${FAKE_EDITOR_PASSWORD:-Hello World}" + +# And change only first line of file +# -i.tmp allows editing file in place. Extension needed on Mac OSX +sed -i.tmp "1 s/^.*$/$new_password/g" "$filename" + +exit 0 diff --git a/tests/gnupg/pubring.gpg b/tests/gnupg/pubring.gpg new file mode 100644 index 0000000..23345ec Binary files /dev/null and b/tests/gnupg/pubring.gpg differ diff --git a/tests/gnupg/random_seed b/tests/gnupg/random_seed new file mode 100644 index 0000000..8e02108 Binary files /dev/null and b/tests/gnupg/random_seed differ diff --git a/tests/gnupg/secring.gpg b/tests/gnupg/secring.gpg new file mode 100644 index 0000000..985744c Binary files /dev/null and b/tests/gnupg/secring.gpg differ diff --git a/tests/gnupg/trustdb.gpg b/tests/gnupg/trustdb.gpg new file mode 100644 index 0000000..8c259d3 Binary files /dev/null and b/tests/gnupg/trustdb.gpg differ diff --git a/tests/setup.sh b/tests/setup.sh new file mode 100755 index 0000000..88f8aa5 --- /dev/null +++ b/tests/setup.sh @@ -0,0 +1,169 @@ +# This file should be sourced by all test-scripts +# +# This scripts sets the following: +# ${GNUPGHOME} Full path to test GPG directory +# ${PASS} Full path to password-store script to test +# ${PASSWORD_STORE_KEY} GPG key id of testing key +# ${PASSWORD_STORE_TEST_HOME} This folder + +# +# Constants + +PASSWORD_STORE_TEST_HOME="$(cd "$(dirname "$BASH_SOURCE")"; pwd)" + +# +# Find the pass script + +PASS="${PASSWORD_STORE_TEST_HOME}/../src/password-store.sh" + +if test -e ${PASS} ; then + echo "pass is ${PASS}" +else + echo "Could not find password-store.sh" + exit 1 +fi + +# +# GnuPG configuration + +# Where the test keyring and test key id +# Note: the assumption is the test key is unencrypted. +export GNUPGHOME=$(pwd)"/gnupg/" +chmod 700 "$GNUPGHOME" +export PASSWORD_STORE_KEY=3DEEA12D # "Password-store Test Key" + +# pass_init() +# +# Initialize a password store, setting PASSWORD_STORE_DIR +# +# Arguments: None +# Returns: Nothing, sets PASSWORD_STORE_DIR +pass_init() { + export PASSWORD_STORE_DIR="${SHARNESS_TRASH_DIRECTORY}/test-store/" + echo "Initializing test password store (${PASSWORD_STORE_DIR}) with key ${PASSWORD_STORE_KEY}" + + if [[ -d "${PASSWORD_STORE_DIR}" ]] ; then + echo "Removing old store" + rm -rf "${PASSWORD_STORE_DIR}" + if [[ -d "${PASSWORD_STORE_DIR}" ]] ; then + echo "Removal failed." + return 1 + fi + fi + + # This curently returns non-zero for unknown reasons. + # Only happens with stdin set to /dev/null. + # I suspect the agent check. + # TODO: Once fixed, catch non-zero here and fail. + ${PASS} init ${PASSWORD_STORE_KEY} || true + + echo "Initialization of ${PASSWORD_STORE_DIR} complete." +} + +# check_cred() +# +# Check to make sure the given credential looks valid. +# Meaning it exists and has at least one line. +# +# Arguments: +# Returns: 0 if valid looking, 1 otherwise +check_cred() { + if [[ "$#" -ne 1 ]]; then + echo "$0: Bad arguments" + return 1 + fi + local cred="$1" + shift + echo "Checking credential ${cred}" + if ! ${PASS} show "$cred"; then + echo "Credential ${cred} does not exist" + return 1 + fi + if [[ -z "$(${PASS} show "$cred")" ]]; then + echo "Credential ${cred} empty" + return 1 + fi +} + +# check_no_cred() +# +# Check to make sure the given credential does not exist. +# Use to validate removal, moving, etc. +# +# Arguments: +# Returns: 0 if credential does not exist, 1 otherwise +check_no_cred() { + if [[ "$#" -ne 1 ]]; then + echo "$0: Bad arguments" + return 1 + fi + local cred="$1" + shift + echo "Checking for lack of credential ${cred}" + ${PASS} show "$cred" || return 0 + echo "Credential ${cred} exists." + return 1 +} + +# create_cred() +# +# Create a credential with the given name and, optionally, password. +# Credential must not already exist. +# +# Arguments: [] +# Returns: 0 on success, 1 otherwise. +create_cred() { + if ! [[ "$#" -gt 0 && "$#" -lt 3 ]]; then + echo "$0: Bad arguments" + return 1 + fi + local cred="$1" + shift + echo "Creating credential ${cred}" + if ! check_no_cred "$cred"; then + echo "Credential already exists" + return 1 + fi + if [[ "$#" -eq 1 ]]; then + local password="$1" + shift + echo "Using password \"$password\" for $cred" + # TODO: Working around bug with 'pass insert' returning non-zero. + # Fix this code to exit on error when that is fixed. + ${PASS} insert -e "$cred" <<<"$password" || true + else + echo "Generating random password for $cred" + if ! ${PASS} generate "${cred}" 24 > /dev/null; then + echo "Failed to create credential ${cred}" + return 1 + fi + fi + return 0 +} + +# verify_password() +# +# Verify a given credential exists and has the given password. +# +# Arguments: +# Returns: 0 on success, 1 otherwise. +verify_password() { + if [[ "$#" -ne 2 ]]; then + echo "$0: Bad arguments" + return 1 + fi + local cred="$1" + shift + local expected="$1" + shift + echo "Verifing credential ${cred} has password \"${expected}\"" + check_cred "$cred" || return 1 + local actualfile="${SHARNESS_TRASH_DIRECTORY}/verify-password-actual.$RANDOM.$RANDOM.$RANDOM.$RANDOM" + local expectedfile="${SHARNESS_TRASH_DIRECTORY}/verify-password-expected.$RANDOM.$RANDOM.$RANDOM.$RANDOM" + ${PASS} show "$TEST_CRED" | sed -n 1p > "$actualfile" && + echo "$expected" > "$expectedfile" && + test_cmp "$expectedfile" "$actualfile" +} + +# Initialize the test harness +. ./sharness.sh diff --git a/tests/sharness.sh b/tests/sharness.sh new file mode 100644 index 0000000..7395be4 --- /dev/null +++ b/tests/sharness.sh @@ -0,0 +1,711 @@ +#!/bin/sh +# +# Copyright (c) 2011-2012 Mathias Lafeldt +# Copyright (c) 2005-2012 Git project +# Copyright (c) 2005-2012 Junio C Hamano +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see http://www.gnu.org/licenses/ . + +# Public: Current version of Sharness. +SHARNESS_VERSION="0.3.0" +export SHARNESS_VERSION + +# Public: The file extension for tests. By default, it is set to "t". +: ${SHARNESS_TEST_EXTENSION:=t} +export SHARNESS_TEST_EXTENSION + +# Keep the original TERM for say_color +ORIGINAL_TERM=$TERM + +# For repeatability, reset the environment to a known state. +LANG=C +LC_ALL=C +PAGER=cat +TZ=UTC +TERM=dumb +EDITOR=: +export LANG LC_ALL PAGER TZ TERM EDITOR +unset VISUAL CDPATH GREP_OPTIONS + +# Line feed +LF=' +' + +[ "x$ORIGINAL_TERM" != "xdumb" ] && ( + TERM=$ORIGINAL_TERM && + export TERM && + [ -t 1 ] && + tput bold >/dev/null 2>&1 && + tput setaf 1 >/dev/null 2>&1 && + tput sgr0 >/dev/null 2>&1 + ) && + color=t + +while test "$#" -ne 0; do + case "$1" in + -d|--d|--de|--deb|--debu|--debug) + debug=t; shift ;; + -i|--i|--im|--imm|--imme|--immed|--immedi|--immedia|--immediat|--immediate) + immediate=t; shift ;; + -l|--l|--lo|--lon|--long|--long-|--long-t|--long-te|--long-tes|--long-test|--long-tests) + TEST_LONG=t; export TEST_LONG; shift ;; + -h|--h|--he|--hel|--help) + help=t; shift ;; + -v|--v|--ve|--ver|--verb|--verbo|--verbos|--verbose) + verbose=t; shift ;; + -q|--q|--qu|--qui|--quie|--quiet) + # Ignore --quiet under a TAP::Harness. Saying how many tests + # passed without the ok/not ok details is always an error. + test -z "$HARNESS_ACTIVE" && quiet=t; shift ;; + --no-color) + color=; shift ;; + --root=*) + root=$(expr "z$1" : 'z[^=]*=\(.*\)') + shift ;; + *) + echo "error: unknown test option '$1'" >&2; exit 1 ;; + esac +done + +if test -n "$color"; then + say_color() { + ( + TERM=$ORIGINAL_TERM + export TERM + case "$1" in + error) + tput bold; tput setaf 1;; # bold red + skip) + tput setaf 4;; # blue + warn) + tput setaf 3;; # brown/yellow + pass) + tput setaf 2;; # green + info) + tput setaf 6;; # cyan + *) + test -n "$quiet" && return;; + esac + shift + printf "%s" "$*" + tput sgr0 + echo + ) + } +else + say_color() { + test -z "$1" && test -n "$quiet" && return + shift + printf "%s\n" "$*" + } +fi + +error() { + say_color error "error: $*" + EXIT_OK=t + exit 1 +} + +say() { + say_color info "$*" +} + +test -n "$test_description" || error "Test script did not set test_description." + +if test "$help" = "t"; then + echo "$test_description" + exit 0 +fi + +exec 5>&1 +exec 6<&0 +if test "$verbose" = "t"; then + exec 4>&2 3>&1 +else + exec 4>/dev/null 3>/dev/null +fi + +test_failure=0 +test_count=0 +test_fixed=0 +test_broken=0 +test_success=0 + +die() { + code=$? + if test -n "$EXIT_OK"; then + exit $code + else + echo >&5 "FATAL: Unexpected exit with code $code" + exit 1 + fi +} + +EXIT_OK= +trap 'die' EXIT + +# Public: Define that a test prerequisite is available. +# +# The prerequisite can later be checked explicitly using test_have_prereq or +# implicitly by specifying the prerequisite name in calls to test_expect_success +# or test_expect_failure. +# +# $1 - Name of prerequiste (a simple word, in all capital letters by convention) +# +# Examples +# +# # Set PYTHON prerequisite if interpreter is available. +# command -v python >/dev/null && test_set_prereq PYTHON +# +# # Set prerequisite depending on some variable. +# test -z "$NO_GETTEXT" && test_set_prereq GETTEXT +# +# Returns nothing. +test_set_prereq() { + satisfied_prereq="$satisfied_prereq$1 " +} +satisfied_prereq=" " + +# Public: Check if one or more test prerequisites are defined. +# +# The prerequisites must have previously been set with test_set_prereq. +# The most common use of this is to skip all the tests if some essential +# prerequisite is missing. +# +# $1 - Comma-separated list of test prerequisites. +# +# Examples +# +# # Skip all remaining tests if prerequisite is not set. +# if ! test_have_prereq PERL; then +# skip_all='skipping perl interface tests, perl not available' +# test_done +# fi +# +# Returns 0 if all prerequisites are defined or 1 otherwise. +test_have_prereq() { + # prerequisites can be concatenated with ',' + save_IFS=$IFS + IFS=, + set -- $* + IFS=$save_IFS + + total_prereq=0 + ok_prereq=0 + missing_prereq= + + for prerequisite; do + case "$prerequisite" in + !*) + negative_prereq=t + prerequisite=${prerequisite#!} + ;; + *) + negative_prereq= + esac + + total_prereq=$(($total_prereq + 1)) + case "$satisfied_prereq" in + *" $prerequisite "*) + satisfied_this_prereq=t + ;; + *) + satisfied_this_prereq= + esac + + case "$satisfied_this_prereq,$negative_prereq" in + t,|,t) + ok_prereq=$(($ok_prereq + 1)) + ;; + *) + # Keep a list of missing prerequisites; restore + # the negative marker if necessary. + prerequisite=${negative_prereq:+!}$prerequisite + if test -z "$missing_prereq"; then + missing_prereq=$prerequisite + else + missing_prereq="$prerequisite,$missing_prereq" + fi + esac + done + + test $total_prereq = $ok_prereq +} + +# You are not expected to call test_ok_ and test_failure_ directly, use +# the text_expect_* functions instead. + +test_ok_() { + test_success=$(($test_success + 1)) + say_color "" "ok $test_count - $@" +} + +test_failure_() { + test_failure=$(($test_failure + 1)) + say_color error "not ok $test_count - $1" + shift + echo "$@" | sed -e 's/^/# /' + test "$immediate" = "" || { EXIT_OK=t; exit 1; } +} + +test_known_broken_ok_() { + test_fixed=$(($test_fixed + 1)) + say_color error "ok $test_count - $@ # TODO known breakage vanished" +} + +test_known_broken_failure_() { + test_broken=$(($test_broken + 1)) + say_color warn "not ok $test_count - $@ # TODO known breakage" +} + +# Public: Execute commands in debug mode. +# +# Takes a single argument and evaluates it only when the test script is started +# with --debug. This is primarily meant for use during the development of test +# scripts. +# +# $1 - Commands to be executed. +# +# Examples +# +# test_debug "cat some_log_file" +# +# Returns the exit code of the last command executed in debug mode or 0 +# otherwise. +test_debug() { + test "$debug" = "" || eval "$1" +} + +test_eval_() { + # This is a separate function because some tests use + # "return" to end a test_expect_success block early. + eval &3 2>&4 "$*" +} + +test_run_() { + test_cleanup=: + expecting_failure=$2 + test_eval_ "$1" + eval_ret=$? + + if test -z "$immediate" || test $eval_ret = 0 || test -n "$expecting_failure"; then + test_eval_ "$test_cleanup" + fi + if test "$verbose" = "t" && test -n "$HARNESS_ACTIVE"; then + echo "" + fi + return "$eval_ret" +} + +test_skip_() { + test_count=$(($test_count + 1)) + to_skip= + for skp in $SKIP_TESTS; do + case $this_test.$test_count in + $skp) + to_skip=t + break + esac + done + if test -z "$to_skip" && test -n "$test_prereq" && ! test_have_prereq "$test_prereq"; then + to_skip=t + fi + case "$to_skip" in + t) + of_prereq= + if test "$missing_prereq" != "$test_prereq"; then + of_prereq=" of $test_prereq" + fi + + say_color skip >&3 "skipping test: $@" + say_color skip "ok $test_count # skip $1 (missing $missing_prereq${of_prereq})" + : true + ;; + *) + false + ;; + esac +} + +# Public: Run test commands and expect them to succeed. +# +# When the test passed, an "ok" message is printed and the number of successful +# tests is incremented. When it failed, a "not ok" message is printed and the +# number of failed tests is incremented. +# +# With --immediate, exit test immediately upon the first failed test. +# +# Usually takes two arguments: +# $1 - Test description +# $2 - Commands to be executed. +# +# With three arguments, the first will be taken to be a prerequisite: +# $1 - Comma-separated list of test prerequisites. The test will be skipped if +# not all of the given prerequisites are set. To negate a prerequisite, +# put a "!" in front of it. +# $2 - Test description +# $3 - Commands to be executed. +# +# Examples +# +# test_expect_success \ +# 'git-write-tree should be able to write an empty tree.' \ +# 'tree=$(git-write-tree)' +# +# # Test depending on one prerequisite. +# test_expect_success TTY 'git --paginate rev-list uses a pager' \ +# ' ... ' +# +# # Multiple prerequisites are separated by a comma. +# test_expect_success PERL,PYTHON 'yo dawg' \ +# ' test $(perl -E 'print eval "1 +" . qx[python -c "print 2"]') == "4" ' +# +# Returns nothing. +test_expect_success() { + test "$#" = 3 && { test_prereq=$1; shift; } || test_prereq= + test "$#" = 2 || error "bug in the test script: not 2 or 3 parameters to test_expect_success" + export test_prereq + if ! test_skip_ "$@"; then + say >&3 "expecting success: $2" + if test_run_ "$2"; then + test_ok_ "$1" + else + test_failure_ "$@" + fi + fi + echo >&3 "" +} + +# Public: Run test commands and expect them to fail. Used to demonstrate a known +# breakage. +# +# This is NOT the opposite of test_expect_success, but rather used to mark a +# test that demonstrates a known breakage. +# +# When the test passed, an "ok" message is printed and the number of fixed tests +# is incremented. When it failed, a "not ok" message is printed and the number +# of tests still broken is incremented. +# +# Failures from these tests won't cause --immediate to stop. +# +# Usually takes two arguments: +# $1 - Test description +# $2 - Commands to be executed. +# +# With three arguments, the first will be taken to be a prerequisite: +# $1 - Comma-separated list of test prerequisites. The test will be skipped if +# not all of the given prerequisites are set. To negate a prerequisite, +# put a "!" in front of it. +# $2 - Test description +# $3 - Commands to be executed. +# +# Returns nothing. +test_expect_failure() { + test "$#" = 3 && { test_prereq=$1; shift; } || test_prereq= + test "$#" = 2 || error "bug in the test script: not 2 or 3 parameters to test_expect_failure" + export test_prereq + if ! test_skip_ "$@"; then + say >&3 "checking known breakage: $2" + if test_run_ "$2" expecting_failure; then + test_known_broken_ok_ "$1" + else + test_known_broken_failure_ "$1" + fi + fi + echo >&3 "" +} + +# Public: Run command and ensure that it fails in a controlled way. +# +# Use it instead of "! ". For example, when dies due to a +# segfault, test_must_fail diagnoses it as an error, while "! " would +# mistakenly be treated as just another expected failure. +# +# This is one of the prefix functions to be used inside test_expect_success or +# test_expect_failure. +# +# $1.. - Command to be executed. +# +# Examples +# +# test_expect_success 'complain and die' ' +# do something && +# do something else && +# test_must_fail git checkout ../outerspace +# ' +# +# Returns 1 if the command succeeded (exit code 0). +# Returns 1 if the command died by signal (exit codes 130-192) +# Returns 1 if the command could not be found (exit code 127). +# Returns 0 otherwise. +test_must_fail() { + "$@" + exit_code=$? + if test $exit_code = 0; then + echo >&2 "test_must_fail: command succeeded: $*" + return 1 + elif test $exit_code -gt 129 -a $exit_code -le 192; then + echo >&2 "test_must_fail: died by signal: $*" + return 1 + elif test $exit_code = 127; then + echo >&2 "test_must_fail: command not found: $*" + return 1 + fi + return 0 +} + +# Public: Run command and ensure that it succeeds or fails in a controlled way. +# +# Similar to test_must_fail, but tolerates success too. Use it instead of +# " || :" to catch failures caused by a segfault, for instance. +# +# This is one of the prefix functions to be used inside test_expect_success or +# test_expect_failure. +# +# $1.. - Command to be executed. +# +# Examples +# +# test_expect_success 'some command works without configuration' ' +# test_might_fail git config --unset all.configuration && +# do something +# ' +# +# Returns 1 if the command died by signal (exit codes 130-192) +# Returns 1 if the command could not be found (exit code 127). +# Returns 0 otherwise. +test_might_fail() { + "$@" + exit_code=$? + if test $exit_code -gt 129 -a $exit_code -le 192; then + echo >&2 "test_might_fail: died by signal: $*" + return 1 + elif test $exit_code = 127; then + echo >&2 "test_might_fail: command not found: $*" + return 1 + fi + return 0 +} + +# Public: Run command and ensure it exits with a given exit code. +# +# This is one of the prefix functions to be used inside test_expect_success or +# test_expect_failure. +# +# $1 - Expected exit code. +# $2.. - Command to be executed. +# +# Examples +# +# test_expect_success 'Merge with d/f conflicts' ' +# test_expect_code 1 git merge "merge msg" B master +# ' +# +# Returns 0 if the expected exit code is returned or 1 otherwise. +test_expect_code() { + want_code=$1 + shift + "$@" + exit_code=$? + if test $exit_code = $want_code; then + return 0 + fi + + echo >&2 "test_expect_code: command exited with $exit_code, we wanted $want_code $*" + return 1 +} + +# Public: Compare two files to see if expected output matches actual output. +# +# The TEST_CMP variable defines the command used for the comparision; it +# defaults to "diff -u". Only when the test script was started with --verbose, +# will the command's output, the diff, be printed to the standard output. +# +# This is one of the prefix functions to be used inside test_expect_success or +# test_expect_failure. +# +# $1 - Path to file with expected output. +# $2 - Path to file with actual output. +# +# Examples +# +# test_expect_success 'foo works' ' +# echo expected >expected && +# foo >actual && +# test_cmp expected actual +# ' +# +# Returns the exit code of the command set by TEST_CMP. +test_cmp() { + ${TEST_CMP:-diff -u} "$@" +} + +# Public: Schedule cleanup commands to be run unconditionally at the end of a +# test. +# +# If some cleanup command fails, the test will not pass. With --immediate, no +# cleanup is done to help diagnose what went wrong. +# +# This is one of the prefix functions to be used inside test_expect_success or +# test_expect_failure. +# +# $1.. - Commands to prepend to the list of cleanup commands. +# +# Examples +# +# test_expect_success 'test core.capslock' ' +# git config core.capslock true && +# test_when_finished "git config --unset core.capslock" && +# do_something +# ' +# +# Returns the exit code of the last cleanup command executed. +test_when_finished() { + test_cleanup="{ $* + } && (exit \"\$eval_ret\"); eval_ret=\$?; $test_cleanup" +} + +# Public: Summarize test results and exit with an appropriate error code. +# +# Must be called at the end of each test script. +# +# Can also be used to stop tests early and skip all remaining tests. For this, +# set skip_all to a string explaining why the tests were skipped before calling +# test_done. +# +# Examples +# +# # Each test script must call test_done at the end. +# test_done +# +# # Skip all remaining tests if prerequisite is not set. +# if ! test_have_prereq PERL; then +# skip_all='skipping perl interface tests, perl not available' +# test_done +# fi +# +# Returns 0 if all tests passed or 1 if there was a failure. +test_done() { + EXIT_OK=t + + if test -z "$HARNESS_ACTIVE"; then + test_results_dir="$SHARNESS_TEST_DIRECTORY/test-results" + mkdir -p "$test_results_dir" + test_results_path="$test_results_dir/${SHARNESS_TEST_FILE%.$SHARNESS_TEST_EXTENSION}.$$.counts" + + cat >>"$test_results_path" <<-EOF + total $test_count + success $test_success + fixed $test_fixed + broken $test_broken + failed $test_failure + + EOF + fi + + if test "$test_fixed" != 0; then + say_color error "# $test_fixed known breakage(s) vanished; please update test(s)" + fi + if test "$test_broken" != 0; then + say_color warn "# still have $test_broken known breakage(s)" + fi + if test "$test_broken" != 0 || test "$test_fixed" != 0; then + test_remaining=$(( $test_count - $test_broken - $test_fixed )) + msg="remaining $test_remaining test(s)" + else + test_remaining=$test_count + msg="$test_count test(s)" + fi + + case "$test_failure" in + 0) + # Maybe print SKIP message + if test -n "$skip_all" && test $test_count -gt 0; then + error "Can't use skip_all after running some tests" + fi + [ -z "$skip_all" ] || skip_all=" # SKIP $skip_all" + + if test $test_remaining -gt 0; then + say_color pass "# passed all $msg" + fi + say "1..$test_count$skip_all" + + test -d "$remove_trash" && + cd "$(dirname "$remove_trash")" && + rm -rf "$(basename "$remove_trash")" + + exit 0 ;; + + *) + say_color error "# failed $test_failure among $msg" + say "1..$test_count" + + exit 1 ;; + + esac +} + +# Public: Root directory containing tests. Tests can override this variable, +# e.g. for testing Sharness itself. +: ${SHARNESS_TEST_DIRECTORY:=$(pwd)} +export SHARNESS_TEST_DIRECTORY + +# Public: Build directory that will be added to PATH. By default, it is set to +# the parent directory of SHARNESS_TEST_DIRECTORY. +: ${SHARNESS_BUILD_DIRECTORY:="$SHARNESS_TEST_DIRECTORY/.."} +PATH="$SHARNESS_BUILD_DIRECTORY:$PATH" +export PATH SHARNESS_BUILD_DIRECTORY + +# Public: Path to test script currently executed. +SHARNESS_TEST_FILE="$0" +export SHARNESS_TEST_FILE + +# Prepare test area. +test_dir="trash directory.$(basename "$SHARNESS_TEST_FILE" ".$SHARNESS_TEST_EXTENSION")" +test -n "$root" && test_dir="$root/$test_dir" +case "$test_dir" in +/*) SHARNESS_TRASH_DIRECTORY="$test_dir" ;; + *) SHARNESS_TRASH_DIRECTORY="$SHARNESS_TEST_DIRECTORY/$test_dir" ;; +esac +test "$debug" = "t" || remove_trash="$SHARNESS_TRASH_DIRECTORY" +rm -rf "$test_dir" || { + EXIT_OK=t + echo >&5 "FATAL: Cannot prepare test area" + exit 1 +} + +# Public: Empty trash directory, the test area, provided for each test. The HOME +# variable is set to that directory too. +export SHARNESS_TRASH_DIRECTORY + +HOME="$SHARNESS_TRASH_DIRECTORY" +export HOME + +mkdir -p "$test_dir" || exit 1 +# Use -P to resolve symlinks in our working directory so that the cwd +# in subprocesses like git equals our $PWD (for pathname comparisons). +cd -P "$test_dir" || exit 1 + +this_test=${SHARNESS_TEST_FILE##*/} +this_test=${this_test%.$SHARNESS_TEST_EXTENSION} +for skp in $SKIP_TESTS; do + case "$this_test" in + $skp) + say_color info >&3 "skipping test $this_test altogether" + skip_all="skip all tests in $this_test" + test_done + esac +done + +# vi: set ts=4 sw=4 noet : diff --git a/tests/t0001-sanity-checks.sh b/tests/t0001-sanity-checks.sh new file mode 100755 index 0000000..bf04394 --- /dev/null +++ b/tests/t0001-sanity-checks.sh @@ -0,0 +1,16 @@ +#!/bin/sh + +test_description='Sanity checks' +. ./setup.sh + +test_expect_success 'Make sure we can run pass' ' + ${PASS} --help | grep "pass: the standard unix password manager" +' + +test_expect_success 'Make sure we can initialize our test store' ' + pass_init && + ls -ld "${PASSWORD_STORE_DIR}" && + [[ -d "${PASSWORD_STORE_DIR}" ]] +' + +test_done diff --git a/tests/t0005-init-failing.sh b/tests/t0005-init-failing.sh new file mode 100755 index 0000000..01548a6 --- /dev/null +++ b/tests/t0005-init-failing.sh @@ -0,0 +1,11 @@ +#!/bin/sh + +test_description='Show "pass init" returning non-zero bug(?) (XXX: remove this test?)' +. ./setup.sh + +test_expect_failure 'Show "pass init" returning non-zero' ' + export PASSWORD_STORE_DIR="${SHARNESS_TRASH_DIRECTORY}/test-store/" && + ${PASS} init ${PASSWORD_STORE_KEY} +' + +test_done diff --git a/tests/t0010-generate-tests.sh b/tests/t0010-generate-tests.sh new file mode 100755 index 0000000..96bb820 --- /dev/null +++ b/tests/t0010-generate-tests.sh @@ -0,0 +1,16 @@ +#!/bin/sh + +test_description='Test generate' +. ./setup.sh + +export TEST_CRED="test_cred" +export TEST_CRED_LEN=24 + +test_expect_success 'Test "generate" command' ' + pass_init && + echo Generating credential "${TEST_CRED}" with length ${TEST_CRED_LEN} && + ${PASS} generate "${TEST_CRED}" ${TEST_CRED_LEN} && + check_cred "${TEST_CRED}" +' + +test_done diff --git a/tests/t0020-show-tests.sh b/tests/t0020-show-tests.sh new file mode 100755 index 0000000..8e0a69a --- /dev/null +++ b/tests/t0020-show-tests.sh @@ -0,0 +1,18 @@ +#!/bin/sh + +test_description='Test show' +. ./setup.sh + +export TEST_CRED="test_cred" + +test_expect_success 'Test "show" command' ' + pass_init && + create_cred "$TEST_CRED" && + ${PASS} show "$TEST_CRED" +' + +test_expect_success 'Test "show" of nonexistant password' ' + pass_init && + test_must_fail ${PASS} show "$TEST_CRED" +' +test_done diff --git a/tests/t0050-mv-tests.sh b/tests/t0050-mv-tests.sh new file mode 100755 index 0000000..65d2c7e --- /dev/null +++ b/tests/t0050-mv-tests.sh @@ -0,0 +1,18 @@ +#!/bin/sh + +test_description='Test mv' +. ./setup.sh + +export TEST_CRED="test_cred" +export TEST_CRED_NEW="test_cred_new" + +test_expect_success 'Test "mv" command' ' + pass_init && + create_cred "${TEST_CRED}" && + echo "Moving $TEST_CRED to $TEST_CRED_NEW" && + ${PASS} mv "${TEST_CRED}" "${TEST_CRED_NEW}" && + check_cred "${TEST_CRED_NEW}" && + check_no_cred "${TEST_CRED}" +' + +test_done diff --git a/tests/t0060-rm-tests.sh b/tests/t0060-rm-tests.sh new file mode 100755 index 0000000..5159ac7 --- /dev/null +++ b/tests/t0060-rm-tests.sh @@ -0,0 +1,20 @@ +#!/bin/sh + +test_description='Test rm' +. ./setup.sh + +export TEST_CRED="test_cred" + +test_expect_success 'Test "rm" command' ' + pass_init && + create_cred "${TEST_CRED}" && + echo "Removing $TEST_CRED" && + echo "y" | ${PASS} rm "${TEST_CRED}" && + check_no_cred "${TEST_CRED}" +' + +test_expect_success 'Test "rm" of non-existent password' ' + test_must_fail ${PASS} rm does-not-exist +' + +test_done diff --git a/tests/t0100-insert-tests.sh b/tests/t0100-insert-tests.sh new file mode 100755 index 0000000..f1349c4 --- /dev/null +++ b/tests/t0100-insert-tests.sh @@ -0,0 +1,15 @@ +#!/bin/sh + +test_description='Test insert' +. ./setup.sh + +export TEST_CRED="test_cred" +export TEST_PASSWORD="Hello world" + +test_expect_success 'Test "insert" command' ' + pass_init && + echo "$TEST_PASSWORD" | ${PASS} insert -e "$TEST_CRED" && + verify_password "$TEST_CRED" "$TEST_PASSWORD" +' + +test_done diff --git a/tests/t0200-edit-tests.sh b/tests/t0200-edit-tests.sh new file mode 100755 index 0000000..65c67f1 --- /dev/null +++ b/tests/t0200-edit-tests.sh @@ -0,0 +1,17 @@ +#!/bin/sh + +test_description='Test edit' +. ./setup.sh + +export TEST_CRED="test_cred" + +test_expect_success 'Test "edit" command' ' + pass_init && + create_cred "$TEST_CRED" && + export FAKE_EDITOR_PASSWORD="big fat fake password" && + export EDITOR="$PASSWORD_STORE_TEST_HOME/fake-editor-change-password.sh" && + ${PASS} edit "$TEST_CRED" && + verify_password "$TEST_CRED" "$FAKE_EDITOR_PASSWORD" +' + +test_done -- cgit v1.2.3