golang/test/run

#!/bin/bash
#
# The 'run' performs a simple test that verifies that S2I image.
# The main focus here is to excersise the S2I scripts.
#
# IMAGE_NAME specifies a name of the candidate image used for testing.
# The image has to be available before this script is executed.
#
export IMAGE_NAME=${IMAGE_NAME:-centos/go-toolset-7-centos7}

declare -a TEST_APPS=({simple,import-with-vendor,import-without-vendor,complete}-app)

# TODO: Make command compatible for Mac users
test_dir="$(readlink -zf $(dirname "${BASH_SOURCE[0]}"))"
image_dir=$(readlink -zf ${test_dir}/..)

info() {
  echo -e "\n\e[1m[INFO] $@\e[0m\n"
}

image_exists() {
  docker inspect $1 &>/dev/null
}

container_exists() {
  image_exists $(cat $cid_file)
}

container_ip() {
  docker inspect --format="{{ .NetworkSettings.IPAddress }}" $(cat $cid_file)
}

run_s2i_build() {
  info "Building the ${1} application image ..."
  pushd ${test_dir}/${1} >/dev/null
  ./s2i-build
  popd
}

incremental_test_clean_up(){
  rm -f run1
  rm -f run2
}

run_s2i_build_incremental(){
  info "Building the ${1} application image using incremental build ..."

  pushd ${test_dir}/${1} >/dev/null
  ./s2i-build-incremental &>run1
  ./s2i-build-incremental &>run2
  if grep "Clean build will be performed because of error saving previous build artifacts" run2; then
    cat run2
    info "Incremental build, artifact injection failed..."
    exit 1
  fi
  if ! grep "Restoring previous build artifacts" run2; then
    info "Incremental build, artifact restoration failed..."
    info "s2i invocation outputs"
    cat run1
    echo "------"
    cat run2
    exit 1
  fi

  incremental_test_clean_up

  popd
}

prepare() {
  if ! image_exists ${IMAGE_NAME}; then
    echo "ERROR: The image ${IMAGE_NAME} must exist before this script is executed."
    exit 1
  fi
  # TODO: S2I build require the application is a valid 'GIT' repository, we
  # should remove this restriction in the future when a file:// is used.
  info "Preparing to test ${1} ..."
  pushd ${test_dir}/${1}/app >/dev/null
  git init
  git config user.email "build@localhost" && git config user.name "builder"
  git add -A && git commit -m "Sample commit"
  popd >/dev/null
}

run_test_application() {
  docker run -t --user=100001 ${CONTAINER_ARGS} --rm --cidfile=${cid_file} ${IMAGE_NAME}-testapp
}

cleanup_app() {
  info "Cleaning up app container ..."
  if [ -f $cid_file ]; then
    if container_exists; then
      docker stop $(cat $cid_file)
    fi
  fi
}

cleanup() {
  info "Cleaning up the test application image"
  if image_exists ${IMAGE_NAME}-testapp; then
    docker rmi -f ${IMAGE_NAME}-testapp
  fi
  info "Cleaning up the test repository"
  if [ -d ${test_dir}/${1}/app/.git ]; then
    rm -rf ${test_dir}/${1}/app/.git
  fi
}

check_result() {
  local result="$1"
  if [[ "$result" != "0" ]]; then
    info "TEST FAILED (${result})"
    cleanup
    exit $result
  fi
}

wait_for_cid() {
  local max_attempts=10
  local sleep_time=1
  local attempt=1
  local result=1
  info "Waiting for application container to start $CONTAINER_ARGS ..."
  while [ $attempt -le $max_attempts ]; do
    [ -f $cid_file ] && [ -s $cid_file ] && break
    attempt=$(( $attempt + 1 ))
    sleep $sleep_time
  done
}

test_s2i_usage() {
  info "Testing 's2i usage' ..."
  s2i usage ${s2i_args} ${IMAGE_NAME}
}

test_docker_run_usage() {
  info "Testing 'docker run' usage ..."
  docker run ${IMAGE_NAME}
}

test_scl_usage() {
  local run_cmd="$1"
  local expected="$2"
  local cid_file="$3"

  info "Testing the image SCL enable"
  out=$(docker run -t --rm ${IMAGE_NAME} /bin/bash -c "${run_cmd}" 2>&1)
  if ! echo "${out}" | grep -q "${expected}"; then
    echo "ERROR[/bin/bash -c "${run_cmd}"] Expected '${expected}', got '${out}'"
    return 1
  fi
  out=$(docker exec $(cat ${cid_file}) /bin/bash -c "${run_cmd}" 2>&1)
  if ! echo "${out}" | grep -q "${expected}"; then
    echo "ERROR[exec /bin/bash -c "${run_cmd}"] Expected '${expected}', got '${out}'"
    return 1
  fi
  out=$(docker exec $(cat ${cid_file}) /bin/sh -ic "${run_cmd}" 2>&1)
  if ! echo "${out}" | grep -q "${expected}"; then
    echo "ERROR[exec /bin/sh -ic "${run_cmd}"] Expected '${expected}', got '${out}'"
    return 1
  fi
}

test_application() {
  local cid_file=$(mktemp -u --suffix=.cid)
  # Verify that the HTTP connection can be established to test application container
  run_test_application &

  # Wait for the container to write it's CID file
  wait_for_cid

  test_scl_usage "go version" "${EXPECTED_VER}" "${cid_file}"
  check_result $?
  cleanup_app
}


# Since we built the candidate image locally, we don't want S2I attempt to pull
# it from Docker hub
export s2i_args="-p never --incremental-pull-policy=never"

# determine what version of the Go are we testing base on the dir we are in
export EXPECTED_VER="go`pwd | awk -F "/" '{print $(NF)}'`"

# Verify the 'usage' script is working properly when running the base image with 's2i usage ...'
info "Testing image ${IMAGE_NAME} with go version ${EXPECTED_VER} "
test_s2i_usage
check_result $?

# Verify the 'usage' script is working properly when running the base image with 'docker run ...'
test_docker_run_usage
check_result $?

for app in ${TEST_APPS[@]}; do
  prepare ${app}
  run_s2i_build ${app}
  if [ -e ${test_dir}/${app}/s2i-build-incremental ]; then
    run_s2i_build_incremental ${app}
  fi
  check_result $?

  # test application with default user
  test_application

  # test application with random user
  CONTAINER_ARGS="-u 12345" test_application

  info "All tests for the ${app} finished successfully."
  cleanup ${app}
done

info "All tests finished successfully."