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.
#
test -n "${IMAGE_NAME-}" || false 'make sure $IMAGE_NAME is defined'
test -n "${VERSION-}" || false 'make sure $VERSION is defined'
test -n "${OS-}" || false 'make sure $OS is defined'

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

TEST_LIST_APP="\
test_s2i_usage
test_docker_run_usage
test_application
test_log_output
test_log_volume_output
test_application_user
"
TEST_LIST_HOOK_APP="test_pre_init_script"
TEST_LIST_PERL_APP="test_perl_directive"
TEST_LIST_MISC=run_dockerfiles_test


source "$test_dir/test-lib.sh"

# TODO: This should be part of the image metadata
test_port=8080

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() {
  ct_s2i_build_as_df file://${test_dir}/${1} ${IMAGE_NAME} ${IMAGE_NAME}-${1} ${s2i_args}
}

prepare() {
  if ! image_exists ${IMAGE_NAME}; then
    echo "ERROR: The image ${IMAGE_NAME} must exist before this script is executed."
    exit 1
  fi
  if ! [ -d "${test_dir}/${1}" ] ; then
    echo "ERROR: The testing app ${test_dir}/${1} does not exist."
    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 "Build the test application image"
  pushd ${test_dir}/${1} >/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() {
  run_args=${CONTAINER_ARGS:-}
  info "Running docker run --user=10001 ${run_args} -d --cidfile=${cid_file} ${IMAGE_NAME}-${1}"
  docker run --user=10001 ${run_args} -d --cidfile=${cid_file} ${IMAGE_NAME}-${1}
}

cleanup_test_app() {
  info "Cleaning up the test application"
  if [ -n "$cid_file" ] && [ -f "$cid_file" ]; then
    if container_exists; then
      docker stop $(cat $cid_file)
      docker rm $(cat $cid_file)
    fi
    rm $cid_file
  fi
}

check_result() {
  local result="$1"
  if [[ "$result" != "0" ]]; then
    cleanup_test_app
    TESTCASE_RESULT=1
  fi
  return $result
}

wait_for_cid() {
  local max_attempts=10
  local sleep_time=1
  local attempt=1
  local result=1
  info "Waiting for application container to start"
  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'"
  ct_s2i_usage ${IMAGE_NAME} ${s2i_args} &>/dev/null
}

test_docker_run_usage() {
  info "Testing 'docker run' usage"
  docker run --rm ${IMAGE_NAME} &>/dev/null
}

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

  info "Testing the image SCL enable"
  out=$(docker run --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
  test_command "$run_cmd" "$expected"
  return $?
}

test_command() {
  local run_cmd="$1"
  local expected="$2"
  local message="$3"
  echo "Test command"
  if [ $message ]; then
    info ${3}
  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

  return 0
}

test_logs() {
  local expected="$1"
  local message="$2"
  local logfile="$3"

  if [ "$message" ]; then
    info ${message}
  fi
  if [ "x$logfile" = "xstdouterr" ]; then
      out=$(docker logs $(cat ${cid_file}) 2>&1)
  elif [ "x$logfile" = "xstdout" ]; then
      out=$(docker logs $(cat ${cid_file}) 2>/dev/null)
  elif [ "x$logfile" = "xstderr" ]; then
      out=$(docker logs $(cat ${cid_file}) 2>&1 1>/dev/null)
  elif [ -n "$logfile" ]; then
      info "Extracting $logfile via docker exec <cont> cat ${logfile}..."
      out=$(docker exec $(cat ${cid_file}) cat ${logfile})
  else
      out=$(docker logs $(cat ${cid_file}) 2>&1)
  fi
  if ! echo "${out}" | egrep -q "${expected}"; then
    echo "ERROR[docker logs $logfile] Expected '${expected}', got '${out}'"
    return 1
  fi

  return 0
}

test_for_output() {
  local url="$1"
  local expect="$2"
  local host="${3-localhost}"
  local max_attempts=5
  local sleep_time=1
  local attempt=1
  local result=1

  info "Testing URL $url with HTTP hostname ${host} produces output $expect"

  while [ $attempt -le $max_attempts ]; do
    response=$(curl -is -H "Host: ${host}" ${url})
    status=$?
    echo "${response}"
    if [ $status -eq 0 ]; then
      if echo "${response}" | grep -q "${expect}"; then
        info "Success!"
        result=0
        break
      else
        echo "Response: ${response}"
      fi
    fi
    attempt=$(( $attempt + 1 ))
    sleep $sleep_time
  done

  return $result
}

test_connection() {
  cat $cid_file
  info "Testing the HTTP connection (http://$(container_ip):${test_port})"

  if test_for_output "http://$(container_ip):${test_port}/" "NGINX is working" &&
     test_for_output "http://$(container_ip):${test_port}/" "NGINX2 is working" localhost2 &&
     test_for_output "http://$(container_ip):${test_port}/aliased/index2.html" "NGINX2 is working"  &&
     test_for_output "http://$(container_ip):${test_port}/nginx-cfg/default.conf" "404"; then
     return 0
  fi

  return 1
}

test_connection_s2i() {
  cat $cid_file
  info "Testing the HTTP connection (http://$(container_ip):${test_port})"

  if test_for_output "http://$(container_ip):${test_port}/" "NGINX is working" &&
     test_for_output "http://$(container_ip):${test_port}/" "NGINX2 is working" localhost2 &&
     test_for_output "http://$(container_ip):${test_port}/nginx-cfg/default.conf" "404"; then
     return 0
  fi

  return 1
}

test_application() {
  # Verify that the HTTP connection can be established to test application container
  run_test_application "test-app" &

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

  test_scl_usage "nginx -v" "nginx version: nginx/${VERSION%%-*}."
  check_result $? || return 1

  test_connection
  check_result $? || return 1

  cleanup_test_app
  return 0
}

test_pre_init_script() {
  # Verify that the HTTP connection can be established to test application container
  run_test_application "start-hook-test-app" &

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

  test_command "cat /opt/app-root/etc/nginx.d/default.conf | grep 'resolver' | sed -e 's/resolver\(.*\);/\1/' | grep 'DNS_SERVER'" ""
  check_result $? || return 1

  test_connection_s2i
  check_result $? || return 1

  cleanup_test_app
  return 0
}

test_log_output() {
  info "Testing log output for $IMAGE_NAME"

  # Verify that the HTTP connection can be established to test application container
  run_test_application "test-app" &

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

  info "Testing that GET / was logged as 200"

  test_for_output "http://$(container_ip):${test_port}/" "NGINX is working"
  check_result $? || return 1

  test_logs '"GET / HTTP/1.1" 200' 'Test that GET / is logged as 200' stdout
  check_result $? || return 1

  info "Testing that GET /nothing-at-all was logged as 404"

  test_for_output "http://$(container_ip):${test_port}/nothing-at-all" "404"
  check_result $? || return 1

  test_logs '"GET /nothing-at-all HTTP/1.1" 404' 'Test that bad GET is logged as 404' stdout
  check_result $? || return 1

  test_logs 'open.*failed.*No such file or directory' 'Test that bad GET is logged to error.log' stdouterr
  check_result $? || return 1

  cleanup_test_app
  return 0
}

test_log_volume_output() {
  info "Testing log volume output for $IMAGE_NAME"

  # Verify that the HTTP connection can be established to test application container
  CONTAINER_ARGS="-e NGINX_LOG_TO_VOLUME=y" run_test_application "test-app" &

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

  info "Testing that GET / was logged as 200"

  test_for_output "http://$(container_ip):${test_port}/" "NGINX is working"
  check_result $? || return 1

  test_logs '"GET / HTTP/1.1" 200' 'Test that GET / is logged as 200' /var/log/nginx/access.log
  check_result $? || return 1

  info "Testing that GET /nothing-at-all was logged as 404"

  test_for_output "http://$(container_ip):${test_port}/nothing-at-all" "404"
  check_result $? || return 1

  test_logs '"GET /nothing-at-all HTTP/1.1" 404' 'Test that bad GET is logged as 404' /var/log/nginx/access.log
  check_result $? || return 1

  test_logs 'open.*failed.*No such file or directory' 'Test that bad GET is logged to error.log' /var/log/nginx/error.log
  check_result $? || return 1

  info "Log volume output tested successfully."

  cleanup_test_app
  return 0
}

test_perl_directive() {
  run_test_application "perl-test-app" &

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

  local perl_version=$(docker exec $(cat ${cid_file}) /bin/bash -c "perl -e 'print \"$^V\"'" 2>&1)

  info "Testing perl_set directive sets header with perl version"
  test_for_output "http://$(container_ip):${test_port}/" "X-Perl-Version: ${perl_version}"
  check_result $? || return 1

  info "Testing perl directive runs perl location handler"
  test_for_output "http://$(container_ip):${test_port}/perl" "Perl location handler is working"
  check_result $? || return 1

  cleanup_test_app
  return 0
}

test_application_user() {
  # Test application with random uid
  CONTAINER_ARGS="--user=12345" test_application
}

function build_image() {
  local test_name="$1"
  cid_file="$CID_FILE_DIR/$test_name"

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

  prepare "${test_name}"
  run_s2i_build "${test_name}"
  check_result $?
}

function run_dockerfiles_test() {
  # This is a hack for moby engine.
  # From unknown reason, moby does not like when using glob in a directory
  # behind a symlink. In this case, 1.22-micro is a symlink to 1.22 example
  # app and when using this example app, moby engine does not match *.html
  # files despite being there (confirmed that replacing glob with file names
  # works). Here we also expect that symlinks are only the micro variants,
  # so therefore we remove -micro suffix in case when the example app
  # directory is a symlink.
  exammple_to_use="$VERSION"
  if [ -L ${test_dir}/examples/$VERSION ] ; then
    exammple_to_use="${VERSION%-micro}"
    echo "WARNING: using '${exammple_to_use}' example app instead of '${VERSION}' to make the test work in moby"
  fi

  local dockerfile_tmp=$(mktemp)
  sed -e "s/^ENV NGINX_VERSION.*$/ENV NGINX_VERSION=$exammple_to_use/" -e "s/\$NGINX_VERSION/$exammple_to_use/g" "${test_dir}/examples/Dockerfile" >"$dockerfile_tmp"
  ct_test_app_dockerfile "$dockerfile_tmp" 'https://github.com/sclorg/nginx-container.git' "NGINX is working" nginx-container
  check_result $? || return 1
  sed -e "s/^ENV NGINX_VERSION.*$/ENV NGINX_VERSION=$exammple_to_use/" -e "s/\$NGINX_VERSION/$exammple_to_use/g" "${test_dir}/examples/Dockerfile.s2i" >"$dockerfile_tmp"
  ct_test_app_dockerfile "$dockerfile_tmp" 'https://github.com/sclorg/nginx-container.git' "NGINX is working" nginx-container
  check_result $? || return 1
  rm "$dockerfile_tmp"
}

ct_init

cid_file="$CID_FILE_DIR/$(mktemp -u -p . --suffix .cid)"

build_image "test-app"

# Run the chosen tests
TEST_SET=${TEST_LIST_APP} ct_run_tests_from_testset "test-app"

build_image "start-hook-test-app"

# Run the chosen tests
TEST_SET=${TEST_LIST_HOOK_APP} ct_run_tests_from_testset "start-hook-test-app"

# Run the chosen tests (not for micro variant which lacks perl)
if ! [[ "${IMAGE_NAME}" =~ .*micro.* ]] ; then
  build_image "perl-test-app"
  TEST_LIST=${TEST_LIST_PERL_APP} ct_run_tests_from_testset "perl-test-app"
fi


# Execute the rest of the tests
TEST_SET=${TEST_LIST_MISC} ct_run_tests_from_testset "miscellaneous-tests"
# vim: set tabstop=2:shiftwidth=2:expandtab: