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)

    _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

# 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

        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.

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

    error "No roles can be tested."

    exit $ERROR_NO_ROLES

fi

# 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"

    # Run tests.

    cd "$role_dir"

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

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

    else

        report_file="/dev/null"

    fi

    info "Running tests for: $role"

    molecule_result=0

    if [[ $tests == all ]]; then

        molecule test --destroy always 2>&1 | tee "$report_file"

        last_pipe_status="${PIPESTATUS[0]}"

        [[ $last_pipe_status == 0 ]] || molecule_result="$last_pipe_status"

    elif [[ $tests == lint ]]; then