run-integration-tests

#!/bin/bash
#
# Run integration tests for ringpop-go.
#
# Integration tests for different cluster sizes are run in parallel. Success
# output is suppressed and only the failures are shown.
#
# 2015-01-14
#
set -eo pipefail

declare project_root="${0%/*}/.."
declare ringpop_common_dir="${0%/*}/ringpop-common"
declare tap_filter="${ringpop_common_dir}/test/tap-filter.js"

declare test_cluster_sizes="1 2 3 4 5 10"
declare test_result=

declare temp_dir="$(mktemp -d)"

# Check node is installed
if ! type node &>/dev/null; then
    echo "ERROR: missing 'node'" >&2
    exit 1
fi

#
# Same as builtin wait, but return code is the number of background processes
# that exited with a non-zero code.
#
wait-all() {
    local -i failed=0

    # We need to explicitly loop through all background jobs and specify the
    # pids to `wait`, otherwise `wait` doesn't return the exit code.
    for pid in $(jobs -p); do
        wait $pid || let "failed+=1"
    done

    return $failed
}

#
# Echos and runs the specified command.
#
run() {
    echo "+ $@" >&2
    "$@"
}

#
# Copy stdin to stdout but prefix each line with the specified string.
#
prefix() {
    local _prefix=

    [ -n "$1" ] && _prefix="[$1] "
    while IFS= read -r -t 30 line; do
        echo "${_prefix}${line}"
    done
}

#
# Clones or updates the ringpop-common repository.
#
fetch-ringpop-common() {
    if [ ! -e "$ringpop_common_dir" ]; then
        run git clone --depth=1 https://github.com/uber/ringpop-common.git "$ringpop_common_dir"
    fi

    run cd "$ringpop_common_dir"
    #run git checkout master
    run git pull
    run cd - >/dev/null

    run cd "${ringpop_common_dir}/test"
    run npm install >/dev/null
    run cd - >/dev/null

    # Check tap-filter exists in ringpop-common. It is required to filter output
    # correctly to stdout/stderr
    if ! [ -x "$tap_filter" ]; then
        echo "ERROR: missing 'test/tap-filter.js' in ringpop-common" >&2
        exit 1
    fi
}

#
# Build the testpop binary.
#
build-testpop() {
    cd "$project_root"
    run make testpop
}

#
# Run test with specified cluster size.
#
# $1: cluster size
#
run-test-for-cluster-size() {
    local cluster_size=$1
    local err=0
    local output_file="${temp_dir}/${cluster_size}.out"

    # Run the tests and buffer the output to a log file. We'll display it later
    # if the test fails. This avoids interleaving of output to the terminal
    # when tests are running in parallel.
    node "${ringpop_common_dir}/test/it-tests.js" \
        -s "[$1]" "${project_root}/testpop" &>$output_file || err=$?

    if [ $PIPESTATUS -gt 0 ]; then
        echo "ERROR: Test errored for cluster size $cluster_size" | \
            prefix "test-errors-${cluster_size}" >&2
        return 1
    fi

    if [ $err -ne 0 ]; then
        # If the test failed, print a message and display the failures
        {
            echo "FAIL: Test failed for cluster size $cluster_size"
            # Output the test data through tap-filter, which discards success
            # info unless -v is specified.
            cat "$output_file" |$tap_filter

        } | prefix "test-errors-${cluster_size}" >&2

        return 1
    fi
}

#
# Run the integration tests against the testpop binary.
#
run-tests() {
    for cluster_size in $test_cluster_sizes; do
        echo "Spawning test for cluster size ${cluster_size}..." |prefix "test-runner"
        run-test-for-cluster-size $cluster_size &
    done

    {
        echo
        echo "Waiting for tests to complete."
        echo
        echo "To monitor test output (verbose), run:"
        echo "    tail -f ${temp_dir}/*.out"
        echo
    } \
        |prefix "test-runner"

    wait-all
}

# Fetch and build in parallel
{ fetch-ringpop-common 2>&1|prefix "fetch ringpop-common"; } &
{ build-testpop 2>&1|prefix "build testpop"; } &
wait-all

# Run integration tests
run-tests
test_result=$?

if [ $test_result -eq 0 ]; then
    echo "Tests passed"
    rm -rf "$temp_dir"
else
    echo "Tests failed" >&2
fi

exit $test_result