#!/bin/sh
# This script is uses ShUnit to test packaging/common/*.  Currently
# it only tests the functions as they perform for rpm and deb building.
# As support is added for other styles of package, these tests should be
# updated.

#######################
# If EXECUTING WITH ROOT ACCESS SCRIPT DELETES AND CREATES USERS.
# EXECUTE WITH CAUTION.
#######################

#set -x

# Note on conflicting variable names:
# SHUNIT_* and SHU_* are shunit2 variables
# test_* should only be used by test functions.
# All other variables will probably be used by pre/post/common functions.
case $1 in
    DEBUG) DEBUG=True
        shift
        ;;
    *) DEBUG= ;;
esac
export DEBUG

ex_from=`dirname $0`

# shunit2 assumes shunit_inc, but we might run from a separate
# builddir. So try to use srcdir, as defined by automake, or
# otherwise `pwd`.
SHUNIT_INC="${srcdir=`pwd`}/packaging/common"; export SHUNIT_INC
TMPDIR=`pwd`/shunit-test; export TMPDIR
amanda_user=test_amandabackup; export amanda_user
amanda_group=test_disk; export amanda_group
sup_group="test_tape"; export sup_group
AMANDAHOMEDIR=$TMPDIR/amanda; export AMANDAHOMEDIR
AMANDATES=$AMANDAHOMEDIR/amandates; export AMANDATES
os=`uname`; export os
wanted_shell='/bin/false'; export wanted_shell
dist=Fedora; export dist
SYSCONFDIR=$TMPDIR/etc; export SYSCONFDIR
SBINDIR=$TMPDIR/sbin; export SBINDIR
encoder=`{ command -v base64 2>/dev/null; } || { command -v uuencode 2>/dev/null; }`
# Don't potentially conflict with a real value...
deb_uid=63000; export deb_uid


# Append stuff to this when you make temp files if they are outside TMPDIR
test_cleanup_files="$TMPDIR"; export test_cleanup_files

# This can't be part of one-time setup, because TMPDIR must exist before
# shunit2 is sourced.
mkdir -p ${TMPDIR} || exit 1
{
    LOGFILE="$TMPDIR/test_sh_libs.log"
    (umask 077 && touch $LOGFILE)
} || {
    echo "Unable to create log file!"
    exit 1
}
export LOGFILE

oneTimeSetUp() {
    msg_prefix="oneTimeSetUp: "
    if [ "$IAmRoot" ]; then
	# Delete an existing user.
        echo "$msg_prefix attempting to delete an existing user."
	userdel -f -r ${amanda_user}
        # If the user exists, our tests will act wrong, so exit
        grep "${amanda_user}" ${SYSCONFDIR}/passwd &> /dev/null || { \
            echo "$msg_prefix ${amanda_user} still exists, or no ${SYSCONFDIR}/passwd.";
            exit 1; }
        groupdel ${amanda_group} || exit 1
        groupdel ${sup_group} || exit 1
    else
	echo "Not root, cleanup skipped"
    fi
    # Make all directories which might be needed.
    mkdir -p ${AMANDAHOMEDIR}/example
    if [ ! "$IAmRoot" ]; then
        mkdir -p ${SYSCONFDIR}/xinetd.d
        mkdir -p ${SYSCONFDIR}/init.d
    fi
}

oneTimeTearDown() {
    if [ ${__shunit_assertsFailed} -eq 0 ] && [ ! "${DEBUG}" ]; then
	rm -rf $test_cleanup_files
    else
	echo "Check ${test_cleanup_files} for logs and error info."
    fi
}

test_cleanup_files="$LOGFILE ${test_cleanup_files}"

# shows syntax errors before the tests are run.
. ${SHUNIT_INC}/common_functions.sh
. ${SHUNIT_INC}/pre_inst_functions.sh
. ${SHUNIT_INC}/post_inst_functions.sh
. ${SHUNIT_INC}/post_rm_functions.sh

# Use this to skip root requiring tests.
# id -u is not portable to solaris.
tester_id=`id | sed 's/gid=\([0-9]*\).*/\1/'`
if [ "$tester_id" = "0" ]; then
    # Same as SHUNIT_TRUE, but we can't use that yet...
    IAmRoot=0
else
    IAmRoot=
fi

# CAUTION: using real values if we are root.
if [ "$IAmRoot" ]; then
    amanda_group=disk; export amanda_group
    SYSCONFDIR=/etc; export SYSCONFDIR
    SBINDDIR=/sbin; export SBINDDIR
fi

# Source our mock utils.
. ${SHUNIT_INC}/mock_utils.sh

log_tail_no_stamp() {
    # This strips the date off of a log line so only the message is
    # compared.
    LOG_TAIL=`tail -1 ${LOGFILE}|cut -d " " -f 5-`
}

######################################
# Common functions

# shUnit reorders tests alphabetically.  We need the logger and cleanup tests
# to run first.
test___logger() {
    # Write a line to the log, test that it got there.
    TEST_MSG="test___logger message"
    LOG_LINE="`date +'%b %d %Y %T'`: ${TEST_MSG}"
    # It's important for the log messages to be quoted, or funny stuff happens.
    logger "${TEST_MSG}"
    LOG_LINE1="`date +'%b %d %Y %T'`: ${TEST_MSG}"
    assertEquals "logger() return code" 0 $?
    log_tail_no_stamp
    assertEquals "logger() did not write <${LOG_LINE}> " \
	"${TEST_MSG}" "${LOG_TAIL}"
    # Leave this outside the unit test framework.  if the logger is
    # broken we must exit.
    if [ ! `grep -c "${LOG_LINE}" ${LOGFILE}` = "1" ]; then
        if [ ! `grep -c "${LOG_LINE1}" ${LOGFILE}` = "1" ]; then
	    echo "error: logger(): Incorrect content in ${LOGFILE}: " `cat ${LOGFILE}`
	    echo "       expected: ${LOG_LINE}"
	    echo "             or: ${LOG_LINE1}"
	    exit 1
         fi
    fi
}

test__log_output_of() {
    # Use log_output_of to append to the log
    TEST_MSG="test__log_output_of message"
    log_output_of echo "${TEST_MSG}"
    assertEquals "log_output_of()" 0 $?
    LOG_LINE="echo: ${TEST_MSG}"
    log_tail_no_stamp
    assertEquals "log_output_of() message should be: " \
        "${LOG_LINE}" "${LOG_TAIL}"
    COUNT=`grep -c "${TEST_MSG}" ${LOGFILE}`
    assertEquals "log_output_of(): incorrect content in log" \
	1 ${COUNT}
    # Leave this outside the unit test framework.  if the logger is
    # broken we must exit.
    if [ ! ${COUNT} = '1' ]; then
	echo "error: log_output_of(): Incorrect content in ${LOGFILE}: " `cat ${LOGFILE}`
	exit 1
    fi
}


# NOTE: check_xinetd and check_inetd tests end up simply duplicating the
# code of the function itself

test_check_smf() {
    logger "test_check_smf"
    [ "$os" = "SunOS" ] || { startSkipping; echo "test_check_smf: skipped"; }
    # Test existing service
    touch ${MOCKDIR}/prexisting_service
    check_smf
    assertEquals "check_smf preexisting services" 0 $?
    rm ${MOCKDIR}/prexisting_service
    check_smf
    assertEquals "check_smf no amanda service" 1 $?
}

test_check_superserver_running() {
    logger "test_check_superserver_running"
    [ "$IAmRoot" ] && { startSkipping; echo "test_check_superserver_running: skipped"; }
    # Test the positive cases
    # running changes the output of mocked ps
    touch ${MOCKDIR}/running
    check_superserver_running inetd
    assertEquals "check_superserver_running inetd" 0 $?
    assertSame "ps args: -e" "`cat $mock_ps_flags`"
    if [ `uname` = 'Darwin' ]; then
	[ "$IAmRoot" ] && startSkipping
        check_superserver_running launchd
        assertEquals "check_superserver_running launchd" 0 $?
        assertSame "ps args: aux" "`cat $mock_ps_flags`"
	endSkipping
    else
	endSkipping
        check_superserver_running launchd
        assertEquals 2 $?
    fi
    # Test the negative case, skip if root
    [ "$IAmRoot" ] && startSkipping
    rm ${MOCKDIR}/running
    check_superserver_running inetd
    assertEquals "check_superserver_running inetd returned 0 when inetd was not running" 1 $?
    assertSame "ps args: -e" "`cat $mock_ps_flags`"
    check_superserver_running xinetd
    assertNotEquals "check_superserver_running xinetd incorrectly returned 0" \
	 0 $?
    assertSame "ps args: -e" "`cat $mock_ps_flags`"
}

test_backup_xinetd() {
    logger "test_backup_xinetd"
    touch ${SYSCONFDIR}/xinetd.d/amandaserver
    backup_xinetd "amandaserver"
    assertEquals "backup_xinetd returns 0" 0 $?
    assertTrue "[ -f ${AMANDAHOMEDIR}/example/*.amandaserver.orig ]"
}

test_backup_inetd() {
    logger "test_backup_inetd"
    case $os in
        SunOS) inetd_dir=${SYSCONFDIR}/inet ;;
        *) inetd_dir=${SYSCONFDIR} ;;
    esac
    [ -d "${inetd_dir}" ] || mkdir -p ${inetd_dir}
    touch ${inetd_dir}/inetd.conf
    echo "amanda foo/bar/baz  amandad" >> ${inetd_dir}/inetd.conf
    backup_inetd
    assertEquals "backup_inetd returns 0" 0 $?
    assertTrue "[ -f ${AMANDAHOMEDIR}/example/inetd.orig ]"
}

test_backup_smf() {
    logger "test_backup_smf"
    :
    # TODO: how to mock this?
}

test_install_xinetd() {
    logger "test_install_xinetd"
    if [ "$os" = "SunOS" ] ; then
        # Solaris has install_xinetd_sol
        startSkipping
        echo "test_install_xinetd: skipped"
        return
    fi
    # Test success:
    touch ${MOCKDIR}/success
    touch ${AMANDAHOMEDIR}/example/xinetd.amandaserver
    install_xinetd "amandaserver"
    assertEquals "install_xinetd returns 0" 0 $?
    # Test "install" failure
    rm ${MOCKDIR}/success
    install_xinetd "amandaserver"
    assertEquals "install_xinetd returns 1" 1 $?
}

test_install_inetd() {
    logger "test_install_inetd"
    case $os in
        SunOS) inetd_dir=${BASEDIR}/${SYSCONFDIR}/inet ;;
        *) inetd_dir=${SYSCONFDIR} ;;
    esac
    [  -f ${inetd_dir}/inetd.conf ] || touch ${inetd_dir}/inetd.conf
    test_inetd_entry='amanda foo/bar/baz  amandad'
    if [ ! -f ${AMANDAHOMEDIR}/example/inetd.conf ]; then
	echo "${test_inetd_entry}" > ${AMANDAHOMEDIR}/example/inetd.conf.amandaserver
    fi
    install_inetd amandaserver
    assertEquals "install_inetd returns 0" 0 $?
    assertSame "${test_inetd_entry}" "`tail -1 ${inetd_dir}/inetd.conf`"
}

# TODO: test_install_smf() {
# Needs mocks for: inetconv, inetadm, svcadm.

test_reload_xinetd() {
    logger "test_reload_xinetd"
    # Might need init script.
    if [ "$IAmRoot" ]; then
        startSkipping
        echo "test_reload_xinetd: skipped"
        return
    elif [ ! -f "${SYSCONFDIR}/init.d/xinetd" ]; then
        mv ${MOCKDIR}/xinetd ${SYSCONFDIR}/init.d
    fi
    # Test bad argument
    reload_xinetd foo
    assertEquals "reload_xinetd should reject argument 'foo'" 1 $?
    # Test success
    touch ${MOCKDIR}/success
    reload_xinetd "reload"
    assertEquals "reload_xinetd" 0 $?
    # Test no argument
    reload_xinetd
    assertEquals "reload_xinetd should attempt to reload" 0 $?
    flags=`cat ${mock_xinetd_flags}`
    assertEquals "xinetd_flags should contain: " \
        "xinetd args: reload" "${flags}"
    # Test failure
    rm ${MOCKDIR}/success
    reload_xinetd "reload"
    assertEquals "reload_xinetd" 1 $?
    tail -4 ${LOGFILE}|grep "\<xinetd.*Attempting restart" >/dev/null
    assertEquals "reload_xinetd should try to restart." 0 $?
    reload_xinetd "restart"
    assertEquals "restart should fail." 1 $?
    tail -3 ${LOGFILE}|grep "restarting xinetd" >/dev/null
    assertEquals "Should log attempt to restart" 0 $?
}

test_reload_inetd() {
    logger "test_reload_inetd"
    # Test bad argument
    # Might need init script.
    if [ ! "$IAmRoot" ]; then
        if [ ! -f "${SYSCONFDIR}/init.d/inetd" ]; then
            mv ${MOCKDIR}/inetd ${SYSCONFDIR}/init.d
        fi
    fi
    # Test bad argument
    reload_inetd foo
    assertEquals "reload_inetd should reject argument 'foo' (return 1):" 1 $?
    # Test success
    touch ${MOCKDIR}/success
    reload_inetd
    assertEquals "reload_inetd" 0 $?
    # Test failure
    rm ${MOCKDIR}/success
    reload_inetd "reload"
    assertEquals "reload_inetd" 1 $?
    tail -4 ${LOGFILE}|grep "\<inetd.*Attempting restart" >/dev/null
    assertEquals "reload_inetd should try to restart." 0 $?
    reload_inetd "restart"
    assertEquals "restart should fail." 1 $?
    tail -3 ${LOGFILE}|grep "Restarting inetd" >/dev/null
    assertEquals "Should log attempt to restart" 0 $?
}


######################################
# pre_install_functions

test_check_user_group_missing() {
    logger "test_check_user_group_missing no param"
    check_user_group
    assertNotEquals "'check_user_group' should fail" 0 $?
    logger "test_check_user_group_missing missing group"
    [ ! "$IAmRoot" ] && rm -f ${SYSCONFDIR}/group
    touch ${SYSCONFDIR}/group
    for os in linux osx solaris; do
        echo $os > ${MOCKDIR}/id_os
        check_user_group "abracadabra"
        assertNotEquals "'check_user group abracadabra' should not be found:" 0 $?
        log_tail_no_stamp
        assertEquals "check_user_group should write" \
            "User's primary group 'abracadabra' does not exist" \
            "${LOG_TAIL}"
    done
}

good_group_entry="${amanda_group}:x:100:"
export good_group_entry
test_check_user_group_exists() {
    logger "test_check_user_group user and group exist"
    touch ${MOCKDIR}/id_exists
    touch ${SYSCONFDIR}/group
    # Non-root adds and entry to the mock group file
    [ ! "$IAmRoot" ] && echo $good_group_entry > ${SYSCONFDIR}/group
    for os in linux osx solaris; do
        echo $os > ${MOCKDIR}/id_os

        # Case 1: Amanda_user is correct.
        echo ${amanda_group} > ${MOCKDIR}/id_group
        check_user_group "${amanda_group}"
        assertEquals "'check_user_group ${amanda_group}': id returns correct groupname" \
            0 $?

        # Case 2: Amanda_user is not a member of the the correct primary group.
        rm ${MOCKDIR}/id_group
        check_user_group "${amanda_group}"
        assertEquals "'check_user_group ${amanda_group}' when not a member" 1 $?
    done
}

test_check_user_supplemental_group_missing() {
    logger "test_check_user_supplemental_group missing"
    [ ! "$IAmRoot" ] && echo $good_group_entry > ${SYSCONFDIR}/group
    for os in linux osx solaris; do
        echo $os > ${MOCKDIR}/id_os
        check_user_supplemental_group ${sup_group}
        assertEquals "'check_user supplemental-group ${sup_group}' when group missing" \
        1 $?
    done
}

missing_group_member="${sup_group}:x:105:nobody"
export missing_group_member
good_sup_group_entry="${missing_group_member},${amanda_user}"
export good_sup_group_entry

test_check_user_supplemental_group_exists() {
    logger "test_check_user_supplemental_group exists"
    [ ! "$IAmRoot" ] && echo $missing_group_member > ${SYSCONFDIR}/group
    check_user_supplemental_group ${sup_group}
    assertEquals "'check_user_supplemental_group ${sup_group}' when amanda_user is not a member" \
        1 $?

    [ ! "$IAmRoot" ] && echo ${good_sup_group_entry} > ${SYSCONFDIR}/group
    check_user_supplemental_group ${sup_group}
    assertEquals "'check_user_supplemental_group ${sup_group}' with correct membership" \
        0 $?
}
test_check_user_shell() {
    logger "test_check_user_shell"
    if [ ! "$IAmRoot" ]; then
	echo "${good_passwd_entry}" > ${SYSCONFDIR}/passwd
    fi
    # Case 1: Provide a matching shell
    check_user_shell "/bin/bash"
    assertEquals "check_user_shell /bin/bash (matching)" 0 $?
    # Case 2: Provide a non-matching shell. 
    check_user_shell "/bin/ksh"
    assertEquals "check_user_shell /bin/ksh (not matching)" 1 $?
}

test_check_user_homedir() {
    logger 'test_check_user_homedir'
    if [ ! "$IAmRoot" ]; then
	echo "${good_passwd_entry}" > ${SYSCONFDIR}/passwd
    fi
    # Case 1: Assume amanda_user is correct.
    check_user_homedir "${AMANDAHOMEDIR}"
    assertEquals "check_user_homedir ${AMANDAHOMEDIR}" 0 $?
    # Case 2: Provide an incorrect homedir
    check_user_homedir "/tmp"
    assertEquals "check_user_homedir /tmp" 1 $?
}

test_check_user_uid() {
    echo "${amanda_group}" > ${MOCKDIR}/id_group
    touch ${MOCKDIR}/id_exists
    logger 'test_check_user_uid'
    for os in linux osx solaris; do
        echo $os > ${MOCKDIR}/id_os
        check_user_uid
        assertEquals "check_user_uid without a uid" 1 $?
        logger 'test_check_user_uid wrong id'
        check_user_uid 123
        assertEquals "check_user_uid uids don't match" 1 $?
        logger 'test_check_user_uid correct id'
        check_user_uid ${deb_uid}
    done

}
test_check_homedir_dir_missing() {
    logger "test_check_homedir_dir_missing"
    # First make sure the dir is missing
    rm -rf ${AMANDAHOMEDIR}
    check_homedir
    assertNotEquals "check_homedir returned 0, but homedir did not exist" 0 $?
}

# passwd file entry for Linux systems, maybe others.  UID is correct
# for Debian as well.
good_passwd_entry="${amanda_user}:x:${mock_deb_uid}:6::${AMANDAHOMEDIR}:/bin/bash"
export good_passwd_entry
test_create_user() {
    logger "test_create_user"
    if [ ! "$IAmRoot" ]; then
	startSkipping
	echo "test_create_user: Creating mock passwd file."
	echo "$good_passwd_entry" > ${SYSCONFDIR}/passwd
	echo "test_create_user: tests skipped."
	#TODO: mock useradd.
	return
    fi
    # Case 1: create_user should succeed.
    create_user
    assertEquals "create_user()" 0 $?
}

test_add_profiles() {
    # Solaris only, but testing using mock usermod will run if not root
    # on any system.
    logger "test_add_profiles"
    [ "$IAmRoot" ] && startSkipping
    add_profiles "Profile foo,Profile bar"
    assertEquals "add_profiles should succeed" 0 $?
    flags=`cat ${mock_usermod_flags}`
    assertEquals "usermod_flags should contain:" \
        "usermod args: -P \"Profile foo,Profile bar\" ${amanda_user}" \
        "${flags}"

}

test_add_group_check_parameters_logs() {
    rm -f ${MOCKDIR}/groupadd_rc ${MOCKDIR}/num_groups
    # Return codes are integers.
    printf '%i' 0 > ${MOCKDIR}/groupadd_rc
    # Test that first parameter is required.
    add_group
    assertEquals "add_group without a group should fail." 1 $?
    log_tail_no_stamp
    assertEquals "add_group should write" \
        "Error: first argument was not a group to add." \
        "${LOG_TAIL}"
}

test_add_group_group_ok() {
    # groupadd created group
    printf '%i' 0 > ${MOCKDIR}/groupadd_rc
    echo '${amanda_user} : prev_grp1' > ${MOCKDIR}/groups_output
    add_group twinkle
    assertEquals "add_group group ok" 0 $?
    flags=`cat ${mock_usermod_flags}`
    assertEquals "usermod_flags" \
        "usermod args: -G prev_grp1,twinkle ${amanda_user}" \
        "${flags}"

    # Make sure supplemental groups are preserved when adding groups to an
    # existing account
    echo '${amanda_user} : prev_grp1 prev_grp2' > ${MOCKDIR}/groups_output
    printf '%i' 1 > ${MOCKDIR}/num_groups
    add_group twinkle
    assertEquals "add_group group ok" 0 $?
    flags=`cat ${mock_usermod_flags}`
    assertEquals "usermod_flags should contain:" \
        "usermod args: -G prev_grp1,prev_grp2,twinkle ${amanda_user}" \
        "${flags}"
}

test_create_homedir() {
    logger "test_create_homedir"
    rm -rf ${AMANDAHOMEDIR}
    create_homedir
    assertEquals "create_homedir returns 0" 0 $?
    assertTrue "${AMANDAHOMEDIR} did not get created" "[ -d ${AMANDAHOMEDIR} ]"
    if [ "$IAmRoot" ]; then
	# Check real owner
	real_owner=`ls -ld $AMANDAHOMEDIR | awk '{ print $3":"$4; }'`
	assertSame "${amanda_user}:${amanda_group}" "$real_owner"
    else
        assertSame \
	    "chown args: -R ${amanda_user}:${amanda_group} ${AMANDAHOMEDIR}" \
	    "`cat $mock_chown_flags`"
    fi
    # A second run should succeed too.
    create_homedir    
    assertEquals "When homedir exists, create_homedir returns 0:" 0 $?
    # Later tests use ${AMANDAHOMEDIR}, so leave the dir there.
}

test_check_homedir_dir_existing() {
    logger "test_check_homedir_dir_existing"
    # Create the dir (example needed for other tests), then check again.
    mkdir -p ${AMANDAHOMEDIR}/example
    check_homedir
    assertEquals "Homedir exists; check_homedir" 0 $?
}

test_create_logdir() {
    logger "test_create_logdir"
    # The logdir variable for the shell libs, not shunit2.
    LOGDIR=$TMPDIR/amanda_log; export LOGDIR
    rm -rf ${LOGDIR}
    rm -rf ${LOGDIR}.save
    create_logdir
    assertEquals "create_logdir clean system" 0 $?
    if [ -n "$IAmRoot" ]; then
	real_owner=`ls -ld $LOGDIR | awk '{ print $3":"$4; }'`
	assertSame "${amanda_user}:${amanda_group}" "$real_owner"
    else
	assertSame \
	    "chown args: -R ${amanda_user}:${amanda_group} ${LOGDIR}"\
	    "`cat $mock_chown_flags`"
    fi
    assertTrue "${LOGDIR} exists" "[ -d ${LOGDIR} ]"
    # What happens if logdir is a file?
    rm -rf ${LOGDIR}
    touch ${LOGDIR}
    create_logdir
    assertEquals "create_logdir" 0 $?
    assertTrue "${LOGDIR} exists" "[ -d ${LOGDIR} ]"
    assertTrue "${LOGDIR}/amanda_log.save backup exists" \
        "[ -f ${LOGDIR}/amanda_log.save ]"
}

test_create_amandates() {
    logger "test_create_amandates"
    rm -f ${AMANDATES}
    create_amandates
    assertEquals "create_amandates" 0 $?
    assertTrue "[ -f ${AMANDATES} ]"
}

test_check_amandates() {
    logger "test_check_amandates"
    touch $mock_chown_flags
    touch $mock_chmod_flags
    check_amandates
    assertEquals "check_amandates" 0 $?
    [ "$IAmRoot" ] && { startSkipping; echo "test_check_amandates: skipped"; }
    assertSame \
	"chown args: ${amanda_user}:${amanda_group} ${AMANDATES}" \
	"`cat $mock_chown_flags`"
    assertSame \
	"chmod args: 0640 ${AMANDATES}" \
	"`cat $mock_chmod_flags`"
}

test_a_create_gnupg() {
    # We need to impose some order on a few tests because some functions
    # rely on others.  Tests are sorted alphabetically.  Insert a letter after
    # "test_" to impose order on particular tests
    logger "test_create_gnupg"
    create_gnupg
    assertEquals "create_gnupg" 0 $?
    assertTrue "[ -d ${AMANDAHOMEDIR}/.gnupg ]"
    # Dir exists
    create_gnupg
    assertEquals "create_gnupg dir existing" 0 $?
}

test_a_get_random_lines() {
    logger "test_get_random_lines"
    get_random_lines > ${TMPDIR}/lines
    assertEquals "get_random_lines" 1 $?
    get_random_lines 1 > ${TMPDIR}/lines
    assertEquals "get_random_lines 1" 0 $?
    assertEquals "get_random_lines 1 output" 1 "`sed -n '$=' ${TMPDIR}/lines`"
    get_random_lines 20 > ${TMPDIR}/lines
    assertEquals "get_random_lines 20 output" 20 "`sed -n '$=' ${TMPDIR}/lines`"
}

test_b_create_ampassphrase() {
    rm -f ${AMANDAHOMEDIR}/.am_passphrase
    logger "test_create_ampassphrase"
    create_ampassphrase
    assertEquals "create_ampassphrase" 0 $?
    assertSame \
        "chown args: ${amanda_user}:${amanda_group} ${AMANDAHOMEDIR}/.am_passphrase" \
        "`cat $mock_chown_flags`"
    assertSame \
        "chmod args: 0600 ${AMANDAHOMEDIR}/.am_passphrase" \
        "`cat $mock_chmod_flags`"
    # When .am_passphrase exists.
    create_ampassphrase
    log_tail_no_stamp
    assertSame \
        "Info: ${AMANDAHOMEDIR}/.am_passphrase already exists." \
        "${LOG_TAIL}"
    rm ${AMANDAHOMEDIR}/.am_passphrase
}

test_b_create_amkey() {
    logger "test_create_amkey"
    # Missing .am_passphrase
    [ -f ${AMANDAHOMEDIR}/.am_passphrase ] && rm ${AMANDAHOMEDIR}/.am_passphrase
    create_amkey
    assertEquals "create_amkey" 1 $?
    log_tail_no_stamp
    assertSame \
        "Error: ${AMANDAHOMEDIR}/.am_passphrase is missing, can't create amcrypt key." \
        "${LOG_TAIL}"
    # Need .am_passphrase. Ignore these test errors if get_random_lines or
    # create_gnupg tests failed.
    get_random_lines 1 > ${AMANDAHOMEDIR}/.am_passphrase
    create_amkey
    assertEquals "create_amkey" 0 $?
    # Test with existing key
    create_amkey
    assertEquals "create_amkey" 0 $?
    log_tail_no_stamp
    assertSame \
        "Info: Encryption key '${AMANDAHOMEDIR}/.gnupg/am_key.gpg' already exists." \
        "${LOG_TAIL}"
    # make sure unencrypted am_key is not hanging around
    assertFalse "[ -f ${AMANDAHOMEDIR}/.gnupg/am_key ]"

}

test_check_gnupg() {
    logger "test_check_gnupg"
    check_gnupg
    assertEquals "check_gnupg" 0 $?
    assertSame \
	"chown args: -R ${amanda_user}:${amanda_group} ${AMANDAHOMEDIR}/.gnupg" \
	"`cat $mock_chown_flags`"
    assertSame \
	"chmod args: -R u=rwX,go= ${AMANDAHOMEDIR}/.gnupg" \
	"`cat $mock_chmod_flags`"
}

test_create_amandahosts() {
    logger "test_create_amandahosts"
    create_amandahosts
    assertEquals "create_amandahosts:" 0 $?
    assertEquals "${AMANDAHOMEDIR}/.amandahosts exists:" 0 $?
    assertEquals "create_amandahosts" 0 $?
    assertTrue "[ -f ${AMANDAHOMEDIR}/.amandahosts ]"
}

test_check_amandahosts_entry() {
    logger "test_check_amandahosts_entry"
    if [ -f ${AMANDAHOMEDIR}/.amandahosts ]; then
	check_amandahosts_entry root amindexd amidxtaped
	assertEquals "check_amandahosts_entry root amindexd amidxtaped" \
	    0 $?
    else
	echo "test_check_amandahosts_entry: ${AMANDAHOMEDIR}/.amandahosts missing.  test skipped"
	startSkipping
    fi
}

test_check_amandahosts_perm() {
    logger "test_check_amandahosts_perm"
    check_amandahosts_perms
    assertEquals "check_amandahosts_perms" 0 $?
    [ "$IAmRoot" ] && { startSkipping; echo "test_check_amandahosts_perm: skipped"; }
    assertSame \
	"chown args: ${amanda_user}:${amanda_group} ${AMANDAHOMEDIR}/.amandahosts" \
	"`cat $mock_chown_flags`"
    assertSame \
	"chmod args: 0600 ${AMANDAHOMEDIR}/.amandahosts" \
	"`cat $mock_chmod_flags`"
}

test_create_ssh_key() {
    logger "test_create_ssh_key"
    keydir=${AMANDAHOMEDIR}/.ssh
    rm -rf ${keydir}
    create_ssh_key server
    assertEquals "create_ssh_key" 0 $?
    assertTrue "[ -f ${keydir}/id_rsa_amdump ]"
    [ "$IAmRoot" ] && { startSkipping; echo "test_create_ssh_key: skipped"; }
    assertSame \
	"chown args: ${amanda_user}:${amanda_group} ${keydir} ${keydir}/id_rsa_amdump ${keydir}/id_rsa_amdump.pub" \
	"`cat $mock_chown_flags`"
    # Chmod is called twice, but we only get the 2nd invocation.
    assertSame \
	"chmod args: 0600 ${keydir}/id_rsa_amdump ${keydir}/id_rsa_amdump.pub" \
	"`cat $mock_chmod_flags`"
    endSkipping

    rm -rf ${keydir}
    # What happens if .ssh is a file?
    touch ${AMANDAHOMEDIR}/.ssh
    create_ssh_key client
    assertEquals "create_ssh_key" 0 $?
    assertTrue "[ -f ${keydir}.save ]"
    assertTrue "[ -f ${keydir}/id_rsa_amrecover ]"
}

test_create_profile() {
    logger "test_create_profile"
    rm -f ${AMANDAHOMEDIR}/.profile
    create_profile
    assertEquals "create_profile" 0 $?
    assertTrue "[ -f ${AMANDAHOMEDIR}/.profile ]"
}

test_check_profile() {
    logger "test_check_profile"
    [ -f "${AMANDAHOMEDIR}/.profile" ] || touch ${AMANDAHOMEDIR}/.profile
    check_profile
    assertEquals "check_profile" 0 $?
    assertTrue "[ -s ${AMANDAHOMEDIR}/.profile ]"
    [ "$IAmRoot" ] && { startSkipping; echo "test_check_profile: skipped"; }
    assertSame \
	"chown args: ${amanda_user}:${amanda_group} ${AMANDAHOMEDIR}/.profile" \
	"`cat $mock_chown_flags`"
    assertSame \
	"chmod args: 0640 ${AMANDAHOMEDIR}/.profile" \
	"`cat $mock_chmod_flags`"
}

test_install_client_conf() {
    logger "test_install_client_conf"
    # Test success
    touch ${MOCKDIR}/success
    install_client_conf
    assertEquals "install_client_conf" 0 $?
    prefix="install args:"
    inst_files="${AMANDAHOMEDIR}/example/amanda-client.conf ${SYSCONFDIR}/amanda/"
    case $os in
      SunOS) assertSame \
        "`cat $mock_install_flags`" \
        "${prefix} -m 0600 -u ${amanda_user} -g ${amanda_group} ${inst_files}"
      ;;
      *) assertSame \
        "`cat $mock_install_flags`" \
        "${prefix} -m 0600 -o ${amanda_user} -g ${amanda_group} ${inst_files}"
    esac
}

#TODO: create_amtmp

######################################
#TODO: post_rm_functions

# Run a single test, or let shunit run all tests
if [ $# -gt 0 ]; then
    echo $1
    SPECIFIC_TESTS="$*"
    suite() {
        suite_addTest test___logger
        suite_addTest test__log_output_of
        for t in $SPECIFIC_TESTS; do
            suite_addTest $t
        done
    }
fi

# Importing shunit2 triggers test enumeration, so must happen after
# all tests are defined.
. ${SHUNIT_INC}/shunit2

echo "shunit2 log is: ${LOGFILE}"
echo "mockdir is: ${MOCKDIR}"
