#!/bin/bash
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#
#   Unit testing library for BeakerLib
#   Author: Ales Zelinka <azelinka@redhat.com>
#   Author: Petr Splichal <psplicha@redhat.com>
#
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#
#   Copyright (c) 2010 Red Hat, Inc. All rights reserved.
#
#   This copyrighted material is made available to anyone wishing
#   to use, modify, copy, or redistribute it subject to the terms
#   and conditions of the GNU General Public License version 2.
#
#   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, write to the Free
#   Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
#   Boston, MA 02110-1301, USA.
#
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#
#   This is a simple unit testing library for BeakerLib.
#   Have a look at the README file to learn more about it.


# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#   Global variables
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

TotalFailed="0"
TotalPassed="0"
FileList=""
TestList=""

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#   assertLog comment [result] --- log a comment (with optional result)
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

assertLog() {
    local comment="$1"
    local result="${2:-INFO}"

    # colorify known results if run on terminal
    if [ -t 1 ]; then
        case $result in
            INFO) result="\033[0;34mINFO\033[0m";;
            PASS) result="\033[0;32mPASS\033[0m";;
            FAIL) result="\033[0;31mFAIL\033[0m";;
            WARN) result="\033[0;33mWARN\033[0m";;
            SKIP) result="\033[0;37mSKIP\033[0m"
                  ((__INTERNAL_ASSERT_SKIPPED++))
                  ((TotalSkipped++))
                ;;
        esac
    fi

    # echo!
    echo -e " [ $result ] $comment"
}


# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#   assertRun command [status] [comment] --- run command, check status, log
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

assertRun() {
    local command="$1"
    local expected="${2:-0}"
    local comment="${3:-Running $command}"

    # no output unless in debug mode
    if [ "$DEBUG" == "1" ]; then
        eval "$command"
    else
        eval "$command" &> /dev/null
    fi
    local status=$?

    # check status
    if [[ "$status" =~ ^$expected$ ]]; then
        assertLog "$comment" 'PASS'
        ((__INTERNAL_ASSERT_PASSED++))
        ((TotalPassed++))
    else
        assertLog "$comment" 'FAIL'
        ((__INTERNAL_ASSERT_FAILED++))
        ((TotalFailed++))
        [ "$DEBUG" == "1" ] && assertLog "Expected $expected, got $status"
    fi
}

silentIfNotDebug() {
    local command="$1"
    if [ "$DEBUG" == "1" ]
    then
      eval "$command"
    else
      eval "$command" &> /dev/null
    fi
}

journalReset() {
  rm -f $__INTERNAL___INTERNAL_BEAKERLIB_JOURNAL $__INTERNAL___INTERNAL_BEAKERLIB_METAFILE $__INTERNAL___INTERNAL_BEAKERLIB_JOURNAL_TXT $__INTERNAL___INTERNAL_BEAKERLIB_JOURNAL_COLORED $__INTERNAL_PRESISTENT_DATA
  [ -e "$BEAKERLIB_DIR" ] && ( chmod -R 777 $BEAKERLIB_DIR ; rm -rf $BEAKERLIB_DIR; )
  unset __INTERNAL_RPM_ASSERTED_PACKAGES
  silentIfNotDebug 'rlJournalStart'
}

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#   assertStart name --- start an assert phase
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

assertStart() {
    local phase="$1"
    echo
    assertLog "Testing $phase"
    __INTERNAL_ASSERT_PHASE="$phase"
    __INTERNAL_ASSERT_PASSED="0"
    __INTERNAL_ASSERT_FAILED="0"
    __INTERNAL_ASSERT_SKIPPED="0"
}


# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#   assertEnd --- short phase summary (returns number of failed asserts)
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

assertEnd() {
    local failed="$__INTERNAL_ASSERT_FAILED"
    local passed="$__INTERNAL_ASSERT_PASSED"
    local skipped="$__INTERNAL_ASSERT_SKIPPED"
    local name="$__INTERNAL_ASSERT_PHASE"

    if [ "$failed" -gt "0" ]; then
        assertLog "Testing $name finished: $passed passed, $failed failed, $skipped skipped" "FAIL"
    elif [ "$passed" -gt "0" ]; then
        assertLog "Testing $name finished: $passed passed, $failed failed, $skipped skipped" "PASS"
    else
        assertLog "Testing $name finished: No assserts run" "WARN"
    fi

    printf "%i:%i:%i\n" $__INTERNAL_ASSERT_PASSED $__INTERNAL_ASSERT_FAILED $__INTERNAL_ASSERT_SKIPPED>> $SCOREFILE
}


# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#   assertTrue comment command --- check that command succeeded
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

assertTrue() {
    local comment="$1"
    local command="$2"

    assertRun "$command" 0 "$comment"
}


# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#   assertFalse comment command --- check that command failed
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

assertFalse() {
    local comment="$1"
    local command="$2"
    local expects="${3:-1}"

    assertRun "$command" "$expects" "$comment"
}


# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#   assertGoodBad command good bad --- check for good/bad asserts in journal
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

assertGoodBad() {
    local command="$1"
    local good="$2"
    local bad="$3"

    if [[ -n "$good" ]]; then
        rm -f $__INTERNAL_BEAKERLIB_JOURNAL $__INTERNAL_BEAKERLIB_METAFILE $__INTERNAL___INTERNAL_BEAKERLIB_JOURNAL_TXT $__INTERNAL___INTERNAL_BEAKERLIB_JOURNAL_COLORED $__INTERNAL_PRESISTENT_DATA; rlJournalStart
        assertTrue "$good good logged for '$command'" \
                "rlPhaseStart FAIL; $command; rlPhaseEnd;
                rlJournalPrintText | egrep 'Assertions: *$good *good, *[0-9]+ *bad'"
    fi

    if [[ -n "$bad" ]]; then
        rm -f $__INTERNAL_BEAKERLIB_JOURNAL $__INTERNAL_BEAKERLIB_METAFILE $__INTERNAL___INTERNAL_BEAKERLIB_JOURNAL_TXT $__INTERNAL___INTERNAL_BEAKERLIB_JOURNAL_COLORED $__INTERNAL_PRESISTENT_DATA; rlJournalStart
        assertTrue "$bad bad logged for '$command'" \
                "rlPhaseStart FAIL; $command; rlPhaseEnd;
                rlJournalPrintText | egrep 'Assertions: *[0-9]+ *good, *$bad *bad'"
    fi
    rm -f $__INTERNAL_BEAKERLIB_JOURNAL $__INTERNAL_BEAKERLIB_METAFILE $__INTERNAL___INTERNAL_BEAKERLIB_JOURNAL_TXT $__INTERNAL___INTERNAL_BEAKERLIB_JOURNAL_COLORED $__INTERNAL_PRESISTENT_DATA
}


# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#   assertParameters assert --- check missing parameters
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

assertParameters() {
	journalReset
	assertTrue "running '$1' (all parameters) must succeed" \
	"rlPhaseStart FAIL; $1 ; rlPhaseEnd ;  rlJournalPrintText |grep '1 *good'"
	local CMD=""
	for i in $1 ; do
		CMD="${CMD}${i} "
		if [ "x$CMD" == "x$1 " ] ; then break ; fi
		#echo "--$1-- --$CMD--"
		journalReset
		assertFalse "running just '$CMD' (missing parameters) must not succeed" \
	    "rlPhaseStart FAIL; $CMD ; rlPhaseEnd ;  rlJournalPrintText |grep '1 *good'"
	done
}


# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#   Fake rhts-report-result
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

rhts-report-result(){
  echo -e "ANCHOR NAME: $1\nRESULT: $2\nLOGFILE: $3\nSCORE: $4"
}



# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#   Self test --- run a simple self test if called as 'test.sh test'
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

if [ "$1" == "test" ]; then
    assertStart "logging"
        assertLog "Some comment with a pass" "PASS"
        assertLog "Some comment with a fail" "FAIL"
    assertEnd

    assertStart "passing asserts"
        assertRun "true"
        assertRun "true" 0
        assertRun "true" 0 "Checking true with assertRun"
        assertRun "false" 1
        assertRun "false" 1 "Checking false with assertRun"
        assertTrue "Checking true with assertTrue" "true"
        assertFalse "Checking false with assertFalse" "false"
    assertEnd

    assertStart "failing asserts"
        assertRun "false"
        assertRun "false" 0
        assertRun "false" 0 "Checking false with assertRun"
        assertRun "true" 1
        assertRun "true" 1 "Checking true with assertRun"
        assertTrue "Checking false with assertTrue" "false"
        assertFalse "Checking true with assertFalse" "true"
    assertEnd

    [ $TotalPassed == 7 -a $TotalFailed == 7 ] && exit 0 || exit 1
fi



# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#   Run the tests
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

# set important variables & start journal
export BEAKERLIB="$PWD/.."
export TESTID='123456'
export TEST='beakerlib-unit-tests'
. ../beakerlib.sh
export __INTERNAL_JOURNALIST="$BEAKERLIB/python/journalling.py"
export OUTPUTFILE=$(mktemp) # no-reboot
export SCOREFILE=$(mktemp) # no-reboot
rlJournalStart

# check parameters for test list
for arg in "$@"; do
    # selected test function
    if [[ "$arg" =~ 'test_' ]]; then
        TestList="$TestList $arg"
    # test file
    elif [[ "$arg" =~ 'Test.sh' ]]; then
        FileList="$FileList $arg"
    else
        echo "What do you mean by $arg?"
        exit 1
    fi
done

# unless test files specified run all available
[[ -z "$FileList" ]] && FileList="$(ls *Test.sh)"

# load all test functions
for file in $FileList; do
    . $file || { echo "Could not load $file"; exit 1; }
done

assessFile(){
    local file="$1"
    assertStart ${file%Test.sh}
    for test in $(grep --text -o '^test_[^ (]*' $file); do
        assertLog "Running $test"
        silentIfNotDebug "journalReset"
        $test
    done
    assertEnd
}

export TIMEFORMAT="System: %S seconds; User: %U seconds"
TIMEFILE=$( mktemp -u ) # no-reboot
# run all tests
if [[ -z "$TestList" ]]; then
    for file in $FileList; do
      (time ( { assessFile $file; } 2>&3 ) ) 3>&2 2>>$TIMEFILE.$( basename $file )
      OLDTIMEFILE=".$( basename $file)-perf.old"
      if [ -e $OLDTIMEFILE ]
      then
        OLDPERF="$( cat $OLDTIMEFILE )"
      fi
      assertLog "Measurement: $( cat $TIMEFILE.$( basename $file ) )"
      if [ -n "$OLDPERF" ]
      then
        assertLog "        Was: $OLDPERF"
      fi
    done
# run selected tests only
else
    for test in $TestList; do
        assertStart "$test"
        silentIfNotDebug "journalReset"
        $test
        assertEnd
    done
fi

# clean up
rm -rf $BEAKERLIB_DIR

# print summary
echo
for file in $( ls ${TIMEFILE}* 2>/dev/null )
do
    OLDTIMEFILE=".${file#$TIMEFILE.}-perf.old"
    assertLog "${file#$TIMEFILE.} performance: $( cat $file )"
    if [ -e $OLDTIMEFILE ]
    then
      assertLog "${file#$TIMEFILE.}   Was:       $( cat $OLDTIMEFILE )"
    fi
    cat $file > $OLDTIMEFILE
done

while read line
do
  PASS=$( echo $line | cut -d ':' -f 1)
  FAIL=$( echo $line | cut -d ':' -f 2 )
  SKIP=$( echo $line | cut -d ':' -f 3 )
  TotalPassed=$(( $TotalPassed+$PASS ))
  TotalFailed=$(( $TotalFailed+$FAIL ))
  TotalSkipped=$(( $TotalSkipped+$SKIP ))
done < $SCOREFILE

rm -rf $TIMEFILE* $SCOREFILE

if [ $TotalPassed -gt 0 -a $TotalFailed == 0 ]; then
    assertLog "Total summary: $TotalPassed passed, $TotalFailed failed, $TotalSkipped skipped\n" "PASS"
    exit 0
else
    assertLog "Total summary: $TotalPassed passed, $TotalFailed failed, $TotalSkipped skipped\n" "FAIL"
    exit 1
fi