Tinmarino
429 lines
11 KiB
Bash
Executable File
429 lines
11 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
# shellcheck disable=SC2155 # Declare and assign separately to avoid masking return values
|
|
|
|
: '
|
|
Vimwiki vader test script
|
|
|
|
Credit: https://github.com/w0rp/ale for script ideas and the color vader output function.
|
|
'
|
|
|
|
# Capture start time now
|
|
declare -g start_time=$(date +%s)
|
|
|
|
|
|
printHelp() {
|
|
: 'Print usage to stdout'
|
|
cat << ' EOF' | sed -e 's/^ //'
|
|
Usage: bash run_tests.sh [OPTIONS]
|
|
|
|
Runs Vimwiki Vader tests or Vint in a Docker container
|
|
|
|
-h (Help) Print help message
|
|
|
|
-n (versioN) Specify vim/nvim version to run tests for.
|
|
Specify "local" to run on your current vim install
|
|
for example on Windows.
|
|
Multiple versions can be specified by quoting the value and
|
|
separating versions with a space. E.g. -n "vim1 vim2".
|
|
Default is all available versions.
|
|
|
|
-f (File) Space separated list of tests to run.
|
|
E.g. -o "list_* z_success"
|
|
|
|
-l (List) list available versions that can be used with the '-n' option
|
|
|
|
-t (Type) Select test type: 'vader', 'vint', or 'all'
|
|
|
|
-v (Verbose) Turn on verbose output.
|
|
|
|
E.g. On Linux without with local Vim
|
|
bash run_tests.sh -v -t vader -n local -f link_creation.vader issue_markdown.vader
|
|
|
|
E.g. On Linux
|
|
bash run_tests.sh -v -t vader -n "vim_7.4.1099 vim_8.1.0519" -f link_creation.vader issue_markdown.vader
|
|
|
|
E.g. On Windows
|
|
bash run_tests.sh -v -t vader -n local -f z_success.vader | cat
|
|
EOF
|
|
|
|
exit 0
|
|
}
|
|
|
|
|
|
run_test(){
|
|
: 'Main function'
|
|
local -i res=0
|
|
|
|
# Hi
|
|
echo -en "Starting $(basename "$0") for VimWiki\n"
|
|
|
|
# Hook ctrl-c or ctrl-z to stop tests
|
|
trap exit 1 SIGINT SIGTERM
|
|
|
|
# For windows: Cmder bash is appending busybox to the path and
|
|
# and a smlll vim is included, so that override the windows path vim
|
|
if [[ -v OLD_PATH ]]; then
|
|
echo "Setting path from OLD_PATH : $OLD_PATH"
|
|
export PATH="$OLD_PATH"
|
|
fi
|
|
|
|
# WORK
|
|
parse_argument "$@"; ((res |= $?))
|
|
execute_test_argument; ((res |= $?))
|
|
|
|
# Print ellapsed time (after calculate it)
|
|
end_time=$(date +%s)
|
|
sec_time=$((end_time - start_time))
|
|
printf -v script_time '%dh:%dm:%ds' $((sec_time/3600)) $((sec_time%3600/60)) $((sec_time%60))
|
|
echo -ne "Script $(basename "$0"), in $script_time, Returned -> $res\n\n"
|
|
|
|
return "$res"
|
|
}
|
|
|
|
|
|
parse_argument(){
|
|
: 'Parse user argument'
|
|
# Declare color helper
|
|
declare -g red='\033[0;31m'
|
|
declare -g green='\033[0;32m'
|
|
declare -g nc='\033[0m'
|
|
|
|
# Declare: Path of the script, supposing no spaces
|
|
declare -g g_script_file=$(dirname "$0")
|
|
declare -g g_script_path=$(realpath "$g_script_file")
|
|
declare -g g_wiki_path=$(realpath "$g_script_path/..")
|
|
declare -g g_tmp_dir=$(dirname "$(mktemp -u)")
|
|
|
|
# Declare: list of vim/nvim versions
|
|
declare -g g_vers="$(print_versions)"
|
|
|
|
# Declare: type of tests to run - vader/vint/all
|
|
declare -g g_type="all"
|
|
|
|
# Declare: verbose output flag
|
|
declare -g g_verbose=0
|
|
|
|
# Declare: only run these tests
|
|
declare -g g_file_test=""
|
|
|
|
# Declare: docker flags
|
|
declare -g flags=(--rm -v "$PWD/../:/testplugin" -v "$PWD/../test:/home" -w /testplugin vimwiki)
|
|
|
|
# Parse all argument options
|
|
while getopts ":hvn:lt:f:" opt; do
|
|
case ${opt} in
|
|
h)
|
|
printHelp
|
|
;;
|
|
n)
|
|
g_vers="$OPTARG"
|
|
;;
|
|
v)
|
|
g_verbose=1
|
|
;;
|
|
l)
|
|
print_versions
|
|
;;
|
|
t)
|
|
g_type="$OPTARG"
|
|
;;
|
|
f)
|
|
g_file_test="$OPTARG"
|
|
;;
|
|
\?)
|
|
echo "Invalid option: $OPTARG" 1>&2
|
|
exit 1
|
|
;;
|
|
:)
|
|
echo "Invalid option: $OPTARG requires an argument" 1>&2
|
|
exit 1
|
|
;;
|
|
esac
|
|
done
|
|
|
|
# Shift out parameters already processed
|
|
shift $((OPTIND -1))
|
|
|
|
# Handle error for non-option arguments
|
|
if [[ $# -ne 0 ]]; then
|
|
echo "Error: Got $# non-option arguments." 1>&2
|
|
exit 1
|
|
fi
|
|
}
|
|
|
|
|
|
execute_test_argument(){
|
|
: 'Execute test according to global variable'
|
|
# Global error return of the script
|
|
local -i res=0 ret=0
|
|
|
|
# Select and run tests
|
|
case $g_type in
|
|
vader)
|
|
run_vader; ret=$?
|
|
echo "Main Vader: returned $ret"
|
|
((res |= ret))
|
|
;;
|
|
vint)
|
|
run_vint; ret=$?
|
|
echo "Main Vint: returned $ret"
|
|
((res |= ret))
|
|
;;
|
|
all)
|
|
run_vint; ret=$?
|
|
echo "Main Vint: returned $ret"
|
|
((res |= ret))
|
|
run_vader; ret=$?
|
|
echo "Main Vader: returned $ret"
|
|
((res |= ret))
|
|
;;
|
|
*)
|
|
echo "Error: invalid type - '$g_type'" 1>&2
|
|
exit 1
|
|
esac
|
|
|
|
return "$res"
|
|
}
|
|
|
|
|
|
print_versions() {
|
|
: 'Print the names of all vim/nvim versions'
|
|
# Get all possible version <- Dockerfile
|
|
sed -n 's/.* -name \([^ ]*\) .*/\1/p' ../Dockerfile
|
|
exit 0
|
|
}
|
|
|
|
|
|
run_vader() {
|
|
: 'Run Vader tests'
|
|
echo -e "\nStarting Vader tests."
|
|
local -i res=0
|
|
local opt='' current_test=''
|
|
|
|
echo "Tin 1 $g_file_test"
|
|
# Parse tests files to execute
|
|
if [[ -z "$g_file_test" ]]; then
|
|
opt="test/*"
|
|
else
|
|
read -ra TEST <<< "$g_file_test"
|
|
for current_test in "${TEST[@]}"; do
|
|
# Remove quotes
|
|
current_test=${current_test#\'}
|
|
current_test=${current_test%\'}
|
|
if [[ "$current_test" == *"*"* ]]; then
|
|
opt+=" test/${current_test}"
|
|
elif [[ -f "$current_test" ]]; then
|
|
opt+=" test/${current_test}"
|
|
elif [[ -f "${current_test}.vader" ]]; then
|
|
opt+=" test/${current_test}.vader"
|
|
else
|
|
printf "WARNING: Test \"%s\" not found.\n", "$current_test"
|
|
fi
|
|
done
|
|
fi
|
|
echo "Tin 2 $opt"
|
|
|
|
# Run tests for each specified version
|
|
for v in $g_vers; do
|
|
echo -e "\n\nRunning version: $v"
|
|
echo -e "============================="
|
|
|
|
# Set local environment variables
|
|
if [[ "$v" == "local" ]]; then
|
|
# Save HOME var
|
|
home_save="$HOME"
|
|
|
|
# Create temporary root
|
|
mkdir -p "$g_tmp_dir/vader_wiki"
|
|
mkdir -p "$g_tmp_dir/vader_wiki/home"
|
|
mkdir -p "$g_tmp_dir/vader_wiki/home/test"
|
|
mkdir -p "$g_tmp_dir/vader_wiki/testplugin"
|
|
|
|
# Set vars
|
|
export ROOT="$g_tmp_dir/vader_wiki/"
|
|
export HOME="$g_tmp_dir/vader_wiki/home"
|
|
vim="vim"
|
|
vim_opt="-u ~/test/vimrc"
|
|
else
|
|
# Only set dockerized vars
|
|
export ROOT="/" # So no if in vimrc
|
|
vim="/vim-build/bin/$v"
|
|
vim_opt="-u test/vimrc"
|
|
fi
|
|
|
|
# Too talkative TODO make a verbose level 1..10 an 1 is not taking vim
|
|
#if [[ "$verbose" != 0 ]]; then
|
|
# vim_opt+=' -V1'
|
|
#fi
|
|
# IDK why vim with -Es is returning ! and make fail:
|
|
# -- tabnext profiling
|
|
# -- map.vim
|
|
vim_opt+=' -i NONE -Es '
|
|
|
|
# set -o pipefail
|
|
|
|
# Copy the resources to temporary directory
|
|
if [[ "$v" == "local" ]]; then
|
|
# flags=(--rm -v "$PWD/../:/testplugin" -v "$PWD/../test:/home" -w /testplugin vimwiki)
|
|
echo -e "\nCopying resources to $ROOT"
|
|
# Copy testplugin
|
|
cp -rf "$g_wiki_path/"* "$ROOT/testplugin/"
|
|
# Copy home
|
|
cp -rf "$g_script_path/"* "$HOME/test/"
|
|
# Copy rtp.vim
|
|
cp -rf "$g_script_path/resources/rtp_local.vim" "$ROOT/rtp.vim"
|
|
# Copy vader <- internet
|
|
echo 'Cloning Vader (git, do not care the fatal)'
|
|
git clone --depth 10 https://github.com/junegunn/vader.vim /tmp/vader_wiki/vader 2>&1
|
|
fi
|
|
|
|
# Run batch of tests
|
|
# shellcheck disable=SC2086,SC2206
|
|
if [[ "$opt" != "" ]]; then
|
|
if [[ "$v" == "local" ]]; then
|
|
pushd "$g_tmp_dir/vader_wiki/testplugin" \
|
|
|| echo 'Warning pushd testplugin failed'
|
|
|
|
# Run the tests
|
|
fcmd(){
|
|
$vim $vim_opt "+Vader! ${opt}" 2>&1 \
|
|
| vader_filter | vader_color
|
|
return ${PIPESTATUS[1]}
|
|
}
|
|
echo -e "\nStarting Batch Vim/Vader:\n<- $opt\n"
|
|
type fcmd | sed -n '/^ /{s/^ //p}' | sed '$s/.*/&;/' ; shift ;
|
|
fcmd; ret=$?
|
|
echo -e "\nReturned Batch Vim/Vader -> $ret"
|
|
(( res |= ret ))
|
|
|
|
popd || echo 'Warning popd failed'
|
|
else
|
|
# In docker
|
|
fcmd() {
|
|
docker run -a stderr -e "VADER_OUTPUT_FILE=/dev/stderr" \
|
|
"${flags[@]}" "$v" $vim_opt "+Vader! ${opt}" 2>&1 \
|
|
| vader_filter | vader_color
|
|
return ${PIPESTATUS[1]}
|
|
}
|
|
echo -e "\nStarting Batch Vim/Vader with: $opt\n"
|
|
type fcmd | sed -n '/^ /{s/^ //p}' | sed '$s/.*/&;/' ; shift ;
|
|
fcmd; ret=$?
|
|
echo -e "\nReturned Batch Docker/Vim/Vader -> $ret : ${PIPESTATUS[*]}"
|
|
(( res |= ret ))
|
|
fi
|
|
fi
|
|
|
|
#set +o pipefail
|
|
|
|
# Restore what must (I know it should be refactored in a while)
|
|
if [[ "$v" == local ]]; then
|
|
export HOME=$home_save
|
|
fi
|
|
done
|
|
return "$res"
|
|
}
|
|
|
|
|
|
run_vint() {
|
|
: 'Run Vint test'
|
|
local -i res=0
|
|
|
|
local cmd="vint -s . && vint -s test/vimrc"
|
|
|
|
if echo "$g_vers" | grep "local" > /dev/null; then
|
|
echo -e "\nRunning Vint: $cmd : in $g_wiki_path"
|
|
pushd "$g_wiki_path" > /dev/null \
|
|
|| echo 'Warning pushd wiki_path failed'
|
|
$cmd
|
|
res=$(( res | $? ))
|
|
popd > /dev/null \
|
|
|| echo 'Warning popd also failed'
|
|
else
|
|
echo -e "\nStarting Docker container and running Vint: $cmd"
|
|
docker run -a stdout "${flags[@]}" bash -c "$cmd"
|
|
res=$(( res | $? ))
|
|
fi
|
|
|
|
return "$res"
|
|
}
|
|
|
|
|
|
vader_filter() {
|
|
: 'Pipe Helper: Filter Vader Stdout'
|
|
local -i res=0
|
|
# Keep indentation
|
|
local IFS=''
|
|
|
|
while read -r REPLY; do
|
|
# Print only possible error cases
|
|
if [[ "$REPLY" = *'docker:'* ]] || \
|
|
[[ "$REPLY" = *'Starting Vader:'* ]] || \
|
|
[[ "$REPLY" = *'Vader error:'* ]] || \
|
|
[[ "$REPLY" = *'Vim: Error '* ]]; then
|
|
echo "$REPLY"
|
|
elif [[ "$REPLY" = *'[EXECUTE] (X)'* ]] || \
|
|
[[ "$REPLY" = *'[ DO] (X)'* ]] || \
|
|
[[ "$REPLY" = *'[ EXPECT] (X)'* ]]; then
|
|
echo -e "$red$REPLY$nc"
|
|
res=1
|
|
elif [[ "$REPLY" = *'Success/Total:'* ]]; then
|
|
success="$(echo -n "$REPLY" | grep -o '[0-9]\+/' | head -n1 | cut -d/ -f1)"
|
|
total="$(echo -n "$REPLY" | grep -o '/[0-9]\+' | head -n1 | cut -d/ -f2)"
|
|
if [ "$success" -lt "$total" ]; then
|
|
res=1
|
|
fi
|
|
echo "$REPLY"
|
|
elif [[ "$g_verbose" != 0 ]]; then
|
|
# just print everything
|
|
echo "$REPLY"
|
|
fi
|
|
done
|
|
|
|
if (( res == 1 )); then
|
|
echo -e "\033[0;31m"
|
|
echo -e "!---------Failed tests detected---------!"
|
|
echo -e "Run with the '-v' flag for verbose output"
|
|
echo -e "\033[0m"
|
|
fi
|
|
|
|
return "$res"
|
|
}
|
|
|
|
|
|
vader_color() {
|
|
: 'Pipe Helper: Filter to add color to Vader'
|
|
while read -r; do
|
|
if [[ "$REPLY" = *'[EXECUTE] (X)'* ]] || \
|
|
[[ "$REPLY" = *'[ EXPECT] (X)'* ]] || \
|
|
[[ "$REPLY" = *'Vim: Error '* ]] || \
|
|
[[ "$REPLY" = *'Vader error:'* ]]; then
|
|
echo -en "$red"
|
|
elif [[ "$REPLY" = *'[EXECUTE]'* ]] || [[ "$REPLY" = *'[ GIVEN]'* ]]; then
|
|
echo -en "$nc"
|
|
fi
|
|
|
|
if [[ "$REPLY" = *'Success/Total'* ]]; then
|
|
success="$(echo -n "$REPLY" | grep -o '[0-9]\+/' | head -n1 | cut -d/ -f1)"
|
|
total="$(echo -n "$REPLY" | grep -o '/[0-9]\+' | head -n1 | cut -d/ -f2)"
|
|
|
|
if [ "$success" -lt "$total" ]; then
|
|
echo -en "$red"
|
|
else
|
|
echo -en "$green"
|
|
fi
|
|
|
|
echo "$REPLY"
|
|
echo -en "$nc"
|
|
else
|
|
echo "$REPLY"
|
|
fi
|
|
done
|
|
|
|
echo -en "$nc"
|
|
}
|
|
|
|
|
|
if ! (return 0 2>/dev/null); then
|
|
run_test "$@"; exit $?
|
|
fi
|