471 lines
13 KiB
Bash
Executable file
471 lines
13 KiB
Bash
Executable file
#!/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'
|
|
|
|
# TODO: Make command compatible for Mac users
|
|
test_dir="$(readlink -f $(dirname "${BASH_SOURCE[0]}"))"
|
|
image_dir=$(readlink -f ${test_dir}/..)
|
|
test_short_summary=''
|
|
TESTSUITE_RESULT=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_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
|
|
# 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
|
|
}
|
|
|
|
cleanup() {
|
|
info "Cleaning up the test application image"
|
|
if image_exists ${IMAGE_NAME}-${1}; then
|
|
docker rmi -f ${IMAGE_NAME}-${1}
|
|
fi
|
|
rm -rf ${test_dir}/${1}/.git
|
|
}
|
|
|
|
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 ${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 run_all_tests() {
|
|
local APP_NAME="${1:-}"
|
|
for test_case in $TEST_LIST; do
|
|
info "Running test $test_case ...."
|
|
TESTCASE_RESULT=0
|
|
$test_case
|
|
check_result $?
|
|
local test_msg
|
|
if [ $TESTCASE_RESULT -eq 0 ]; then
|
|
test_msg="[PASSED]"
|
|
else
|
|
test_msg="[FAILED]"
|
|
TESTSUITE_RESULT=1
|
|
fi
|
|
printf -v test_short_summary "%s %s %s\n" "${test_short_summary}" "${test_msg}" "$test_case"
|
|
[ -n "${FAIL_QUICKLY:-}" ] && cleanup "${APP_NAME}" && return 1
|
|
done;
|
|
[ -n "${APP_NAME}" ] && cleanup "${APP_NAME}"
|
|
}
|
|
|
|
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 $?
|
|
}
|
|
|
|
test_scl_enable() {
|
|
echo "Testing nginx availability in Dockerfile"
|
|
ct_binary_found_from_df nginx
|
|
check_result $? || return 1
|
|
|
|
echo "Testing variable presence during \`docker exec\`"
|
|
ct_check_exec_env_vars
|
|
check_result $? || return 1
|
|
|
|
echo "Checking if all scl variables are defined in Dockerfile"
|
|
ct_check_scl_enable_vars
|
|
check_result $? || return 1
|
|
}
|
|
|
|
function run_dockerfiles_test() {
|
|
local dockerfile_tmp=$(mktemp)
|
|
sed -e "s/^ENV NGINX_VERSION.*$/ENV NGINX_VERSION=$VERSION/" -e "s/\$NGINX_VERSION/$VERSION/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=$VERSION/" -e "s/\$NGINX_VERSION/$VERSION/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
|
|
rm "$dockerfile_tmp"
|
|
}
|
|
|
|
CID_FILE_DIR=$(mktemp -d)
|
|
|
|
build_image "test-app"
|
|
|
|
# Run the chosen tests
|
|
TEST_LIST=${TEST_LIST_APP} run_all_tests "test-app"
|
|
|
|
build_image "start-hook-test-app"
|
|
|
|
# Run the chosen tests
|
|
TEST_LIST=${TEST_LIST_HOOK_APP} run_all_tests "start-hook-test-app"
|
|
|
|
build_image "perl-test-app"
|
|
|
|
# Run the chosen tests
|
|
TEST_LIST=${TEST_LIST_PERL_APP} run_all_tests "perl-test-app"
|
|
|
|
# Run the rest of the tests by defining TEST_LIST to include the rest of the relevant cases
|
|
TEST_LIST=run_dockerfiles_test
|
|
|
|
# These tests only make sense for rhscl
|
|
if [ "$OS" == "rhel7" ] || [ "$OS" == "centos7" ]; then
|
|
# autocleanup only enabled here as only the following tests so far use it
|
|
ct_enable_cleanup
|
|
TEST_LIST="$TEST_LIST test_scl_enable"
|
|
fi
|
|
|
|
# Execute the rest of the tests depending on what TEST_LIST includes now
|
|
run_all_tests
|
|
|
|
# All tests executed, see the results
|
|
echo "$test_short_summary"
|
|
|
|
if [ $TESTSUITE_RESULT -eq 0 ] ; then
|
|
echo "Tests for ${IMAGE_NAME} succeeded."
|
|
else
|
|
echo "Tests for ${IMAGE_NAME} failed."
|
|
fi
|
|
|
|
exit $TESTSUITE_RESULT
|