containers
/
podman
mirror of https://github.com/containers/podman.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
podman/test/compose/test-compose

440 lines
12 KiB
Bash
Executable File
Raw Blame History

#!/usr/bin/env bash
#
# Usage: test-docker-compose [testname]
#
# DEVELOPER NOTE: you almost certainly don't need to play in here. See README.
#
ME=$(basename $0)
###############################################################################
# BEGIN stuff you can but probably shouldn't customize
# Directory where this script (and extra test configs) live
TEST_ROOTDIR=$(realpath $(dirname $0))
# Podman executable
PODMAN_BIN=$(realpath bin)/podman
# Github repo containing sample docker-compose setups
# FIXME: we should probably version this
AWESOME_COMPOSE=https://github.com/docker/awesome-compose
# Local path to docker socket
DOCKER_SOCK=/var/run/docker.sock
# END stuff you can but probably shouldn't customize
###############################################################################
# BEGIN setup
TMPDIR=${TMPDIR:-/var/tmp}
WORKDIR=$(mktemp --tmpdir -d $ME.tmp.XXXXXX)
# Log of all HTTP requests and responses; always make '.log' point to latest
LOGBASE=${TMPDIR}/$ME.log
LOG=${LOGBASE}.$(date +'%Y%m%dT%H%M%S')
ln -sf $LOG $LOGBASE
# Keep track of test count and failures in files, not variables, because
# variables don't carry back up from subshells.
testcounter_file=$WORKDIR/.testcounter
failures_file=$WORKDIR/.failures
echo 0 >$testcounter_file
echo 0 >$failures_file
# END setup
###############################################################################
# BEGIN infrastructure code - the helper functions used in tests themselves
#########
# die # Exit error with a message to stderr
#########
function die() {
echo "$ME: $*" >&2
exit 1
}
########
# is # Simple comparison
########
function is() {
local actual=$1
local expect=$2
local testname=$3
if [[ $actual = $expect ]]; then
# On success, include expected value; this helps readers understand
_show_ok 1 "$testname=$expect"
return
fi
_show_ok 0 "$testname" "$expect" "$actual"
}
##########
# like # Compare, but allowing patterns
##########
function like() {
local actual=$1
local expect=$2
local testname=$3
# "is" (equality) is a subset of "like", but one that expr fails on if
# the expected result has shell-special characters like '['. Treat it
# as a special case.
if [[ "$actual" = "$expect" ]]; then
_show_ok 1 "$testname=$expect"
return
fi
if expr "$actual" : ".*$expect" &>/dev/null; then
# On success, include expected value; this helps readers understand
_show_ok 1 "$testname ('$actual') ~ $expect"
return
fi
_show_ok 0 "$testname" "~ $expect" "$actual"
}
##############
# _show_ok # Helper for is() and like(): displays 'ok' or 'not ok'
##############
function _show_ok() {
local ok=$1
local testname=$2
# If output is a tty, colorize pass/fail
local red=
local green=
local reset=
local bold=
if [ -t 1 ]; then
red='\e[31m'
green='\e[32m'
reset='\e[0m'
bold='\e[1m'
fi
_bump $testcounter_file
count=$(<$testcounter_file)
# "skip" is a special case of "ok". Assume that our caller has included
# the magical '# skip - reason" comment string.
if [[ $ok == "skip" ]]; then
# colon-plus: replace green with yellow, but only if green is non-null
green="${green:+\e[33m}"
ok=1
fi
if [ $ok -eq 1 ]; then
echo -e "${green}ok $count $testname${reset}"
echo "ok $count $testname" >>$LOG
return
fi
# Failed
local expect=$3
local actual=$4
printf "${red}not ok $count $testname${reset}\n"
printf "${red}# expected: %s${reset}\n" "$expect"
printf "${red}# actual: ${bold}%s${reset}\n" "$actual"
echo "not ok $count $testname" >>$LOG
echo " expected: $expect" >>$LOG
_bump $failures_file
}
###########
# _bump # Increment a counter in a file
###########
function _bump() {
local file=$1
count=$(<$file)
echo $(( $count + 1 )) >| $file
}
#############
# jsonify # convert 'foo=bar,x=y' to json {"foo":"bar","x":"y"}
#############
function jsonify() {
# split by comma
local -a settings_in
read -ra settings_in <<<"$1"
# convert each to double-quoted form
local -a settings_out
for i in ${settings_in[*]}; do
settings_out+=$(sed -e 's/\(.*\)=\(.*\)/"\1":"\2"/' <<<$i)
done
# ...and wrap inside braces.
# FIXME: handle commas
echo "{${settings_out[*]}}"
}
#######
# t # Main test helper
#######
function t() {
local method=$1; shift
local path=$1; shift
local curl_args
local testname="$method $path"
# POST requests require an extra params arg
if [[ $method = "POST" ]]; then
curl_args="-d $(jsonify $1)"
testname="$testname [$curl_args]"
shift
fi
# entrypoint path can include a descriptive comment; strip it off
path=${path%% *}
# curl -X HEAD but without --head seems to wait for output anyway
if [[ $method == "HEAD" ]]; then
curl_args="--head"
fi
local expected_code=$1; shift
# If given path begins with /, use it as-is; otherwise prepend /version/
local url=http://$HOST:$PORT
if expr "$path" : "/" >/dev/null; then
url="$url$path"
else
url="$url/v1.40/$path"
fi
# Log every action we do
echo "-------------------------------------------------------------" >>$LOG
echo "\$ $testname" >>$LOG
rm -f $WORKDIR/curl.*
# -s = silent, but --write-out 'format' gives us important response data
response=$(curl -s -X $method ${curl_args} \
-H 'Content-type: application/json' \
--dump-header $WORKDIR/curl.headers.out \
--write-out '%{http_code}^%{content_type}^%{time_total}' \
-o $WORKDIR/curl.result.out "$url")
# Any error from curl is instant bad news, from which we can't recover
rc=$?
if [[ $rc -ne 0 ]]; then
echo "FATAL: curl failure ($rc) on $url - cannot continue" >&2
exit 1
fi
# Show returned headers (without trailing ^M or empty lines) in log file.
# Sometimes -- I can't remember why! -- we don't get headers.
if [[ -e $WORKDIR/curl.headers.out ]]; then
tr -d '\015' < $WORKDIR/curl.headers.out | egrep '.' >>$LOG
fi
IFS='^' read actual_code content_type time_total <<<"$response"
printf "X-Response-Time: ${time_total}s\n\n" >>$LOG
# Log results, if text. If JSON, filter through jq for readability.
if [[ $content_type =~ /octet ]]; then
output="[$(file --brief $WORKDIR/curl.result.out)]"
echo "$output" >>$LOG
else
output=$(< $WORKDIR/curl.result.out)
if [[ $content_type =~ application/json ]]; then
jq . <<<"$output" >>$LOG
else
echo "$output" >>$LOG
fi
fi
# Test return code
is "$actual_code" "$expected_code" "$testname : status"
# Special case: 204/304, by definition, MUST NOT return content (rfc2616)
if [[ $expected_code = 204 || $expected_code = 304 ]]; then
if [ -n "$*" ]; then
die "Internal error: ${expected_code} status returns no output; fix your test."
fi
if [ -n "$output" ]; then
_show_ok 0 "$testname: ${expected_code} status returns no output" "''" "$output"
fi
return
fi
local i
# Special case: if response code does not match, dump the response body
# and skip all further subtests.
if [[ $actual_code != $expected_code ]]; then
echo -e "# response: $output"
for i; do
_show_ok skip "$testname: $i # skip - wrong return code"
done
return
fi
for i; do
if expr "$i" : "[^=~]\+=.*" >/dev/null; then
# Exact match on json field
json_field=$(expr "$i" : "\([^=]*\)=")
expect=$(expr "$i" : '[^=]*=\(.*\)')
actual=$(jq -r "$json_field" <<<"$output")
is "$actual" "$expect" "$testname : $json_field"
elif expr "$i" : "[^=~]\+~.*" >/dev/null; then
# regex match on json field
json_field=$(expr "$i" : "\([^~]*\)~")
expect=$(expr "$i" : '[^~]*~\(.*\)')
actual=$(jq -r "$json_field" <<<"$output")
like "$actual" "$expect" "$testname : $json_field"
else
# Direct string comparison
is "$output" "$i" "$testname : output"
fi
done
}
###################
# start_service # Run the socket listener
###################
service_pid=
function start_service() {
test -x $PODMAN_BIN || die "Not found: $PODMAN_BIN"
rm -rf $WORKDIR/{root,runroot,cni}
mkdir $WORKDIR/cni
cp /etc/cni/net.d/*podman*conflist $WORKDIR/cni/
$PODMAN_BIN \
--root $WORKDIR/root \
--runroot $WORKDIR/runroot \
--cgroup-manager=systemd \
--cni-config-dir $WORKDIR/cni \
system service \
--time 0 unix:/$DOCKER_SOCK \
&> $WORKDIR/server.log &
service_pid=$!
# Wait (FIXME: how do we test the socket?)
local _timeout=5
while [ $_timeout -gt 0 ]; do
# FIXME: should we actually try a read or write?
test -S $DOCKER_SOCK && return
sleep 1
_timeout=$(( $_timeout - 1 ))
done
cat $WORKDIR/server.log
die "Timed out waiting for service"
}
############
# podman # Needed by some test scripts to invoke the actual podman binary
############
function podman() {
echo "\$ $PODMAN_BIN $*" >>$WORKDIR/output.log
$PODMAN_BIN --root $WORKDIR "$@" >>$WORKDIR/output.log 2>&1
}
# END infrastructure code
###############################################################################
# BEGIN sanity checks
for tool in curl docker-compose; do
type $tool &>/dev/null || die "$ME: Required tool '$tool' not found"
done
# END sanity checks
###############################################################################
# BEGIN entry handler (subtest invoker)
TESTS_DIR=$WORKDIR/awesome-compose
git clone $AWESOME_COMPOSE $TESTS_DIR
git -C $TESTS_DIR checkout -q a3c38822277bcca04abbadf34120dcff808db3ec
# Identify the tests to run. If called with args, use those as globs.
tests_to_run=()
if [ -n "$*" ]; then
shopt -s nullglob
for i; do
match=(${TEST_ROOTDIR}/*${i}*.curl)
if [ ${#match} -eq 0 ]; then
die "No match for $TEST_ROOTDIR/*$i*.curl"
fi
tests_to_run+=("${match[@]}")
done
shopt -u nullglob
else
tests_to_run=(${TEST_ROOTDIR}/*.curl)
fi
# Test count: each of those tests might have a local set of subtests
n_tests=$((2 * ${#tests_to_run[*]}))
for t in ${tests_to_run[@]}; do
n_curls=$(wc -l $t | awk '{print $1}')
n_tests=$(( n_tests + n_curls ))
done
echo "1..$n_tests"
for t in ${tests_to_run[@]}; do
testname="$(basename $t .curl)"
start_service
logfile=$WORKDIR/$testname.log
(
cd $TESTS_DIR/$testname || die "Cannot cd $TESTS_DIR/$testname"
docker-compose up -d &> $logfile
if [[ $? -ne 0 ]]; then
_show_ok 0 "$testname - up" "[ok]" "$(< $logfile)"
# FIXME: cat log
docker-compose down >>$logfile 2>&1 # No status check here
exit 1
fi
_show_ok 1 "$testname - up"
# FIXME: run tests, e.g. curl
curls=$TEST_ROOTDIR/$testname.curl
if [[ -e $curls ]]; then
while read port expect; do
actual=$(curl --retry 5 --retry-connrefused -s http://127.0.0.1:$port/)
curl_rc=$?
if [ $curl_rc -ne 0 ]; then
_show_ok 0 "$testname - curl failed with status $curl_rc"
docker-compose down >>$logfile 2>&1
exit 1
fi
like "$actual" "$expect" "$testname : port $port"
done < $curls
fi
docker-compose down &> $logfile
if [[ $? -eq 0 ]]; then
_show_ok 1 "$testname - down"
else
_show_ok 0 "$testname - down" "[ok]" "$(< $logfile)"
# FIXME: show error
fi
)
kill $service_pid
wait $service_pid
# FIXME: otherwise we get EBUSY
umount $WORKDIR/root/overlay &>/dev/null
done
# END entry handler
###############################################################################
# Clean up
test_count=$(<$testcounter_file)
failure_count=$(<$failures_file)
if [ -z "$PODMAN_TESTS_KEEP_WORKDIR" ]; then
rm -rf $WORKDIR
fi
exit $failure_count
Reference in New Issue View Git Blame Copy Permalink