index : cgit

# Shared groundwork sourced by every test script. It builds a handful of small
# repositories under repos/ and writes a cgitrc pointing at them, then offers
# the helpers that write a config of a test's own and ask cgit for a page, so
# a test only has to look at what comes back. Sourcing it also brings in the
# test library from the bundled Git tree, which is where test_expect_success
# and the trash directory come from. Set CGIT_TEST_NO_CREATE_REPOS to get the
# helpers without paying for the fixtures.

LF='
'
# Trash directories are collected under one trash/, which keeps the ignore
# and clean rules to a single name. Seeded ahead of the real arguments so
# one given on the command line still wins.
test_argv="${LF}--root=trash"

# The Git test library would run every Git command under Valgrind if it saw
# --valgrind, and only cgit is worth watching, so the option is taken out
# here and acted on further down. The tool chosen is exported, as the library
# runs the script again without it for --tee, --verbose-log and --stress.
# Valgrind reports on the verbose output, which it therefore turns on.
while test $# != 0
do
	case "$1" in
	--va|--val|--valg|--valgr|--valgri|--valgrin|--valgrind)
		CGIT_TEST_VALGRIND=memcheck
		;;
	--valgrind=*)
		CGIT_TEST_VALGRIND=${1#--*=}
		;;
	--valgrind-only=*)
		echo "error: --valgrind-only is not supported, use --valgrind with --run" >&2
		exit 1
		;;
	*)
		test_argv="$test_argv$LF$1"
		;;
	esac
	shift
done
if test -n "$CGIT_TEST_VALGRIND"
then
	test_argv="$test_argv${LF}--verbose"
	export CGIT_TEST_VALGRIND
fi

# Globbing is off while the arguments are split apart again, so one that looks
# like a pattern reaches the library as it was given.
cgit_ifs=$IFS
IFS=$LF
set -f
set -- $test_argv
set +f
IFS=$cgit_ifs
unset test_argv cgit_ifs

# The library takes these from the environment when they are set there, so
# they are set outright, or a shell set up for work on Git itself would point
# the suite at another library and every path below at another tree. The
# fixtures and many tests name master, which the library would otherwise take
# from the same environment, or from a Git built with its breaking changes.
TEST_DIRECTORY=$(pwd)/../vendor/git/t
TEST_OUTPUT_DIRECTORY=$(pwd)
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=master
export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME
# The library would otherwise leave a repository of its own in the trash
# directory, and the tests build the repositories they want themselves.
TEST_NO_CREATE_REPO=YesPlease
. "$TEST_DIRECTORY"/test-lib.sh

# cgit reads the CGI variables and a few of its own from the environment, and
# the library clears only Git's, so a developer's shell could hand any of them
# to every request. LUA_INIT runs code in each standalone interpreter. The Lua
# search paths are left alone, since they are how a system points Lua at its
# modules.
for cgit_variable in SCRIPT_NAME PATH_INFO QUERY_STRING HTTP_HOST HTTPS NO_HTTP \
	REQUEST_METHOD SERVER_NAME SERVER_PORT HTTP_COOKIE HTTP_REFERER CONTENT_LENGTH \
	CONTENT_TYPE REMOTE_ADDR REMOTE_USER CGIT_CONFIG CGIT_SCINTILLUA_PATH \
	LUA_INIT LUA_INIT_5_2 LUA_INIT_5_3 LUA_INIT_5_4 LUA_INIT_5_5
do
	unset $cgit_variable
done
unset cgit_variable
umask 022

# A sanitizer report goes to stderr, which the library throws away without -v,
# and a process whose exit status is lost, one in a pipeline say, fails no test
# at all. So each report is written to a file beside the script's counts, and
# any found there when the script ends are shown and fail a test of their own.
# The summary looks for them again.
cgit_sanitizer_log="$TEST_RESULTS_BASE.sanitizer"
mkdir -p "$TEST_RESULTS_DIR" &&
rm -f "$cgit_sanitizer_log".* ||
	BAIL_OUT "cannot prepare $TEST_RESULTS_DIR for sanitizer reports"
ASAN_OPTIONS="$ASAN_OPTIONS:log_path='$cgit_sanitizer_log'"
UBSAN_OPTIONS="$UBSAN_OPTIONS:log_path='$cgit_sanitizer_log'"
export ASAN_OPTIONS UBSAN_OPTIONS

# This runs when the script ends, where the library has pointed stdout and
# stderr at its verbose output, so they are pointed back for the test. It can
# run twice when -i stops the script, which the flag guards against.
cgit_check_sanitizer_logs() {
	test -z "$cgit_sanitizer_checked" || return 0
	cgit_sanitizer_checked=t
	set -- "$cgit_sanitizer_log".*
	test -f "$1" || return 0
	cat "$@" >&7
	test_expect_success 'no sanitizer reported an error' '
		for cgit_sanitizer_report in "$cgit_sanitizer_log".*
		do
			test_path_is_missing "$cgit_sanitizer_report" || return 1
		done
	' >&5 2>&7
}
test_atexit cgit_check_sanitizer_logs

# The library has moved into the trash directory by now, so paths outside it
# are anchored to TEST_OUTPUT_DIRECTORY. The tests run cgit by name, so the
# binary just built has to come ahead of any copy already installed. Under
# Valgrind the wrappers take that place instead, and find valgrind by the path
# looked up here, as a few tests run cgit with no PATH at all.
if test -n "$CGIT_TEST_VALGRIND"
then
	GIT_VALGRIND="$TEST_DIRECTORY/valgrind"
	CGIT_VALGRIND=$(cd "$TEST_OUTPUT_DIRECTORY/valgrind" && pwd)
	CGIT_VALGRIND_PROGRAM=$(command -v valgrind) ||
		BAIL_OUT "--valgrind needs valgrind on the PATH"
	PATH="$CGIT_VALGRIND/bin:$PATH"
	export GIT_VALGRIND CGIT_VALGRIND CGIT_VALGRIND_PROGRAM
else
	PATH="$TEST_OUTPUT_DIRECTORY/../build:$PATH"
fi

FILTER_DIRECTORY=$(cd "$TEST_OUTPUT_DIRECTORY/filters" && pwd)

# Lua filters only work when cgit was compiled with Lua, so the tests that use
# them have to ask the binary rather than assume. A cgit that cannot print its
# version stops the run rather than reading as one built without Lua, and the
# answer has to agree with the flags the binary was built with.
cgit_version=$(cgit --version) ||
	BAIL_OUT "cgit --version failed, so the binary under test is broken"
case "$cgit_version" in
*"[+] Lua scripting"*)
	CGIT_HAS_LUA=1
	test_set_prereq CGIT_LUA
	;;
*)
	CGIT_HAS_LUA=0
	;;
esac
cgit_flags="$TEST_OUTPUT_DIRECTORY/../build/CGIT-CFLAGS"
if test -z "$CGIT_TEST_VALGRIND" && test -f "$cgit_flags"
then
	if grep -e "-DNO_LUA" "$cgit_flags" >/dev/null
	then
		test "$CGIT_HAS_LUA" = 0 ||
			BAIL_OUT "cgit reports Lua but was built with NO_LUA"
	else
		test "$CGIT_HAS_LUA" = 1 ||
			BAIL_OUT "cgit was built with Lua but its version does not say so"
	fi
fi
unset cgit_version cgit_flags

# A run that has to cover everything names the prerequisites it cannot go
# without in CGIT_TEST_REQUIRE, and the library then stops a script that finds
# one missing rather than skip the tests that need it. Lua is asked about at
# once, as a few scripts leave whole tests out when cgit has none.
GIT_TEST_REQUIRE_PREREQ="$GIT_TEST_REQUIRE_PREREQ $CGIT_TEST_REQUIRE"
test_have_prereq CGIT_LUA || :

# Creates a repository holding the given number of one file commits. A third
# argument asks for a variant, either testplus for a file and a branch whose
# names have to be escaped in a URL, or commit-graph for a written commit graph.
mkrepo() {
	mkrepo_commits=$2
	mkrepo_variant=$3
	test_create_repo "$1" &&
	(
		cd "$1" &&
		n=1 &&
		while test $n -le $mkrepo_commits
		do
			echo $n >file-$n &&
			git add file-$n &&
			git commit -m "commit $n" &&
			n=$((n + 1)) || exit 1
		done &&
		case "$mkrepo_variant" in
		testplus)
			echo "hello" >a+b &&
			git add a+b &&
			git commit -m "add a+b" &&
			git branch "1+2"
			;;
		commit-graph)
			git commit-graph write
			;;
		esac
	)
}

setup_repos() {
	mkdir cache &&
	mkrepo repos/foo 5 >/dev/null &&
	mkrepo repos/bar 50 commit-graph >/dev/null &&
	mkrepo repos/foo+bar 10 testplus >/dev/null &&
	mkrepo "repos/with space" 2 >/dev/null &&
	mkrepo repos/filter 5 testplus >/dev/null &&
	cat >cgitrc <<EOF &&
virtual-root=/
cache-root=$PWD/cache

cache-size=1021
enable-cache-list=1
snapshots=tar tar.gz tar.bz2 tar.lz tar.xz tar.zst zip
enable-log-filecount=1
enable-log-linecount=1
summary-log=5
summary-branches=5
summary-tags=5
clone-url=git://example.org/\$CGIT_REPO_URL.git

repo.url=foo
repo.path=$PWD/repos/foo/.git
# No repo.desc here, and the description file holds git's placeholder, so
# the [no description] default gets exercised.

repo.url=bar
repo.path=$PWD/repos/bar/.git
repo.desc=the bar repo

repo.url=foo+bar
repo.path=$PWD/repos/foo+bar/.git
repo.desc=the foo+bar repo

repo.url=with space
repo.path=$PWD/repos/with space/.git
repo.desc=spaced repo

repo.url=filter-exec
repo.path=$PWD/repos/filter/.git
repo.desc=filtered repo
repo.about-filter=exec:$FILTER_DIRECTORY/dump.sh
repo.commit-filter=exec:$FILTER_DIRECTORY/dump.sh
repo.email-filter=exec:$FILTER_DIRECTORY/dump.sh
repo.source-filter=exec:$FILTER_DIRECTORY/dump.sh
repo.readme=master:a+b
EOF

	if test "$CGIT_HAS_LUA" -eq 1
	then
		cat >>cgitrc <<EOF
repo.url=filter-lua
repo.path=$PWD/repos/filter/.git
repo.desc=filtered repo
repo.about-filter=lua:$FILTER_DIRECTORY/dump.lua
repo.commit-filter=lua:$FILTER_DIRECTORY/dump.lua
repo.email-filter=lua:$FILTER_DIRECTORY/dump.lua
repo.source-filter=lua:$FILTER_DIRECTORY/dump.lua
repo.readme=master:a+b
EOF
	fi
}

# Writes a config to the file named first that serves repos/<url> under the
# url named second, with the cache off and links rooted at /, and takes the
# rest as settings. A repository copies its defaults from the global settings
# read before its repo.url, so whatever order they come in, the repo.* ones
# go after the repository and all others ahead of it. A repo.path setting
# names a repository kept somewhere else.
cgitrc_repo() {
	cgitrc_file=$1
	cgitrc_url=$2
	shift 2
	cgitrc_path="repo.path=$PWD/repos/$cgitrc_url/.git"
	cgitrc_before=
	cgitrc_after=
	for cgitrc_setting
	do
		case "$cgitrc_setting" in
		repo.path=*)
			cgitrc_path=$cgitrc_setting
			;;
		repo.*)
			cgitrc_after="$cgitrc_after$cgitrc_setting$LF"
			;;
		*)
			cgitrc_before="$cgitrc_before$cgitrc_setting$LF"
			;;
		esac
	done
	printf '%s' "virtual-root=/$LF" "cache-size=0$LF" "$cgitrc_before" \
		"repo.url=$cgitrc_url$LF" "$cgitrc_path$LF" "$cgitrc_after" >"$cgitrc_file"
}

# Writes a config to the file named first with the cache off and links rooted
# at /, as cgitrc_repo does, followed by the rest as lines of their own. They
# keep the order given, since a repo.* setting goes to the repository named
# last and a section takes in the repositories after it.
cgitrc_repos() {
	cgitrc_file=$1
	shift
	printf '%s\n' virtual-root=/ cache-size=0 "$@" >"$cgitrc_file"
}

# Writes the global settings named after the file ahead of a copy of the
# shared cgitrc. The copy turns the cache off, because a page is cached under
# its request alone and would otherwise come back as the shared config made
# it.
cgitrc_copy() {
	cgitrc_file=$1
	shift
	{
		test $# = 0 || printf '%s\n' "$@"
		sed "s/^cache-size=.*/cache-size=0/" cgitrc
	} >"$cgitrc_file"
}

# Runs cgit on the config file named first for the query string named second,
# passing on its output and its exit status, which is 0 for an error page too.
# A request that hangs, on a lock never let go say, is killed by an alarm,
# which survives the exec, so its test fails rather than the run stalling.
cgit_rc() {
	CGIT_CONFIG="$PWD/$1" QUERY_STRING="$2" \
		"$PERL_PATH" -e 'alarm shift; exec @ARGV or die "$ARGV[0]: $!\n"' 60 cgit
}

# These two ask the shared config, which keeps each page in a cache keyed on
# the request alone. A test that changes a repository and asks again for a page
# fetched before gets the old copy back, unless it uses cgit_ok_url.
cgit_query() {
	cgit_rc cgitrc "$1"
}

cgit_url() {
	cgit_rc cgitrc "url=$1"
}

# Asks for a page as cgit_rc does but fails unless the request really worked,
# with a 200 status, nothing logged and, for an HTML page, the closing tag.
# cgit exits 0 whatever goes wrong, and a death halfway through a page leaves
# it cut short behind a 200 status, so the exit status alone proves little.
# The page still goes to stdout and the log to stderr. Under -x a shell
# without BASH_XTRACEFD would trace cgit_rc into the log kept here, so the
# trace stops for that one call.
cgit_ok() {
	cgit_ok_flags=$-
	set +x
	cgit_rc "$@" >cgit-ok.out 2>cgit-ok.err
	cgit_ok_status=$?
	case $cgit_ok_flags in
	*x*)
		set -x
		;;
	esac
	cat cgit-ok.out
	cat cgit-ok.err >&2
	if test "$cgit_ok_status" != 0
	then
		echo "cgit exited with status $cgit_ok_status" >&2
		return 1
	elif test -s cgit-ok.err
	then
		echo "cgit logged an error" >&2
		return 1
	elif ! sed -n 1p cgit-ok.out | grep "^Status: 200" >/dev/null
	then
		echo "cgit answered $(sed -n 1p cgit-ok.out)" >&2
		return 1
	elif sed "/^$/q" cgit-ok.out | grep -i "^Content-Type: text/html" >/dev/null &&
		! grep "</html>" cgit-ok.out >/dev/null
	then
		echo "the page stops short of </html>" >&2
		return 1
	fi
}

# The same against the shared repositories, through a copy of the shared
# config with the page cache off, so the page is rendered afresh rather than
# replayed from a slot an earlier test filled.
cgit_ok_url() {
	sed "s/^cache-size=.*/cache-size=0/" cgitrc >cgitrc-ok &&
	cgit_ok cgitrc-ok "url=$1"
}

# The response headers run down to the first empty line, and a test comparing
# two pages wants to see the bodies alone.
strip_headers() {
	while read -r strip_headers_line
	do
		test -z "$strip_headers_line" && break
	done
	cat
}

# The fixtures are built here rather than in a test so that --run can still
# pick out any test, and a fixture that cannot be built stops the run where
# it broke rather than failing every test after it.
if test -z "$CGIT_TEST_NO_CREATE_REPOS"
then
	setup_repos || BAIL_OUT "the shared repositories could not be built"
fi