257 lines
6.7 KiB
Bash
Executable file
257 lines
6.7 KiB
Bash
Executable file
#!/bin/bash
|
|
#
|
|
# The 'run' performs a simple test that verifies the S2I image.
|
|
# The main focus here is to exercise the S2I scripts.
|
|
#
|
|
# For more information see the documentation:
|
|
# https://github.com/openshift/source-to-image/blob/master/docs/builder_image.md
|
|
#
|
|
# IMAGE_NAME specifies a name of the candidate image used for testing.
|
|
# The image has to be available before this script is executed.
|
|
#
|
|
IMAGE_NAME=${IMAGE_NAME-nodejs-candidate}
|
|
|
|
# Determining system utility executables (darwin compatibility check)
|
|
READLINK_EXEC="readlink"
|
|
MKTEMP_EXEC="mktemp"
|
|
if [[ "$OSTYPE" =~ 'darwin' ]]; then
|
|
! type -a "greadlink" &>"/dev/null" || READLINK_EXEC="greadlink"
|
|
! type -a "gmktemp" &>"/dev/null" || MKTEMP_EXEC="gmktemp"
|
|
fi
|
|
|
|
test_dir="$($READLINK_EXEC -zf $(dirname "${BASH_SOURCE[0]}"))"
|
|
image_dir=$($READLINK_EXEC -zf ${test_dir}/..)
|
|
scripts_url="file://${image_dir}/.s2i/bin"
|
|
cid_file=$($MKTEMP_EXEC -u --suffix=.cid)
|
|
|
|
# Since we built the candidate image locally, we don't want S2I to attempt to pull
|
|
# it from Docker hub
|
|
s2i_args="--force-pull=false"
|
|
|
|
# Port the image exposes service to be tested
|
|
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() {
|
|
if [ ! -z "$DOCKER_HOST" ] && [[ "$OSTYPE" =~ 'darwin' ]]; then
|
|
docker-machine ip
|
|
else
|
|
docker inspect --format="{{ .NetworkSettings.IPAddress }}" $(cat $cid_file)
|
|
fi
|
|
}
|
|
|
|
container_logs() {
|
|
docker logs $(cat $cid_file)
|
|
}
|
|
|
|
container_port() {
|
|
if [ ! -z "$DOCKER_HOST" ] && [[ "$OSTYPE" =~ 'darwin' ]]; then
|
|
docker inspect --format="{{(index .NetworkSettings.Ports \"$test_port/tcp\" 0).HostPort}}" "$(cat "${cid_file}")"
|
|
else
|
|
echo $test_port
|
|
fi
|
|
}
|
|
|
|
run_s2i_build() {
|
|
s2i build --incremental=true ${s2i_args} file://${test_dir}/test-app ${IMAGE_NAME} ${IMAGE_NAME}-testapp
|
|
}
|
|
|
|
prepare() {
|
|
if ! image_exists ${IMAGE_NAME}; then
|
|
echo "ERROR: The image ${IMAGE_NAME} must exist before this script is executed."
|
|
exit 1
|
|
fi
|
|
# s2i build requires the application is a valid 'Git' repository
|
|
pushd ${test_dir}/test-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 --rm --cidfile=${cid_file} -p ${test_port} $1 ${IMAGE_NAME}-testapp
|
|
}
|
|
|
|
cleanup() {
|
|
if [ -f $cid_file ]; then
|
|
if container_exists; then
|
|
docker stop $(cat $cid_file)
|
|
fi
|
|
fi
|
|
if image_exists ${IMAGE_NAME}-testapp; then
|
|
docker rmi -f ${IMAGE_NAME}-testapp
|
|
fi
|
|
rm -rf ${test_dir}/test-app/.git
|
|
}
|
|
|
|
check_result() {
|
|
local result="$1"
|
|
if [[ "$result" != "0" ]]; then
|
|
echo "S2I image '${IMAGE_NAME}' test FAILED (exit code: ${result})"
|
|
cleanup
|
|
exit $result
|
|
fi
|
|
}
|
|
|
|
wait_for_cid() {
|
|
local max_attempts=10
|
|
local sleep_time=1
|
|
local attempt=1
|
|
local result=1
|
|
while [ $attempt -le $max_attempts ]; do
|
|
[ -f $cid_file ] && break
|
|
echo "Waiting for container to start..."
|
|
attempt=$(( $attempt + 1 ))
|
|
sleep $sleep_time
|
|
done
|
|
}
|
|
|
|
test_s2i_usage() {
|
|
echo "Testing 's2i usage'..."
|
|
s2i usage ${s2i_args} ${IMAGE_NAME} &>/dev/null
|
|
}
|
|
|
|
test_docker_run_usage() {
|
|
echo "Testing 'docker run' usage..."
|
|
docker run ${IMAGE_NAME} &>/dev/null
|
|
}
|
|
|
|
validate_default_value() {
|
|
local label=$1
|
|
|
|
IFS=':' read -a label_vals <<< $(docker inspect -f "{{index .Config.Labels \"$label\"}}" ${IMAGE_NAME})
|
|
label_var=${label_vals[0]}
|
|
default_label_val=${label_vals[1]}
|
|
|
|
actual_label_val=$(docker run --rm $IMAGE_NAME /bin/bash -c "echo $"$label_var)
|
|
|
|
if [ "$actual_label_val" != "$default_label_val" ]; then
|
|
echo "ERROR default value for $label with environment variable $label_var; Expected $default_label_val, got $actual_label_val"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# Gets the NODE_ENV environment variable from the container.
|
|
get_node_env_from_container() {
|
|
local dev_mode="$1"
|
|
local node_env="$2"
|
|
|
|
IFS=':' read -a label_val <<< $(docker inspect -f '{{index .Config.Labels "com.redhat.dev-mode"}}' $IMAGE_NAME)
|
|
dev_mode_label_var="${label_val[0]}"
|
|
|
|
echo $(docker run --rm --env $dev_mode_label_var=$dev_mode --env NODE_ENV=$node_env $IMAGE_NAME /bin/bash -c 'echo "$NODE_ENV"')
|
|
}
|
|
|
|
# Ensures that a docker container run with '--env NODE_ENV=$current_val' produces a NODE_ENV value of $expected when
|
|
# DEV_MODE=dev_mode.
|
|
validate_node_env() {
|
|
local current_val="$1"
|
|
local dev_mode_val="$2"
|
|
local expected="$3"
|
|
|
|
actual=$(get_node_env_from_container "$dev_mode_val" "$current_val")
|
|
if [ "$actual" != "$expected" ]; then
|
|
echo "ERROR default value for NODE_ENV when development mode is $dev_mode_val; should be $expected but is $actual"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
test_connection() {
|
|
echo "Testing HTTP connection (http://$(container_ip):$(container_port))"
|
|
local max_attempts=10
|
|
local sleep_time=1
|
|
local attempt=1
|
|
local result=1
|
|
while [ $attempt -le $max_attempts ]; do
|
|
echo "Sending GET request to http://$(container_ip):$(container_port)/"
|
|
response_code=$(curl -s -w %{http_code} -o /dev/null http://$(container_ip):$(container_port)/)
|
|
status=$?
|
|
if [ $status -eq 0 ]; then
|
|
if [ $response_code -eq 200 ]; then
|
|
result=0
|
|
fi
|
|
break
|
|
fi
|
|
attempt=$(( $attempt + 1 ))
|
|
sleep $sleep_time
|
|
done
|
|
return $result
|
|
}
|
|
|
|
# Build the application image twice to ensure the 'save-artifacts' and
|
|
# 'restore-artifacts' scripts are working properly
|
|
prepare
|
|
run_s2i_build
|
|
check_result $?
|
|
|
|
info "Save-artifacts test passed successfully"
|
|
|
|
# Verify the 'usage' script is working properly
|
|
test_s2i_usage
|
|
check_result $?
|
|
|
|
info "Usage test passed successfully"
|
|
|
|
# Verify the 'usage' script is working properly when running the base image with 'docker run ...'
|
|
test_docker_run_usage
|
|
check_result $?
|
|
|
|
info "Run usage test passed successfully"
|
|
|
|
# Verify that the HTTP connection can be established to test application container
|
|
run_test_application &
|
|
|
|
# Wait for the container to write its CID file
|
|
wait_for_cid
|
|
|
|
test_connection
|
|
check_result $?
|
|
|
|
info "Connection test passed successfully"
|
|
|
|
echo "Testing DEV_MODE=false"
|
|
logs=$(container_logs)
|
|
echo ${logs} | grep -q DEV_MODE=false
|
|
check_result $?
|
|
echo ${logs} | grep -q NODE_ENV=production
|
|
check_result $?
|
|
echo ${logs} | grep -q DEBUG_PORT=5858
|
|
check_result $?
|
|
|
|
info "Production test passed"
|
|
|
|
docker kill $(cat $cid_file)
|
|
rm $cid_file
|
|
|
|
echo "Testing DEV_MODE=true"
|
|
run_test_application "-e DEV_MODE=true" &
|
|
wait_for_cid
|
|
|
|
test_connection
|
|
check_result $?
|
|
|
|
logs=$(container_logs)
|
|
echo ${logs} | grep -q DEV_MODE=true
|
|
check_result $?
|
|
echo ${logs} | grep -q NODE_ENV=development
|
|
check_result $?
|
|
echo ${logs} | grep -q DEBUG_PORT=5858
|
|
check_result $?
|
|
|
|
info "Development test passed"
|
|
|
|
cleanup
|
|
|
|
info "All tests finished successfully."
|