root
/
rabbitmq-server
mirror of https://github.com/rabbitmq/rabbitmq-server.git
1
0
Fork 0
Code Issues Actions 9 Packages Projects Releases Wiki Activity
rabbitmq-server/selenium/bin/suite_template

772 lines
21 KiB
Bash
Raw Permalink Blame History

#!/usr/bin/env bash
if [[ ! -z "${DEBUG}" ]]; then
set -x
fi
SCRIPT="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
SUITE=$(caller)
SUITE=$(basename "${SUITE}" .sh )
tabs 1
declare -i PADDING_LEVEL=0
declare -i STEP=1
declare -a REQUIRED_COMPONENTS
find_selenium_dir() {
TEST_PATH=$1
FOUND=""
while [[ $TEST_PATH != "" && $FOUND == "" ]]; do
FILENAME=$(basename "$TEST_PATH")
if [[ $FILENAME == "selenium" ]]; then
FOUND=$TEST_PATH
fi
TEST_PATH="$(dirname $TEST_PATH)"
done
echo $FOUND
}
SELENIUM_ROOT_FOLDER=$(find_selenium_dir $SCRIPT)
TEST_DIR=$SELENIUM_ROOT_FOLDER/test
BIN_DIR=$SELENIUM_ROOT_FOLDER/bin
if [[ -z "${CONF_DIR_PREFIX}" ]]; then
CONF_DIR_PREFIX=$(mktemp -d)
fi
CONF_DIR=${CONF_DIR_PREFIX}/selenium/${SUITE}
SCREENS=${CONF_DIR}/screens
LOGS=${CONF_DIR}/logs
ENV_FILE=$CONF_DIR/.env
OTHER_ENV_FILE=$CONF_DIR/.other.env
rm -rf $CONF_DIR
for f in $SCRIPT/components/*; do
if [[ ! "$f" == *README.md ]]
then
source $f;
fi
done
parse_arguments() {
if [[ "$#" -gt 0 ]]
then
if [[ "$1" == "start-rabbitmq" ]]
then
echo "start-rabbitmq"
elif [[ "$1" == "start-other-rabbitmq" ]]
then
echo "start-other-rabbitmq"
elif [[ "$1" == "start-others" ]]
then
echo "start-others"
elif [[ "$1" == "ensure-others" ]]
then
echo "ensure-others"
elif [[ "$1" == "stop-others" ]]
then
echo "stop-others"
elif [[ "$1" == "stop-rabbitmq" ]]
then
echo "stop-rabbitmq"
elif [[ "$1" == "test" ]]
then
echo "test $2"
fi
else
echo "run"
fi
}
COMMAND=$(parse_arguments $@)
print() {
tabbing=""
if [[ $PADDING_LEVEL -gt 0 ]]; then
for i in $(seq $PADDING_LEVEL); do
tabbing="$tabbing\t"
done
fi
echo -e "$tabbing$1"
}
begin() {
print "\n[$STEP] $@"
PADDING_LEVEL=$(($PADDING_LEVEL + 1))
STEP=$(($STEP + 1))
}
end() {
PADDING_LEVEL=$(($PADDING_LEVEL - 1))
print "$@"
}
ensure_docker_network() {
begin "Ensuring $DOCKER_NETWORK network ..."
if [ ! "$(docker network ls | grep $DOCKER_NETWORK)" ]; then
print "> DOCKER_NETWORK: $DOCKER_NETWORK created"
docker network create $DOCKER_NETWORK
fi
end "$DOCKER_NETWORK network exists"
}
init_suite() {
TEST_CASES_DIR=$(realpath ${TEST_DIR}${TEST_CASES_PATH:?"missing TEST_CASES_PATH"})
if [ -z "${TEST_CONFIG_PATH}" ]; then TEST_CONFIG_DIR=$TEST_CASES_DIR
else TEST_CONFIG_DIR=$(realpath ${TEST_DIR}${TEST_CONFIG_PATH})
fi
DOCKER_NETWORK=${DOCKER_NETWORK:-rabbitmq_net}
begin "Initializing suite $SUITE ..."
print "> REQUIRED_COMPONENTS: ${REQUIRED_COMPONENTS[*]}"
print "> CONF_DIR_PREFIX: ${CONF_DIR_PREFIX} "
print "> CONF_DIR: ${CONF_DIR} "
print "> TEST_CASES_DIR: ${TEST_CASES_DIR} "
print "> TEST_CONFIG_DIR: ${TEST_CONFIG_DIR} "
print "> DOCKER_NETWORK: ${DOCKER_NETWORK} "
print "> initial PROFILES: ${PROFILES} "
print "> (+) ADDON_PROFILES: ${ADDON_PROFILES} "
PROFILES="${PROFILES} ${ADDON_PROFILES}"
print "> (=) final PROFILES: ${PROFILES} "
print "> ENV_FILE: ${ENV_FILE} "
print "> OTHER_ENV_FILE: ${OTHER_ENV_FILE} "
print "> COMMAND: ${COMMAND}"
end "Initialized suite"
mkdir -p ${LOGS}
mkdir -p ${SCREENS}
}
build_mocha_image() {
DOCKER_BUILD_ARGS=""
if [[ -n "$MOCHA_DOCKER_FILE" ]]; then
DOCKER_BUILD_ARGS="-f $MOCHA_DOCKER_FILE "
fi
begin "Ensuring mocha-test image ($DOCKER_BUILD_ARGS) ..."
tag=($(md5sum $SELENIUM_ROOT_FOLDER/package.json))
print "> tag : $tag"
if [[ $(docker images -q mocha-test:$tag 2> /dev/null) == "" ]]; then
docker build $DOCKER_BUILD_ARGS -t mocha-test:$tag --target test $SELENIUM_ROOT_FOLDER
print "> Built docker image mocha-test:$tag"
fi
end "mocha-test image exists"
}
kill_container_if_exist() {
if docker stop $1 &> /dev/null; then
docker rm $1 &> /dev/null
fi
}
wait_for_message() {
attemps_left=10
while ! docker logs $1 2>&1 | grep -q "$2";
do
sleep 5
print "Waiting 5sec for $1 to start ($attemps_left attempts left )..."
((attemps_left--))
if [[ "$attemps_left" -lt 1 ]]; then
print "Timed out waiting"
save_container_log $1
exit 1
fi
done
}
wait_for_oidc_endpoint() {
NAME=$1
BASE_URL=$2
if [[ $BASE_URL == *"localhost"** || $BASE_URL == *"0.0.0.0"** ]]; then
wait_for_oidc_endpoint_local $@
else
wait_for_oidc_endpoint_docker $@
fi
}
wait_for_oidc_endpoint_local() {
NAME=$1
BASE_URL=$2
CURL_ARGS="-k --tlsv1.2 -L --fail "
DELAY_BETWEEN_ATTEMPTS=5
if [[ $# -eq 3 ]]; then
CURL_ARGS="$CURL_ARGS --cacert $3"
DELAY_BETWEEN_ATTEMPTS=10
fi
max_retry=15
counter=0
print "Waiting for OIDC discovery endpoint $NAME ... (BASE_URL: $BASE_URL)"
until (curl $CURL_ARGS ${BASE_URL}/.well-known/openid-configuration >/dev/null 2>&1)
do
sleep $DELAY_BETWEEN_ATTEMPTS
[[ counter -eq $max_retry ]] && print "Failed!" && exit 1
print "Trying again. Try #$counter"
((counter++))
done
sleep 20
}
wait_for_oidc_endpoint_docker() {
NAME=$1
BASE_URL=$2
CURL_ARGS="-k --tlsv1.2 -L --fail "
DOCKER_ARGS="--rm --net ${DOCKER_NETWORK} "
DELAY_BETWEEN_ATTEMPTS=5
if [[ $# -gt 2 ]]; then
DOCKER_ARGS="$DOCKER_ARGS -v $3:/tmp/ca_certificate.pem"
CURL_ARGS="$CURL_ARGS --cacert /tmp/ca_certificate.pem"
DELAY_BETWEEN_ATTEMPTS=10
fi
max_retry=15
counter=0
print "Waiting for OIDC discovery endpoint $NAME ... (BASE_URL: $BASE_URL)"
until (docker run $DOCKER_ARGS curlimages/curl:7.85.0 $CURL_ARGS ${BASE_URL}/.well-known/openid-configuration >/dev/null 2>&1)
do
sleep $DELAY_BETWEEN_ATTEMPTS
[[ counter -eq $max_retry ]] && print "Failed!" && exit 1
print "Trying again. Try #$counter"
((counter++))
done
sleep 20
}
calculate_rabbitmq_url() {
echo "${RABBITMQ_SCHEME:-http}://$1${PUBLIC_RABBITMQ_PATH:-$RABBITMQ_PATH}"
}
calculate_other_rabbitmq_url() {
echo "${OTHER_RABBITMQ_SCHEME:-http}://$1${PUBLIC_RABBITMQ_PATH:-$RABBITMQ_PATH}"
}
calculate_forward_proxy_url() {
PROXIED_URL=$1
PROXY_HOSTNAME=$2
PROXY_PORT=$3
SCHEME=$(echo "$PROXIED_URL" | cut -d: -f1)
PATH=$(echo "$PROXIED_URL" | cut -d/ -f4-)
echo "$SCHEME://$PROXY_HOSTNAME:$PROXY_PORT/$PATH"
}
wait_for_url() {
BASE_URL=$1
if [[ $BASE_URL == *"localhost"** ]]; then
wait_for_url_local $@
else
wait_for_url_docker $@
fi
}
wait_for_url_local() {
url=$1
proxy=${2:-none}
proxy_user=${3:-none}
proxy_pass=$4
curl_args="-L -f -v"
max_retry=10
counter=0
if [[ "$proxy" != "none" && "$proxy" != "" ]]; then
curl_args="--proxy ${proxy} ${curl_args}"
fi
if [[ "$proxy_user" != "none" && "$proxy_user" != "" ]]; then
curl_args="--proxy-user ${proxy_user}:${proxy_pass} ${curl_args}"
fi
until (curl $curl_args $url >/dev/null 2>&1)
do
print "Waiting for $url to start (local)"
sleep 5
[[ counter -eq $max_retry ]] && print "Failed!" && exit 1
print "Trying again. Try #$counter"
((counter++))
done
}
wait_for_url_docker() {
url=$1
proxy=${2:-none}
proxy_user=${3:-none}
proxy_pass=$4
max_retry=10
counter=0
curl_args="-L -f -v"
if [[ "$proxy" != "none" && "$proxy" != "" ]]; then
curl_args="--proxy ${proxy} ${curl_args}"
fi
if [[ "$proxy_user" != "none" && "$proxy_user" != "" ]]; then
curl_args="--proxy-user ${proxy_user}:${proxy_pass} ${curl_args}"
fi
until (docker run --net ${DOCKER_NETWORK} --rm curlimages/curl:7.85.0 $curl_args $url >/dev/null 2>&1)
do
print "Waiting for $url to start (docker)"
sleep 5
[[ counter -eq $max_retry ]] && print "Failed!" && exit 1
print "Trying again. Try #$counter"
((counter++))
done
}
test_on_cluster() {
IFS=', ' read -r -a array <<< "$RABBITMQ_CLUSTER_NODES"
begin "Running against all nodes in cluster $RABBITMQ_CLUSTER_NODES :"
for item in "${array[@]}"
do
RMQ_HOST_0=${RABBITMQ_HOST:-rabbitmq:15672}
RMQ_HOST=$(rewrite_rabbitmq_hostname ${item} $RMQ_HOST_0)
PUBLIC_RMQ_HOST_0=${PUBLIC_RABBITMQ_HOST:-$RMQ_HOST}
PUBLIC_RMQ_HOST=$(rewrite_rabbitmq_hostname ${item} $PUBLIC_RMQ_HOST_0)
RMQ_URL=$(calculate_rabbitmq_url $PUBLIC_RMQ_HOST)
RMQ_HOSTNAME=${item}
_test $RMQ_HOST \
$PUBLIC_RMQ_HOST \
$RMQ_URL \
$RMQ_HOSTNAME
TEST_RESULT=$?
if [ $TEST_RESULT -ne 0 ]; then
break
fi
done
end "Finishing running test ($TEST_RESULT)"
}
rewrite_rabbitmq_hostname() {
IFS=':' read -r -a array <<< "$2"
if [ "${array[0]}" == "rabbitmq" ]; then
echo "${2//rabbitmq/$1}"
else
echo "$2"
fi
}
test() {
if [[ "$PROFILES" == *"cluster"* && ! -z "$RABBITMQ_CLUSTER_NODES" ]]; then
test_on_cluster
else
RMQ_HOST=${RABBITMQ_HOST:-rabbitmq:15672}
PUBLIC_RMQ_HOST=${PUBLIC_RABBITMQ_HOST:-$RMQ_HOST}
_test $RABBITMQ_HOST \
$PUBLIC_RMQ_HOST \
$(calculate_rabbitmq_url $PUBLIC_RMQ_HOST) \
${RABBITMQ_HOSTNAME:-rabbitmq}
fi
}
_test() {
RMQ_HOST=$1
PUBLIC_RMQ_HOST=$2
RMQ_URL=$3
RMQ_HOSTNAME=$4
kill_container_if_exist mocha
begin "Running tests against $RMQ_HOSTNAME with these env variable:"
SELENIUM_TIMEOUT=${SELENIUM_TIMEOUT:-20000}
SELENIUM_POLLING=${SELENIUM_POLLING:-500}
print "> SELENIUM_TIMEOUT: ${SELENIUM_TIMEOUT}"
print "> SELENIUM_POLLING: ${SELENIUM_POLLING}"
print "> RABBITMQ_HOST: ${RMQ_HOST}"
print "> RABBITMQ_HOSTNAME: ${RMQ_HOSTNAME}"
print "> PUBLIC_RABBITMQ_HOST: ${PUBLIC_RMQ_HOST}"
print "> RABBITMQ_PATH: ${RABBITMQ_PATH}"
print "> RABBITMQ_URL: ${RMQ_URL}"
print "> UAA_URL: ${UAA_URL}"
print "> FAKEPORTAL_URL: ${FAKEPORTAL_URL}"
mocha_test_tag=($(md5sum $SELENIUM_ROOT_FOLDER/package.json))
generate_node_extra_ca_cert
MOUNT_NODE_EXTRA_CA_CERTS=${CONF_DIR}/node
EXTRA_ENV_VARS=""
EXTRA_MOUNTS=""
if [[ -f ${MOUNT_NODE_EXTRA_CA_CERTS}/node_ca_certs.pem ]]; then
print "> MOUNT_NODE_EXTRA_CA_CERTS: ${MOUNT_NODE_EXTRA_CA_CERTS}"
EXTRA_ENV_VARS="${EXTRA_ENV_VARS} --env NODE_EXTRA_CA_CERTS=/nodejs/node_ca_certs.pem "
EXTRA_MOUNTS="${EXTRA_MOUNTS} -v ${MOUNT_NODE_EXTRA_CA_CERTS}:/nodejs "
fi
docker run \
--rm \
--name mocha \
--net ${DOCKER_NETWORK} \
--env RABBITMQ_URL=${RMQ_URL} \
--env RABBITMQ_HOSTNAME=${RMQ_HOSTNAME} \
--env UAA_URL=${UAA_URL} \
--env FAKE_PORTAL_URL=${FAKEPORTAL_URL} \
--env RUN_LOCAL=false \
--env SELENIUM_TIMEOUT=${SELENIUM_TIMEOUT} \
--env SELENIUM_POLLING=${SELENIUM_POLLING} \
--env PROFILES="${PROFILES}" \
--env ENV_FILE="/code/.env" \
--env RABBITMQ_CERTS=/etc/rabbitmq/certs \
${EXTRA_ENV_VARS} \
-v ${TEST_DIR}:/code/test \
-v ${TEST_CONFIG_DIR}/certs:/etc/rabbitmq/certs \
-v ${SCREENS}:/screens \
-v ${ENV_FILE}:/code/.env \
${EXTRA_MOUNTS} \
mocha-test:${mocha_test_tag} test /code/test${TEST_CASES_PATH}
TEST_RESULT=$?
end "Finishing running test ($TEST_RESULT)"
return $TEST_RESULT
}
save_logs() {
mkdir -p $LOGS
save_container_logs selenium
}
save_container_logs() {
echo "Saving logs for $1"
if docker container ls | grep $1 >/dev/null 2>&1; then
docker logs $1 &> $LOGS/$1.log
else
echo "$1 not running"
fi
}
save_container_log() {
echo "Saving container $1 logs to $LOGS/$1.log ..."
docker logs $1 &> $LOGS/$1.log
}
profiles_with_local_or_docker() {
if [[ "$PROFILES" != *"local"* && "$PROFILES" != *"docker"* ]]; then
echo "$PROFILES docker"
else
echo "$PROFILES"
fi
}
other_profiles_with_local_or_docker() {
if [[ "$PROFILES_FOR_OTHER" != *"local"* && "$PROFILES_FOR_OTHER" != *"docker"* ]]; then
echo "$PROFILES_FOR_OTHER docker"
else
echo "$PROFILES_FOR_OTHER"
fi
}
generate_env_file() {
begin "Generating env file from profiles: [${PROFILES}] ..."
mkdir -p $CONF_DIR
${BIN_DIR}/gen-env-file "${PROFILES}" $TEST_CONFIG_DIR ${ENV_FILE}.tmp
grep -v '^#' ${ENV_FILE}.tmp > $ENV_FILE
source $ENV_FILE
end "Finished generating env file."
}
generate_other_env_file() {
begin "Generating other env file from profiles: [${PROFILES_FOR_OTHER}] "
mkdir -p $CONF_DIR
${BIN_DIR}/gen-env-file "${PROFILES_FOR_OTHER}" $TEST_CONFIG_DIR ${OTHER_ENV_FILE}.tmp
grep -v '^#' ${OTHER_ENV_FILE}.tmp > $OTHER_ENV_FILE
end "Finished generating other env file."
}
generate-ca-server-client-kpi() {
NAME=$1
FOLDER=$2
if [[ ! -f "${FOLDER}/server_${NAME}_key.pem" ]]; then
do_generate-ca-server-client-kpi $1 $2
fi
}
do_generate-ca-server-client-kpi() {
NAME=$1
FOLDER=$2
ROOT=$SELENIUM_ROOT_FOLDER
begin "Generate certs for $NAME"
if [ ! -d "$ROOT/tls-gen" ]; then
git clone https://github.com/michaelklishin/tls-gen $ROOT/tls-gen
fi
print "Generating CA and Server (localhost and $NAME) PKI under $FOLDER ..."
mkdir -p $FOLDER
CUR_DIR=$(pwd)
cd $ROOT/tls-gen/basic
cp openssl.cnf openssl.cnf.bak
if [ -f "$FOLDER/openssl.cnf.in" ]; then
cp $FOLDER/openssl.cnf.in >> openssl.cnf
fi
if [[ ! -z "${DEBUG}" ]]; then
print "Used this openssl.conf"
cat openssl.cnf
fi
make CN=$NAME CLIENT_ALT_NAME=internaluser
cp openssl.cnf.bak openssl.cnf
cd $CUR_DIR
cp $ROOT/tls-gen/basic/result/ca_certificate.pem $FOLDER/ca_${NAME}_certificate.pem
cp $ROOT/tls-gen/basic/result/server_${NAME}_certificate.pem $FOLDER
cp $ROOT/tls-gen/basic/result/server_${NAME}_key.pem $FOLDER
cp $ROOT/tls-gen/basic/result/server_${NAME}.p12 $FOLDER
cp $ROOT/tls-gen/basic/result/client_${NAME}_certificate.pem $FOLDER
cp $ROOT/tls-gen/basic/result/client_${NAME}_key.pem $FOLDER
cp $ROOT/tls-gen/basic/result/client_${NAME}.p12 $FOLDER
chmod ugo+r $FOLDER/*.pem
end "SSL Certificates generated for $NAME under $FOLDER"
}
generate-truststore-if-required() {
NAME=$1
FOLDER=$2
if [[ ! -f "${FOLDER}/truststore.jks" ]]; then
keytool -import \
-trustcacerts \
-file ${FOLDER}/ca_${NAME}_certificate.pem \
-keystore ${FOLDER}/truststore.jks \
-storepass foobar \
-noprompt
fi
}
generate-server-keystore-if-required() {
NAME=$1
FOLDER=$2
if [ ! -f "${FOLDER}/server_${NAME}.jks" ]; then
keytool -importkeystore \
-destkeystore ${FOLDER}/server_${NAME}.jks \
-srckeystore ${FOLDER}/server_${NAME}.p12 \
-deststoretype pkcs12 \
-srcstoretype pkcs12 \
-alias 1 \
-destalias server-${NAME}-tls \
-deststorepass foobar \
-destkeypass foobar \
-srcstorepass "" \
-srckeypass "" \
-noprompt
fi
}
generate-client-keystore-if-required() {
NAME=$1
FOLDER=$2
if [ ! -f "${FOLDER}/client_${NAME}.jks" ]; then
keytool -importkeystore \
-destkeystore ${FOLDER}/client_${NAME}.jks \
-srckeystore ${FOLDER}/client_${NAME}.p12 \
-deststoretype pkcs12 \
-srcstoretype pkcs12 \
-alias 1 \
-destalias client-${NAME}-tls \
-deststorepass foobar \
-destkeypass foobar \
-srcstorepass "" \
-srckeypass "" \
-noprompt
fi
}
run() {
runWith rabbitmq
}
runWith() {
if [[ "$COMMAND" == "run" ]]
then
run_on_docker_with $@
else
run_local_with $@
fi
}
initOnly() {
if [[ "$COMMAND" == "initOnly" ]]
then
init_only $@
fi
}
run_local_with() {
export PROFILES="local ${PROFILES}"
determine_required_components_excluding_rabbitmq $@
init_suite
ensure_docker_network
generate_env_file
build_mocha_image
if [[ "$PROFILES_FOR_OTHER" != "" ]]
then
export PROFILES_FOR_OTHER="local ${PROFILES_FOR_OTHER}"
generate_other_env_file
fi
if [[ "$COMMAND" == "start-rabbitmq" ]]
then
start_local_rabbitmq
elif [[ "$COMMAND" == "stop-rabbitmq" ]]
then
stop_local_rabbitmq
elif [[ "$COMMAND" == "start-other-rabbitmq" ]]
then
start_local_other_rabbitmq
elif [[ "$COMMAND" == "start-others" ]]
then
start_local_others
elif [[ "$COMMAND" == "ensure-others" ]]
then
ensure_local_others
elif [[ "$COMMAND" == "stop-others" ]]
then
teardown_local_others
elif [[ "$COMMAND" == "stop-rabbitmq" ]]
then
stop_local_rabbitmq
elif [[ "$COMMAND" =~ test[[:space:]]*([^[:space:]]*) ]]
then
test_local ${BASH_REMATCH[1]}
fi
}
determine_required_components_including_rabbitmq() {
for (( i=1; i<=$#; i++)) {
eval val='$'$i
REQUIRED_COMPONENTS+=( "$val" )
}
if [[ "$@" != *"rabbitmq"* ]]; then
REQUIRED_COMPONENTS+=("rabbitmq")
fi
}
determine_required_components_excluding_rabbitmq() {
for (( i=1; i<=$#; i++)) {
eval val='$'$i
if [[ "$val" != "rabbitmq" ]] && [[ "$val" != "other_rabbitmq" ]]; then
REQUIRED_COMPONENTS+=( "$val" )
fi
}
}
initOnly() {
for (( i=1; i<=$#; i++)) {
eval val='$'$i
if [[ $val != "rabbitmq" ]]; then
init="init_$val"
$init
fi
}
}
run_on_docker_with() {
determine_required_components_including_rabbitmq $@
export PROFILES=`profiles_with_local_or_docker`
init_suite
ensure_docker_network
generate_env_file
build_mocha_image
start_selenium
if [[ "$PROFILES_FOR_OTHER" != "" ]]
then
export PROFILES_FOR_OTHER=`other_profiles_with_local_or_docker`
generate_other_env_file
fi
trap "teardown_components" EXIT
start_components
test
TEST_RESULT=$?
save_logs
save_components_logs
kill_container_if_exist selenium
exit $TEST_RESULT
}
start_local_others() {
if [[ $REQUIRED_COMPONENTS == "" ]]; then
print "There are no other components"
else
start_components
fi
}
ensure_local_others() {
if [[ $REQUIRED_COMPONENTS == "" ]]; then
print "There are no other components"
else
ensure_components
fi
}
teardown_local_others() {
if [[ $REQUIRED_COMPONENTS == "" ]]; then
print "There are no other components"
else
teardown_components true
fi
}
test_local() {
begin "Running local test ${1:-}"
RABBITMQ_HOST=${RABBITMQ_HOST:-rabbitmq:15672}
OTHER_RABBITMQ_HOST=${OTHER_RABBITMQ_HOST:-none}
PUBLIC_RABBITMQ_HOST=${PUBLIC_RABBITMQ_HOST:-$RABBITMQ_HOST}
OTHER_PUBLIC_RABBITMQ_HOST=${OTHER_PUBLIC_RABBITMQ_HOST:-$OTHER_RABBITMQ_HOST}
export RABBITMQ_URL=$(calculate_rabbitmq_url $PUBLIC_RABBITMQ_HOST)
export OTHER_RABBITMQ_URL=$(calculate_rabbitmq_url $OTHER_PUBLIC_RABBITMQ_HOST)
export RABBITMQ_HOSTNAME=${RABBITMQ_HOSTNAME:-rabbitmq}
export RABBITMQ_AMQP_USERNAME=${RABBITMQ_AMQP_USERNAME}
export RABBITMQ_AMQP_PASSWORD=${RABBITMQ_AMQP_PASSWORD}
export SELENIUM_TIMEOUT=${SELENIUM_TIMEOUT:-20000}
export SELENIUM_POLLING=${SELENIUM_POLLING:-500}
generate_node_extra_ca_cert
MOUNT_NODE_EXTRA_CA_CERTS=${CONF_DIR}/node/node_ca_certs.pem
print "> SELENIUM_TIMEOUT: ${SELENIUM_TIMEOUT}"
print "> SELENIUM_POLLING: ${SELENIUM_POLLING}"
print "> RABBITMQ_HOST: ${RABBITMQ_HOST}"
print "> RABBITMQ_HOSTNAME: ${RABBITMQ_HOSTNAME}"
print "> PUBLIC_RABBITMQ_HOST: ${PUBLIC_RABBITMQ_HOST}"
print "> RABBITMQ_PATH: ${RABBITMQ_PATH}"
print "> RABBITMQ_URL: ${RABBITMQ_URL}"
print "> UAA_URL: ${UAA_URL}"
print "> FAKE_PORTAL_URL: ${FAKE_PORTAL_URL}"
print "> MOUNT_NODE_EXTRA_CA_CERTS: ${MOUNT_NODE_EXTRA_CA_CERTS}"
export RUN_LOCAL=true
export SCREENSHOTS_DIR=${SCREENS}
export PROFILES
export ENV_FILE
export NODE_EXTRA_CA_CERTS=$MOUNT_NODE_EXTRA_CA_CERTS
npm test $TEST_CASES_DIR/$1
}
ensure_components() {
for i in "${REQUIRED_COMPONENTS[@]}"
do
start="ensure_$i"
$start
done
}
start_components() {
for i in "${REQUIRED_COMPONENTS[@]}"
do
start="start_$i"
$start
done
}
teardown_components() {
skip_rabbitmq=${1:-false}
begin "Tear down ... "
for i in "${REQUIRED_COMPONENTS[@]}"
do
if [[ $i != "rabbitmq" || ($i == "rabbitmq" && $skip_rabbitmq == false) ]]
then
local component="$i"
stop="stop_$i"
type "$stop" &>/dev/null && $stop || kill_container_if_exist "$component"
print "Tear down $component"
fi
done
end "Finished teardown"
}
save_components_logs() {
begin "Saving Logs to $LOGS for ${REQUIRED_COMPONENTS[@]} ..."
for i in "${REQUIRED_COMPONENTS[@]}"
do
local component="$i"
save="save_logs_$i"
type "$save" &>/dev/null && $save || save_container_logs "$component"
print "Saving logs for component $component"
done
end "Finished saving logs"
}
generate_node_extra_ca_cert() {
begin "Generating ${CONF_DIR}/node/node_ca_certs.pem ..."
mkdir -p ${CONF_DIR}/node
rm -f ${CONF_DIR}/node/node_ca_certs.pem
env | while IFS= read -r line; do
value=${line#*=}
name=${line%%=*}
if [[ $name == *NODE_EXTRA_CA_CERTS ]]
then
print "Adding ${TEST_DIR}/${value} to ${CONF_DIR}/node/node_ca_certs.pem ..."
cat ${TEST_DIR}/${value} >> ${CONF_DIR}/node/node_ca_certs.pem
fi
done
if [[ -f ${CONF_DIR}/node/node_ca_certs.pem ]]; then
end "Generated ${CONF_DIR}/node/node_ca_certs.pem"
else
end "Did not generate ${CONF_DIR}/node/node_ca_certs.pem"
fi
}
Reference in New Issue View Git Blame Copy Permalink