#!/bin/bash

#

# run_tests.sh

#

# Copyright (C) 2017, Branko Majic <branko@majic.rs>

#

# 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 3 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/>.

#

program="run_tests.sh"

function usage() {

    cat <<EOF

$program, a non-interactive utility for running role tests for Majic Ansible

Roles

Usage: $program [OPTIONS] (all|role1 ... roleN)

$program is a non-interactive utility for running role tests for Majic Ansible

Roles.

The script iterates over all roles within sub-directory "roles" (relative to

working directory) that have a valid Molecule configuration, runs the tests, and

optionally writes report for all tested roles (see option -r).

Only the default scenario is tested at the moment.

$program accepts the following options:

    -r

        Generate report for all roles under sub-directory of current

        directory "test_report-YYYY_MM_DD-hh_mm". Within the

        sub-directory each role will have its own file named

        "role-ROLENAME.txt". In addition, a summary file (summary.txt)

        is produced with overview of which roles have passed, failed,

        and which roles were skipped.

    -l all|lint

        Limit what type of tests should be run. Currently supported

        values are:

        all

            Runs all the available tests. This is the default.

        lint

            Runs only the linting tests. This is useful for performing

            a quick check on syntax prior to running more extensive

            testing.

    -d

        Enable debug mode.

    -v

        Show script licensing information.

    -h

        Show usage help.

Please report bugs and send feature requests to <branko@majic.rs>.

EOF

}

function version() {

    cat <<EOF

$program

+-----------------------------------------------------------------------+

| Copyright (C) 2017, Branko Majic <branko@majic.rs>                    |

|                                                                       |

| 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 3 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/>. |

+-----------------------------------------------------------------------+

EOF

}

# Set-up colours for message printing if we're not piping and terminal is

# capable of outputting the colors.

_color_terminal=$(tput colors 2>&1)

if [[ -t 1 ]] && (( _color_terminal > 0 )); then

    _text_bold=$(tput bold)

    _text_white=$(tput setaf 7)

    _text_blue=$(tput setaf 6)

    _text_green=$(tput setaf 2)

    _text_yellow=$(tput setaf 3)

    _text_red=$(tput setaf 1)

    _text_reset=$(tput sgr0)

else

    _text_bold=""

    _text_white=""

    _text_blue=""

    _text_green=""

    _text_yellow=""

    _text_red=""

    _text_reset=""

fi

# Set-up functions for printing coloured messages.

function debug() {

    if [[ $debug != 0 ]]; then

        echo "${_text_bold}${_text_blue}[DEBUG]${_text_reset}" "$@"

    fi

}

function info() {

    echo "${_text_bold}${_text_white}[INFO] ${_text_reset}" "$@"

}

function success() {

    echo "${_text_bold}${_text_green}[OK]   ${_text_reset}" "$@"

}

function warning() {

    echo "${_text_bold}${_text_yellow}[WARN] ${_text_reset}" "$@"

}

function error() {

    echo "${_text_bold}${_text_red}[ERROR]${_text_reset}" "$@" >&2

}

# Define error codes.

SUCCESS=0

ERROR_ARGUMENTS=1

ERROR_NO_ROLES=2

ERROR_MISSING_BINARY=3

ERROR_FAILED_ROLES=4

ERROR_REPORT=5

# Disable debug mode by default.

debug=0

# Default values.

report=0

tests=all

# If no arguments were given, just show usage help.

if [[ -z $1 ]]; then

    usage

    exit "$SUCCESS"

fi

# Parse the arguments

while getopts "rl:qdvh" opt; do

    case "$opt" in

        r) report=1;;

        l) tests="$OPTARG";;

	d) debug=1;;

        v) version

           exit "$SUCCESS";;

        h) usage

           exit "$SUCCESS";;

        *) usage

           exit "$ERROR_ARGUMENTS";;

    esac

done

i=$OPTIND

shift $(( i-1 ))

# Test if the necessary binaries are available.

if ! type molecule > /dev/null 2>&1; then

    error "Could not locate binary: molecule. Please ensure you are running the script from within correctly set-up Python virtual environment."

    exit $ERROR_MISSING_BINARY

fi

# Assume success.

test_result=0

# Verify arguments.

if [[ $tests != "all" && $tests != "lint" ]]; then

    error "Unsupported type of tests requested: $tests"

    exit $ERROR_ARGUMENTS

fi

# Assemble list of roles to run against.

roles=()

roles_to_test=()

roles_to_skip=()

# Assemble list of roles to test.

if [[ $1 == "all" ]]; then

    debug "Testing of all roles was requested, assembling role list."

    # Traverse directory.

    for role_dir in roles/*; do

        if [[ -d $role_dir ]]; then

            debug "Located candiate role in directory $role_dir"

            roles+=("${role_dir#roles/}")

        else

            debug "Ignoring non-directory $role_dir"

        fi

    done

else

    while [[ -n $1 ]]; do

        roles+=("$1")

        shift 1

    done

fi

if [[ ${#roles[@]} == 0 ]]; then

    error "No role has been specified for testing."

    exit $ERROR_ARGUMENTS

fi

# Determine which roles have available tests.

for role in "${roles[@]}"; do

    role_dir="roles/$role"

    if [[ ! -d "roles/$role" ]]; then

        warning "Could not locate role $role in directory $role_dir"

        roles_to_skip+=("$role")

    elif [[ -f "$role_dir/molecule/default/molecule.yml" ]]; then

        debug "Role $role contains Molecule configuration."

         roles_to_test+=("$role")

    else

        warning "Role $role cannot be tested - missing Molecule configuration."

        roles_to_skip+=("$role")

    fi

done

# Output some helpful info, and ensure we can actually run tests against

# something.

info "Testing requested for roles: ${roles[*]}"

[[ ${#roles_to_skip[@]} != 0 ]] && info "The following roles will not be tested: ${roles_to_skip[*]}"

if [[ ${#roles_to_test[@]} == 0 ]]; then

    error "No roles can be tested."

    exit $ERROR_NO_ROLES

fi

info "The following roles will be tested: ${roles_to_test[*]}"

# Prepare directory for storing reports.

if [[ $report == 1 ]]; then

    report_directory="$(pwd)/test_report-$(date +%Y_%m_%d-%H_%M_%S)"

    report_summary="${report_directory}/summary.txt"

    if ! mkdir "$report_directory"; then

        error "Failed to create report directory $report_directory"

        exit $ERROR_REPORT

    fi

    touch "$report_summary"

    debug "Created report directory $report_directory."

    # Output skipped roles to summary immediatelly.

    for role in "${roles_to_skip[@]}"; do

        echo "[SKIP] $role" >> "$report_summary"

    done

else

    debug "No report directory will be created."

fi

# Test the roles.

passed_roles=()

failed_roles=()

work_dir="$(pwd)"

for role in "${roles_to_test[@]}"; do

    # Calculate directories between which we need to move.

    role_dir="$work_dir/roles/$role"

    if [[ $report == 1 ]]; then

        report_file="$report_directory/role-${role}.txt"

    else

        report_file="/dev/null"

    fi

    info "Running tests for: $role"

    last_pipe_status="${PIPESTATUS[0]}"

        last_pipe_status="${PIPESTATUS[0]}"

        last_pipe_status="${PIPESTATUS[0]}"

        last_pipe_status="${PIPESTATUS[0]}"

    fi

    # Determine result.

        passed_roles+=("$role")

        [[ $report == 1 ]] && echo "[PASS] $role" >> "$report_summary"

    else

        test_result=$ERROR_FAILED_ROLES

        failed_roles+=("$role")

        # Log failure in summary if requested.

        [[ $report == 1 ]] && echo "[FAIL] $role" >> "$report_summary"

    fi

done

for role in "${roles_to_skip[@]}"; do

    warning "SKIP: $role"

done

for role in "${passed_roles[@]}"; do

    success "PASS: $role"

done

for role in "${failed_roles[@]}"; do

    error "FAIL: $role"

done

exit $test_result