moby--moby/hack/make/.integration-test-helpers

#!/usr/bin/env bash
#
# For integration-cli test, we use [gocheck](https://labix.org/gocheck), if you want
# to run certain tests on your local host, you should run with command:
#
#     TESTFLAGS='-check.f DockerSuite.TestBuild*' ./hack/make.sh binary test-integration
#

if [[ "${TESTFLAGS}" = *-check.f* ]]; then
	echo Skipping integration tests since TESTFLAGS includes integration-cli only flags
	TEST_SKIP_INTEGRATION=1
fi

if [[ "${TESTFLAGS}" = *-test.run* ]]; then
	echo Skipping integration-cli tests since TESTFLAGS includes integration only flags
	TEST_SKIP_INTEGRATION_CLI=1
fi


if [ -z "${MAKEDIR}" ]; then
	MAKEDIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
	export MAKEDIR
fi
source "${MAKEDIR}/.go-autogen"

# Set defaults
: "${TEST_REPEAT:=1}"
: "${TESTFLAGS:=}"
: "${TESTDEBUG:=}"

setup_integration_test_filter() {
	if [ -z "${TEST_FILTER}" ]; then
		return
	fi

	if [ -z "${TEST_SKIP_INTEGRATION}" ]; then
		: "${TEST_INTEGRATION_DIR:=$(grep -rl "func\ .*${TEST_FILTER}.*\(t\ \*testing\.T\)" ./integration | grep '_test\.go' | xargs -I file dirname file | uniq)}"
		if [ -z "${TEST_INTEGRATION_DIR}" ]; then
			echo "Skipping integration tests since the supplied filter \"${TEST_FILTER}\" omits all integration tests"
			TEST_SKIP_INTEGRATION=1
		else
			TESTFLAGS_INTEGRATION+="-test.run ${TEST_FILTER}"
		fi
	fi

	if [ -z "${TEST_SKIP_INTEGRATION_CLI}" ]; then
		# ease up on the filtering here since CLI suites are namespaced by an object
		if grep -r "${TEST_FILTER}.*\(c\ \*check\.C\)" ./integration-cli | grep -q '_test\.go$'; then
			TEST_SKIP_INTEGRATION_CLI=1
			echo "Skipping integration-cli tests since the supplied filter \"${TEST_FILTER}\" omits all integration-cli tests"
		else
			TESTFLAGS_INTEGRATION_CLI+="-check.f ${TEST_FILTER}"
		fi
	fi
}

setup_integration_test_filter
integration_api_dirs="${TEST_INTEGRATION_DIR:-$(go list  -test -f '{{- if ne .ForTest "" -}}{{- .Dir -}}{{- end -}}'  ./integration/...)}"

run_test_integration() {
	set_platform_timeout
	if [ -z "${TEST_SKIP_INTEGRATION}" ]; then
		run_test_integration_suites
	fi
	if [ -z "${TEST_SKIP_INTEGRATION_CLI}" ]; then
		run_test_integration_legacy_suites
	fi
}

run_test_integration_suites() {
	local flags="-test.v -test.timeout=${TIMEOUT} $TESTFLAGS ${TESTFLAGS_INTEGRATION}"
	for dir in ${integration_api_dirs}; do
		if ! (
			cd "$dir"
			echo "Running $PWD flags=${flags}"
			# shellcheck disable=SC2086
			test_env ./test.main ${flags}
		); then exit 1; fi
	done
}

run_test_integration_legacy_suites() {
	(
		flags="-check.v -check.timeout=${TIMEOUT} -test.timeout=360m $TESTFLAGS ${TESTFLAGS_INTEGRATION_CLI}"
		cd integration-cli
		echo "Running $PWD flags=${flags}"
		# shellcheck disable=SC2086
		test_env ./test.main $flags
	)
}

build_test_suite_binaries() {
	if [ -n "${DOCKER_INTEGRATION_TESTS_VERIFIED}" ]; then
		echo "Skipping building test binaries; as DOCKER_INTEGRATION_TESTS_VERIFIED is set"
		return
	fi
	if [ -z "${TEST_SKIP_INTEGRATION_CLI}" ]; then
		build_test_suite_binary ./integration-cli "test.main"
	fi
	if [ -z "${TEST_SKIP_INTEGRATION}" ]; then
		for dir in ${integration_api_dirs}; do
			build_test_suite_binary "$dir" "test.main"
		done
	fi
}

# Build a binary for a test suite package
build_test_suite_binary() {
	local dir="$1"
	local out="$2"
	echo Building test suite binary "$dir/$out"
	go test -c -o "$dir/$out" -ldflags "$LDFLAGS" "${BUILDFLAGS[@]}" "$dir"
}

cleanup_test_suite_binaries() {
	[ -n "$TESTDEBUG" ] && return
	echo "Removing test suite binaries"
	# shellcheck disable=SC2038
	find integration* -name test.main | xargs -r rm
}

repeat() {
	for i in $(seq 1 ${TEST_REPEAT}); do
		echo "Running integration-test (iteration $i)"
		$@
	done
}

# use "env -i" to tightly control the environment variables that bleed into the tests
test_env() {
	(
		set -e
		[ -n "$TESTDEBUG" ] && set -x
		env -i \
			DEST="$ABS_DEST" \
			DOCKER_API_VERSION="$DOCKER_API_VERSION" \
			DOCKER_BUILDKIT="$DOCKER_BUILDKIT" \
			DOCKER_INTEGRATION_DAEMON_DEST="$DOCKER_INTEGRATION_DAEMON_DEST" \
			DOCKER_TLS_VERIFY="$DOCKER_TEST_TLS_VERIFY" \
			DOCKER_CERT_PATH="$DOCKER_TEST_CERT_PATH" \
			DOCKER_ENGINE_GOARCH="$DOCKER_ENGINE_GOARCH" \
			DOCKER_GRAPHDRIVER="$DOCKER_GRAPHDRIVER" \
			DOCKER_USERLANDPROXY="$DOCKER_USERLANDPROXY" \
			DOCKER_HOST="$DOCKER_HOST" \
			DOCKER_REMAP_ROOT="$DOCKER_REMAP_ROOT" \
			DOCKER_REMOTE_DAEMON="$DOCKER_REMOTE_DAEMON" \
			DOCKERFILE="$DOCKERFILE" \
			GOPATH="$GOPATH" \
			GOTRACEBACK=all \
			HOME="$ABS_DEST/fake-HOME" \
			PATH="$PATH" \
			TEMP="$TEMP" \
			TEST_CLIENT_BINARY="$TEST_CLIENT_BINARY" \
			"$@"
	)
}

error_on_leaked_containerd_shims() {
	if [ "$(go env GOOS)" = 'windows' ]; then
		return
	fi

	leftovers=$(ps -ax -o pid,cmd |
	            awk '$2 == "containerd-shim" && $4 ~ /.*\/bundles\/.*\/test-integration/ { print $1 }')
	if [ -n "$leftovers" ]; then
		ps aux
		# shellcheck disable=SC2086
		kill -9 ${leftovers} 2> /dev/null
		echo "!!!! WARNING you have left over shim(s), Cleanup your test !!!!"
		exit 1
	fi
}

set_platform_timeout() {
	# Test timeout.
	if [ "${DOCKER_ENGINE_GOARCH}" = "arm64" ] || [ "${DOCKER_ENGINE_GOARCH}" = "arm" ]; then
		: "${TIMEOUT:=10m}"
	elif [ "${DOCKER_ENGINE_GOARCH}" = "windows" ]; then
		: "${TIMEOUT:=8m}"
	else
		: "${TIMEOUT:=5m}"
	fi

	if [ "${TEST_REPEAT}" -gt 1 ]; then
		# TIMEOUT needs to take TEST_REPEAT into account, or a premature time out may happen.
		# The following ugliness will:
		# - remove last character (usually 'm' from '10m')
		# - multiply by testcount
		# - add last character back
		TIMEOUT=$((${TIMEOUT::-1} * ${TEST_REPEAT}))${TIMEOUT:$((${#TIMEOUT}-1)):1}
	fi
}