urchin/urchin

#!/bin/sh

# ----------------------------------------------------------------------
# Copyright (c) 2013, 2014, 2015, 2016 Thomas Levine
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# ----------------------------------------------------------------------


# ----------------------------------------------------------------------
# Copyright (c) 2014, Michael Klement
# Copyright (c) 2012, ScraperWiki Limited
# All rights reserved.
# 
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# 
# Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
#
# Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation
# and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------

set -e

# Delimiters
LF="$(printf '\n')"
HT="$(printf '\t')"

# Urchin version number
VERSION=0.0.0-master

# Kill subprocesses on interrupt.
trap "kill -$$; exit" HUP INT TERM

DEFAULT_SHELLS='
sh
bash
dash
ksh
posh
pdksh
mksh
yash
zsh
'
if [ -n "${ZSH_VERSION}" ]; then
  # avoid "no matches found: *" error when directories are empty
  setopt NULL_GLOB
  emulate sh
fi

# -------------------- Usage -------------------- 
USAGE="usage: $0 [options]... [test file or directory]..."

urchin_help() {
  cat <<EOF

${USAGE}

By default, Urchin checks for the following shells and runs every
particular test file once per shell.

  $(echo "${DEFAULT_SHELLS}" | sed 's/ /\n  /g')

On each run,

1. The TEST_SHELL environment variable is set to the particular shell.
2. If the test file lacks a shebang line or has a shebang line of
   "#!/bin/sh", the test script is also executed in that shell.

The following flags affect how this multiple-shell testing is handled.

-s, --shell <shell>      Tell Urchin to use a different list of shells.
                         (You can pass this flag multiple times.)

The following flags affect how Urchin processes tests.

-b, --run-in-series      Run tests in series. The default is to run tests
                         in parallel where possible.
-e, --exit-on-fail       Stop running if any single test fails.
                         This can be useful if you are running something
                         other than test files with Urchin.
-T, --timeout <seconds>  Kill a test if it runs for longer than the
                         specified duration. The default is no timeout.
-f, --force              Force running even if the test directory's name
                         does not contain the word "test".

These options affect how results are formatted. Options -q, and -v
have no effect when combined with formats other than "urchin".
-vv, -vvv, and -vvvv do have effect when combined with formats "urchin"
or "tap".

-p, --pretty             Print results in color and with fancy symbols.
-F, --format <name>      XXX

And these options affect how much is printed.

-q, --quiet              Print nothing to stdout;
                         the only output is the exit code.
(default verbosity)      Print names of failed tests and counts
                         of passed, failed, and skipped tests.
-v                       Print stdout from failing tests.
-vv                      Print names of passed tests.
-vvv, --verbose          Print stdout from all tests.
-vvvv, --debug           Run with set -x.

The remaining flags provide information about urchin.

-h, --help               Display this help.
--version                Display the version number.

Urchin recognizes certain environment variables.

TEST_SHELL           This is sometimes over-ridden; see -s.
RUN_IN_SERIES        Set this to have the same effect as
                     -b/--run-in-series. This is helpful if you are
                     calling urchin inside an urchin test suite.

Exit codes have the following meanings

0                    All tests were ok
1                    At least one test was not ok.
2                    No tests were found.
10                   Dependencies are missing (locally, not on remotes).
11                   Flags were not valid.
12                   File names contain unsupported delimiters (HT or LF).
13                   An test shell specified with -s/--shell is not available.

Go to https://thomaslevine.com/!/urchin/ for documentation on writing tests.

EOF
}

# -------------------- Portable wrappers -------------------- 
mktemp_dir() {
  # Support HP-UX mktemp that has wrong exit codes and
  # can't make directories.
  tmp=$(mktemp)
  if test -f "${tmp}"; then
    rm "${tmp}"
  fi
  mkdir "${tmp}"
  echo "${tmp}"
}

md5 () {
  case "${urchin_md5}" in
    md5sum) echo "${1}" | md5sum | sed 's/ .*//' ;;
    md5) echo "${1}" | md5 | sed 's/.* //' ;;
  esac
}

# -------------------- Utilities -------------------- 
if command -v md5 1> /dev/null 2> /dev/null; then
  urchin_md5=md5
elif command -v md5sum 1> /dev/null 2> /dev/null; then
  urchin_md5=md5sum
else
  echo Could not find MD5 hash command >&2
  exit 10
fi

epoch_date() {
  date +%s
}
epoch_pax() {
  # Based on http://stackoverflow.com/a/7262588/407226
  tmp="$(mktemp)"
  echo "ibase=8;$({ pax -wx cpio "${tmp}"; echo; } | cut -c 48-59)" | bc
  rm "${tmp}"
}

if epoch_date 2>&1 > /dev/null; then
  epoch=epoch_date
elif epoch_pax 2>&1 > /dev/null; then
  epoch=epoch_pax
else
  echo I could not find a seconds counter. >&2
  exit 10
fi



plural () {
  # Make $1 a plural according to the number $2.
  # If $3 is supplied, use that instead of "${1}s".
  # Result is written to stdout.
  if [ "${2}" = 1 ]; then
    echo "${1}"
  else
    echo "${3-${1}s}"
  fi
}

has_shebang_line() {
  head -n 1 "${1}" | grep -v '^#!/bin/sh$' | grep -q '^#!'
}

indent() {
  level="${1}"
  if test "${level}" -gt 0; then
    printf "%$((2 * ${level}))s"
  fi
}

# Expand relative paths
fullpath() {
  if test -e "${1}"; then
    readlink -f -- "${1}" | sed 's/\/*$//'
  else
    echo "Could not find file or directory: ${1}" >&2
    return 1
  fi
}

# If $1 is an ascestor of $2, echo the path of $2 relative $1.
# If either of $1 or $2 does not exist, return with code 1
# If $1 is not an ancestor of $2, return with code 2
# Otherwise, return with code 2.
localpath() {
  test -e "${1}" && test -e "${2}" || return 1 # A file is missing.

  parent="$(fullpath "${1}")"
  child="$(fullpath "${2}")"

  if echo "${child}" | grep "^${parent}/" > /dev/null; then
    # Child is really a child.
    echo "${child#"${parent}/"}"
    return 0
  else
    # Child is not really a child.
    return 2
  fi
}


contains() {
  case "$#" in
    1) grep "${1}" > /dev/null ;;
    2) echo "${1}" | contains "${2}" ;;
    3) contains "${1}" "${2}" && contains "${1}" "${3}" ;;
    *) container="${1}" && shift
       contains "${container}" "${1}" && shift &&
       contains "${container}" "${@}" ;;
   esac
}

is_set() {
  set | grep "^${1}=" > /dev/null
}

# File where a test's stdout and stderr is saved
stdout_file() {
  urchin_tmp="${1}"
  the_test="${2}"
  the_shell="${3}"

  x="${urchin_tmp}/stdout$(localpath "$the_test")"
  mkdir -p "${x}"
  echo "${x}/$(md5 "${the_shell}")"
}

# Print a line of a log file
log() {
  for arg in "$@"; do
    printf "${arg}\t"
  done
  printf '\n'
}

# Root directory of the present test suite
# USAGE: test_suite_root <directory>
test_suite_root() {
  # Call recursively but remember the original argument.
  orig="${2:-$1}"
  current="${1%/}"

  abscurrent="$(fullpath "${current}")"
  if test "${abscurrent}" = / ||
    basename "${abscurrent}" | contains '^\.' ; then
    # Stop traversing upwards at / and at hidden directories.
    if test -d "${orig}"; then
      echo "${orig}"
    else
      dirname -- "${orig}"
    fi
  elif ! test -e "${current}"; then
    echo "${current}: No such file or directory">&2
    return 1
  elif test -f "${current}"; then
    test_suite_root "$(dirname -- "${current}")" "${orig}"
  elif test -f "${current}"/.urchin_root; then
    echo "${current}"
  else
    test_suite_root "${current}"/.. "${orig}"
  fi
}

# -------------------- Printing output -------------------- 
# Format functions may read a log file from stdin.

meta_verbosity() {
  echo "if test \${${1}} -ge ${2}; then ${3}=true; fi"
}

format_tap() {
  v="${1}"
  urchin_tmp="${2}"
  elapsed="${3}"

  $(meta_verbosity v 2 print_not_ok_stdout)
  $(meta_verbosity v 3 print_ok_stdout)

  print_stdout() {
    echo '# ------------ Begin output ------------'
    sed 's/^/# /' "$(stdout_file "${urchin_tmp}" "${path}" "${the_shell}")"
    echo '# ------------ End output ------------'
  }

  while IFS="${HT}" read -r remote the_shell path result file_elapsed; do
    # Number of files that have run, including this one
    n=$(( ${n:-0} + 1))

    case "${result}" in
      ok) echo "ok $n - ${path} (${the_shell}${on})"
          if "${print_ok_stdout}"; then print_stdout; fi ;;
      not_ok) echo "not_ok $n - ${path} (${the_shell}${on})"
              if "${print_not_ok_stdout}"; then print_stdout; fi ;;
      skip) "ok $n - ${path} (${the_shell}${on}) # SKIP" ;;
    esac
    echo "# Previous test took ${file_elapsed} seconds."

  done

  echo "# Full test suite took ${elapsed} $(plural second ${elapsed})."
  echo 1.."${n}"
}

format_urchin() {
  v="${1}"
  urchin_tmp="${2}"
  verbosity="${3}"
  print_in_color="${4}"

  $(meta_verbosity v 1 print_margins)
  $(meta_verbosity v 1 print_not_ok)
  $(meta_verbosity v 2 print_not_ok_stdout)
  $(meta_verbosity v 2 print_ok)
  $(meta_verbosity v 3 print_ok_stdout)

  if $print_in_color; then
    success_mark=$(printf "\033[32m✓ \033[0m")
    fail_mark=$(printf "\033[31m✗ \033[0m")
  else
    success_mark=.\ 
    fail_mark=F\ 
  fi

  header() {
    if test "${prevdir}" != "${currentdir}"; then
      echo
    fi
    if test "${prevpath}" != "${path}"; then
      printf "$(dirname -- "${path}")/\n> $(basename -- "${path}")\n"
    fi
  }

  print_stdout() {
    sed 's/^/  | /' "$(stdout_file "${urchin_tmp}" "${path}" "${the_shell}")"
  }

  while IFS="${HT}" read -r remote the_shell path result file_elapsed; do
    abspath=${urchin_tmp}/${path}

    currentdir="$(dirname -- "${path}")"
    prevdir="${currentdir}"

    # Format the message
    if test -z "${remote}"; then
      on=" on ${remote}"
    else
      on=
    fi
    if test result = skip; then
      parantheses="(skipped)"
    else
      parantheses="(${file_elapsed} $(plural second "${file_elapsed}"))"
    fi
    message="${the_shell}${on} (${file_elapsed} ${unit})"

    # Keep track of how many files have been ok, not ok, and skipped.
    eval "${result}s=$((${result}s+1))"

    # Print the result.
    case "${result}" in
      ok) if "${print_ok}"; then
            header && echo "${success_mark} ${message}"
          fi ;;
      not_ok) if "${print_not_ok}"; then
                header && echo "${fail_mark} ${message}"
                if "${print_not_ok_stdout}"; then print_stdout; fi
              fi ;;
      skip) if "${print_ok}"; then
              header && echo "${skip_mark} ${message}"
              if "${print_ok_stdout}"; then print_stdout; fi
            fi ;;
    esac
    prevpath="${path}"
  done

  if "${print_margins}"; then
    echo
    echo "Done, took ${elapsed} $(plural second ${elapsed})."
    echo "${oks} $(plural test "${oks}") passed."
    echo "${skips} $(plural test "${skips}") skipped."
    echo "${not_oks} $(plural test "${not_oks}") failed."
  fi
}

# -------------------- Main stuff -------------------- 

# Return codes have the following meaning
# 0) All tests succeded
# 1) At least one test failed.
# *) Something else went wrong; Urchin should exit with the same code.
recurse() {
  echo "$3 $4 $5"
  abs_root="${1}"
  abs_requested="${2}"
  abs_current="${3}"

  run_in_series_root="${4}"
  exit_on_not_ok="${5}"

  rel_requested="$(localpath ${abs_root} ${abs_requested})"
  rel_current="$(localpath ${abs_root} ${abs_current})"

  for ignore in setup_dir teardown_dir setup teardown; do
    if test "$(basename "${abs_current}")" = "${ignore}"; then
      return 0
    fi
  done

  if contains "${abs_current}" "${HT}"; then
    echo "${shell_list}" | while read -r sh; do
      no_tab="$(echo "${rel_current}" | tr '\t' ' ')"
      log "${remote}" "${sh}" "${no_tab}" tab '' >> "${urchin_tmp}"/log
    done
  elif [ -x "${abs_current}" ]; then
    meta_finalize='
      if test -f .urchin_dir && grep series ./.urchin_dir > /dev/null ||
        "${run_in_series_root}"; then
        set +e
        wait ${!}
        return_code=$?
        set -e
        if "${exit_on_not_ok}" && test "${return_code}" -ne 0; then
          eval "$(meta_dot_if_exists teardown_dir)"
          return $return_code
        fi
      fi
    '
    meta_dot_if_exists() {
      echo "
      if test -f ${1}; then
        . ./${1}
      fi
      "
    }

    if [ -d "${abs_current}" ]; then
    (
      cd -- "${abs_current}"

      eval "$(meta_dot_if_exists setup_dir)"

      for test in *; do
        if test "${test}" = '*' && ! test -e "${test}"; then
          # The directory is empty.
          break
        fi

        recurse "${abs_root}" "${abs_requested}" "${abs_current}/${test}" \
                          "${run_in_series_root}" "${exit_on_not_ok}"
        #&
      # eval "${meta_finalize}"

      done
      wait
      eval "$(meta_dot_if_exists teardown_dir)"
    )
    elif [ -f "${abs_current}" ]; then
      cd -- "$(dirname -- "${abs_current}")"
      echo "${shell_list}" | while read -r sh; do
        (
          eval "$(meta_dot_if_exists setup)"

          out_file="$(stdout_file "${urchin_tmp}" "${rel_current}" "${sh}")"

          # Run with a shell?
          if has_shebang_line "${abs_current}"; then
            set -- "${abs_current}"
          else
            set -- "${sh}" "${abs_current}"
          fi

          # Run the test
          cmd='TEST_SHELL="${sh}" $TIMEOUT "$@"  > "${out_file}" 2>&1'
          start=$("${epoch}")
          exit_code="$(catch "${cmd}")"
          finish=$("${epoch}")
          elapsed=$(($finish - $start))

          eval "$(meta_dot_if_exists teardown)"

          case "${exit_code}" in
            0) result=ok ;;
            3) result=skip ;;
            *) result=not_ok ;;
          esac

          log "${remote}" "${rel_curent}" "${result}" "${elapsed}" \
            >> "${urchin_tmp}"/log
          exit "${exit_code}"
        )
        #&
      # eval "${meta_finalize}"
      done
     #wait
    fi
  elif test -n "${rel_current}"; then
    # Skip because the file is not executable.
    echo "${shell_list}" | while read -r sh; do
      printf "\t${sh}\t${rel_current}\tskip\t0\n" >> "${urchin_tmp}"/log
    done
  fi
  echo ${rel_current} 3 >> /tmp/bbb
}

main() {
  # Defaults
  format=urchin
  if "${RUN_IN_SERIES}" 2> /dev/null; then
    run_in_series=true
  else
    run_in_series=false
  fi
  exit_on_not_ok=false

  # Shift if possible; error otherwise.
  flag_arg() {
    flag="${1}"
    if shift; then
      echo "${1}"
    else
      echo Missing argument for "${flag}" >&2
      exit 11
    fi
  }

  # Receive input
  while [ "${#}" -gt 0 ]; do
    case "${1}" in
        -b|--run-in-series) run_in_series=true;;
        -e|--exit-on-fail) exit_on_not_ok=true;;
        -f|--force) force=true;;

        -F|--format) format="$(flag_arg)" ;;
        -p|--pretty) print_in_color=true;;

        -q|--quiet)     verbosity=0 ;;
        -v)             verbosity=2 ;;
        -vv)            verbosity=3 ;;
        -vvv|--verbose) verbosity=4 ;;
        -vvvv|--debug)  verbosity=5 ;;

        --version) echo "${VERSION}" && exit;;
        -h|--help) urchin_help && exit 0;;

        -s|--shell) sh="$(flag_arg)"
          if ! command -v "${sh}" > /dev/null; then
            echo "Cannot find specified shell: '${sh}'" >&2
            urchin_help >&2
            exit 13
          elif contains "${potential_test}" "${HT}" "${LF}"; then
            echo 'Shell paths may contain all characters other than' >&2
            echo 'horizontal tab (\t) and line feed (\n).' >&2
            exit 11
          elif contains "${sh}" "[${IFS}]"; then
            echo "Warning: It is best if field-separator characters
(usually spaces) are absent from shell paths so that
you don't need to quote the TEST_SHELL variable." >&2
          fi
          shell_list="${sh}${LF}${shell_list}" ;;

        -T|--timeout) urchin_timeout="$(flag_arg)" 
          if ! contains "${urchin_timeout}" \
            '[0-9][0-9.]*\(s\|m\|h\|d\|\)' ; then
            echo Bad timeout argument: "${urchin_timeout}" >&2
            exit 11
          fi ;;

        -*) urchin_help >&2 && exit 11;;
        *) if contains "${1}" "${HT}" "${LF}"; then
             echo 'Test file names may contain all characters other than' >&2
             echo 'horizontal tab (\t) and line feed (\n).' >&2
             exit 11
           elif [ ! -e "${1}" ]; then
             echo "No such file or directory: '${1}'" >&2
             echo "${USAGE}" >&2
             exit 11
           elif ! {
             # Molly guard
             root="$(test_suite_root "${1}")"
             basename "$(fullpath "${root}")" |
             grep -i 'test' > /dev/null
           }; then
             molly=true
           fi
           test_seeds="${1}${LF}${test_seeds}" ;;
    esac
    shift
  done

  if ! is_set test_seeds; then
    echo Missing test location >&2
    exit 2
  fi

  if is_set molly && ! is_set force; then
    echo 'The root directory of the tests that you are running urchin on
doesnot contain the word "test", so I am not running,
in case that was an accident. Use the -f flag if you really
want to run urchin on that directory.' >&2
    exit 12
  fi

  # If -s was not passed, use the available default shells.
  if ! is_set "${shell_list}"; then
    if $cycle_shell; then
      for shell in $DEFAULT_SHELLS; do
        if command -v "${shell}" 1> /dev/null 2> /dev/null; then
          shell_list="${shell}${HT}${shell_list}"
        fi
      done
    fi
  fi

  if is_set urchin_timeout; then
    # Choose the timeout command
    if timeout -t 0 true 2> /dev/null; then
      TIMEOUT="timeout -t ${urchin_timeout}"
    elif timeout 0 true 2> /dev/null; then
      TIMEOUT="timeout ${urchin_timeout}"
    else
      echo I couldn\'t figure out how to use your version of timeout >&2
      exit 10
    fi
  fi

  if is_set exit_on_not_ok && ! is_set run_in_series; then
    echo 'You must also pass -b/--series in order to use -e/--exit-on-fail.' >&2
    exit 11
  fi

  # --------------------   REALLY RUN   -------------------- #

  # Temporary files
  urchin_tmp=$(mktemp_dir)

  # Write header information
  echo Running tests at $(date +%Y-%m-%dT%H:%M:%S) >> "${urchin_tmp}"/head
  printf 'Cycling with the following shells: ' >> "${urchin_tmp}"/head
  echo "${shell_list}" | tr "${HT}" \  >> "${urchin_tmp}"/head
  echo >> "${urchin_tmp}"/head

  start=$("${epoch}")
  while read -r seed; do
    root="$(fullpath "$(test_suite_root "${seed}")")"
    abs="$(fullpath "${seed}")"

    set +e
    recurse "${root}" "${abs}" "${root}" \
      "${run_in_series}" "${exit_on_not_ok}"
    return_code=$?
    set -e
    echo $return_code
    if test "${return_code}" -eq 0; then break; fi
  done<<EOF
  ${test_seeds}
EOF
  finish=$("${epoch}")

  if test "${return_code}" -le 1; then
    if test -f "${urchin_tmp}"/log ; then
      cat "${urchin_tmp}"/head

# "${urchin_tmp}"/log
# elapsed=$(($finish - $start))

# # Use a temporary file rather than a pipe because a pipe starts a sub-shell
# # and thus makes the above variables local.
# sorted_log_file=$(mktemp)
# cat "${log_file}" | LC_COLLATE=C sort > "${sorted_log_file}"

# rm "${sorted_log_file}"

# test "${not_oks}" -eq '0'


    else
      echo 'No tests found' >&2
      return_code=2
    fi
  fi

  rm -Rf "${urchin_tmp}"
  exit "${return_code}"
}

echo "kill -$$"
is_set NO_MAIN || main "$@"