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.
while test $# != 0
do
	case "$1" in
	--va|--val|--valg|--valgr|--valgri|--valgrin|--valgrind)
		cgit_valgrind=t
		test_argv="$test_argv${LF}--verbose"
		;;
	*)
		test_argv="$test_argv$LF$1"
		;;
	esac
	shift
done

OLDIFS=$IFS
IFS=$LF
set -- $test_argv
IFS=$OLDIFS

: ${TEST_DIRECTORY=$(pwd)/../vendor/git/t}
: ${TEST_OUTPUT_DIRECTORY=$(pwd)}
# The library would otherwise leave a repository of its own in the trash
# directory, and every repository these tests want is built by mkrepo below.
TEST_NO_CREATE_REPO=YesPlease
. "$TEST_DIRECTORY"/test-lib.sh

# The library spells its results directory test-results and derives these
# variables before it can be told otherwise, so they are re-pointed at the
# plainer results/. The --tee and --stress raw logs and the leak logs write
# earlier and keep the library's name.
TEST_RESULTS_DIR="$TEST_OUTPUT_DIRECTORY/results"
TEST_RESULTS_BASE="$TEST_RESULTS_DIR/$TEST_NAME$TEST_STRESS_JOB_SFX"

# 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.
if test -n "$cgit_valgrind"
then
	GIT_VALGRIND="$TEST_DIRECTORY/valgrind"
	CGIT_VALGRIND=$(cd "$TEST_OUTPUT_DIRECTORY/valgrind" && pwd)
	PATH="$CGIT_VALGRIND/bin:$PATH"
	export GIT_VALGRIND CGIT_VALGRIND
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.
if cgit --version | grep -F -q "[+] Lua scripting"
then
	CGIT_HAS_LUA=1
	test_set_prereq CGIT_LUA
else
	CGIT_HAS_LUA=0
fi

# 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() {
	repo=$1
	commits=$2
	variant=$3
	test_create_repo "$repo"
	(
		cd "$repo"
		n=1
		while test $n -le $commits
		do
			echo $n >file-$n
			git add file-$n
			git commit -m "commit $n"
			n=$((n + 1))
		done
		case "$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, 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 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"
}

cgit_rc() {
	CGIT_CONFIG="$PWD/$1" QUERY_STRING="$2" cgit
}

cgit_query() {
	cgit_rc cgitrc "$1"
}

cgit_url() {
	cgit_rc cgitrc "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 line
	do
		test -z "$line" && break
	done
	cat
}

test -z "$CGIT_TEST_NO_CREATE_REPOS" && setup_repos