#!/bin/sh

# Checks the post-receive hooks under custom/hooks. The cache hook runs from a
# copy pointed at a cache and a scan path in the trash directory, since the
# shipped one names the system's own. The hooks run inside a repository's git
# directory the way git runs them after a push, and once each installed and
# pushed to.

test_description='Check the shipped post-receive hooks'
CGIT_TEST_NO_CREATE_REPOS=YesPlease
. ./setup.sh

HOOK_DIRECTORY="$TEST_OUTPUT_DIRECTORY/../custom/hooks"

# The request each page slot in a directory answers, read off its head the
# way the hook reads it, leaving out the locks and the cached repository
# scan.
cached_requests() {
	test -d "$1" || return 1
	for slot in "$1"/*
	do
		case $slot in
		*.lock | */rc-*)
			continue
			;;
		esac
		dd if="$slot" bs=4096 count=1 2>/dev/null >slot-head &&
		tr "\0" "\n" <slot-head | sed -n 1p || return 1
	done
}

# Every cache hook run starts from the cache as cgit left it.
fresh_slots() {
	rm -rf slots && cp -R pristine slots
}

# A cache that cgit itself filled, for the scanned repositories and the
# index, so the hook reads the keys cgit really writes. Each page has to
# have a slot of its own, or a check that a page went would pass for one
# that was never there.
test_expect_success 'set up a cache of three repositories and the index' '
	test_create_repo pusher &&
	test_commit -C pusher cached &&
	mkdir scan slots &&
	git init -q --bare scan/a.git &&
	git init -q --bare scan/b.git &&
	git init -q --bare scan/foo+bar.git &&
	git -C pusher push -q ../scan/a.git HEAD:refs/heads/main &&
	git -C pusher push -q ../scan/b.git HEAD:refs/heads/main &&
	git -C pusher push -q ../scan/foo+bar.git HEAD:refs/heads/main &&
	{
		echo "cache-root=$PWD/slots" &&
		echo "cache-size=1000" &&
		echo "virtual-root=/" &&
		echo "scan-path=$PWD/scan"
	} >cachedrc &&
	for page in / /a.git/ /a.git/log/ /b.git/ /b.git/log/
	do
		CGIT_CONFIG="$PWD/cachedrc" PATH_INFO="$page" QUERY_STRING= cgit >/dev/null ||
		return 1
	done &&
	cgit_rc cachedrc "url=a.git/refs/" >/dev/null &&
	cgit_rc cachedrc "url=b.git/refs/" >/dev/null &&
	cgit_rc cachedrc "r=a.git&p=log" >/dev/null &&
	cgit_rc cachedrc "r=b.git&p=log" >/dev/null &&
	CGIT_CONFIG="$PWD/cachedrc" PATH_INFO=/foo+bar.git/log/ QUERY_STRING= cgit >/dev/null &&
	cgit_rc cachedrc "url=foo%2bbar.git/refs/" >/dev/null &&
	cgit_rc cachedrc "r=foo%2Bbar.git&p=log" >/dev/null &&
	echo writer >slots/0123abcd.lock &&
	printf "not a key\0page" >slots/00000000 &&
	cp -R slots pristine &&
	sort >expect-keys <<-\EOF &&
	7|http://0|1|/0|
	7|http://0|7|/a.git/0|
	7|http://0|11|/a.git/log/0|
	7|http://0|7|/b.git/0|
	7|http://0|11|/b.git/log/0|
	7|http://0|0|15|url=a.git/refs/
	7|http://0|0|15|url=b.git/refs/
	7|http://0|0|13|r=a.git&p=log
	7|http://0|0|13|r=b.git&p=log
	7|http://0|17|/foo+bar.git/log/0|
	7|http://0|0|23|url=foo%2bbar.git/refs/
	7|http://0|0|21|r=foo%2Bbar.git&p=log
	not a key
	EOF
	cached_requests pristine >keys &&
	sort keys >sorted-keys &&
	test_cmp expect-keys sorted-keys &&
	ls pristine >pristine-slots &&
	grep "^rc-" pristine-slots &&
	sed -e "s|^cache_root=.*|cache_root='\''$PWD/slots'\''|" \
		-e "s|^scan_path=.*|scan_path='\''$PWD/scan'\''|" \
		"$HOOK_DIRECTORY/post-receive.cgit-cache" >cache-hook &&
	grep -Fx "cache_root='\''$PWD/slots'\''" cache-hook &&
	grep -Fx "scan_path='\''$PWD/scan'\''" cache-hook
'

# With remove-suffix the url leaves out the .git the scan found, and the
# hook has to leave it out the same way.
test_expect_success 'set up a cache of repositories served without the suffix' '
	mkdir suffix-slots &&
	{
		echo "cache-root=$PWD/suffix-slots" &&
		echo "cache-size=1000" &&
		echo "virtual-root=/" &&
		echo "remove-suffix=1" &&
		echo "scan-path=$PWD/scan"
	} >suffixrc &&
	for page in / /a/ /a/log/ /b/ /b/log/
	do
		CGIT_CONFIG="$PWD/suffixrc" PATH_INFO="$page" QUERY_STRING= cgit >/dev/null ||
		return 1
	done &&
	cp -R suffix-slots suffix-pristine &&
	cached_requests suffix-pristine >keys &&
	test_grep "|/a/log/0|" keys &&
	test_grep "|/b/log/0|" keys &&
	test_grep "|1|/0|" keys &&
	sed -e "s|^cache_root=.*|cache_root='\''$PWD/suffix-slots'\''|" \
		-e "s|^remove_suffix=.*|remove_suffix=1|" cache-hook >suffix-hook &&
	grep -Fx "cache_root='\''$PWD/suffix-slots'\''" suffix-hook &&
	grep -Fx "remove_suffix=1" suffix-hook
'

# scan-path finds a repository with a work tree by its .git and serves it at
# the work tree's path, while git runs its post-receive in the .git.
test_expect_success 'set up a cache of a scanned repository with a work tree' '
	git clone -q pusher scan/c &&
	mkdir worktree-slots &&
	sed "s|^cache-root=.*|cache-root=$PWD/worktree-slots|" cachedrc >worktreerc &&
	for page in / /a.git/ /c/ /c/log/
	do
		CGIT_CONFIG="$PWD/worktreerc" PATH_INFO="$page" QUERY_STRING= cgit >/dev/null ||
		return 1
	done &&
	cp -R worktree-slots worktree-pristine &&
	cached_requests worktree-pristine >keys &&
	test_grep "|/c/0|" keys &&
	test_grep "|/c/log/0|" keys &&
	test_grep "|/a.git/0|" keys &&
	sed "s|^cache_root=.*|cache_root='\''$PWD/worktree-slots'\''|" cache-hook >worktree-hook &&
	grep -Fx "cache_root='\''$PWD/worktree-slots'\''" worktree-hook
'

# The hooks are POSIX sh, so every case runs under each such shell that is
# here, once however many names reach it. Whatever a hook prints reaches the
# pusher, so each has to stay silent.
shells=
shell_paths=
for shell in sh dash ksh mksh yash posh bash zsh busybox
do
	shell_path=$(command -v $shell) || continue
	for seen in $shell_paths
	do
		test "$seen" -ef "$shell_path" && continue 2
	done
	shell_paths="$shell_paths $shell_path"
	shells="$shells $shell"
done
say "running the hooks under$shells"

# Every case below needs the set-up tests above it, and some need the case
# before them under the same shell, so a --run subset has to take those too.

for shell in $shells
do
	# zsh and busybox behave as sh only when asked to.
	case $shell in
	zsh)
		run="zsh --emulate sh"
		;;
	busybox)
		run="busybox sh"
		;;
	*)
		run=$shell
		;;
	esac

	test_expect_success "a push drops its own pages and the index under $shell" '
		fresh_slots &&
		(cd scan/a.git && $run ../../cache-hook 2>../../err) &&
		test_must_be_empty err &&
		cached_requests slots >left &&
		test_grep "|/b.git/log/" left &&
		test_grep "url=b.git/refs/" left &&
		test_grep "r=b.git&p=log" left &&
		test_grep ! "a.git" left &&
		test_grep ! "1|/0|" left &&
		test_grep ! "not a key" left &&
		test_path_is_file slots/0123abcd.lock &&
		ls slots >left-slots &&
		test_grep ! "^rc-" left-slots
	'

	test_expect_success "a push drops the pages of a repository served without the suffix under $shell" '
		rm -rf suffix-slots && cp -R suffix-pristine suffix-slots &&
		(cd scan/a.git && $run ../../suffix-hook 2>../../err) &&
		test_must_be_empty err &&
		cached_requests suffix-slots >left &&
		test_grep "|/b/log/0|" left &&
		test_grep ! "|/a/" left &&
		test_grep ! "|1|/0|" left
	'

	test_expect_success "a push to a repository with a work tree drops its pages under $shell" '
		rm -rf worktree-slots && cp -R worktree-pristine worktree-slots &&
		(cd scan/c/.git && $run ../../../worktree-hook 2>../../../err) &&
		test_must_be_empty err &&
		cached_requests worktree-slots >left &&
		test_grep "|/a.git/0|" left &&
		test_grep ! "|/c/" left
	'

	test_expect_success "a push drops the pages of a repository whose url is escaped under $shell" '
		fresh_slots &&
		(cd scan/foo+bar.git && $run ../../cache-hook 2>../../err) &&
		test_must_be_empty err &&
		cached_requests slots >left &&
		test_grep "|/b.git/log/" left &&
		test_grep "url=b.git/refs/" left &&
		test_grep ! "foo" left
	'

	test_expect_success "a repository named in cgitrc gives the hook its url under $shell" '
		fresh_slots &&
		git -C scan/b.git config hooks.cgiturl b.git &&
		sed "s|^scan_path=.*|scan_path=/nonexistent|" cache-hook >named-hook &&
		grep -Fx "scan_path=/nonexistent" named-hook &&
		(cd scan/b.git && $run ../../named-hook 2>../../err) &&
		test_must_be_empty err &&
		cached_requests slots >left &&
		test_grep "|/a.git/log/" left &&
		test_grep ! "b.git" left
	'

	test_expect_success "with no url to go on the whole cache goes under $shell" '
		fresh_slots &&
		(cd scan/a.git && $run ../../named-hook 2>../../err) &&
		test_must_be_empty err &&
		test "$(ls slots)" = 0123abcd.lock
	'

	test_expect_success "the cache hook does nothing without a cache root under $shell" '
		sed "s|^cache_root=.*|cache_root='\''$PWD/none'\''|" cache-hook >rootless-hook &&
		grep -Fx "cache_root='\''$PWD/none'\''" rootless-hook &&
		(cd scan/a.git && $run ../../rootless-hook 2>../../err) &&
		test_must_be_empty err &&
		test_path_is_missing none
	'

	test_expect_success SANITY "the cache hook shows a pusher no error under $shell" '
		fresh_slots &&
		test_when_finished "chmod 755 slots" &&
		chmod 555 slots &&
		(cd scan/a.git && $run ../../cache-hook 2>../../err) &&
		test_must_be_empty err &&
		ls slots >left &&
		test_cmp pristine-slots left
	'
done

# The newest branch tip by committer date is main. The other branch has the
# newer author date, a tag outside refs/heads points at a newer commit
# still, and an annotated tag was made later than all of them.
test_expect_success 'set up a repository whose dates disagree' '
	test_create_repo work &&
	(
		cd work &&
		echo one >file &&
		git add file &&
		GIT_AUTHOR_DATE="2001-01-01 00:00:00 +0000" \
		GIT_COMMITTER_DATE="2021-02-03 04:05:06 +0000" git commit -q -m newest &&
		git branch -M main &&
		git checkout -q -b old &&
		echo two >file &&
		GIT_AUTHOR_DATE="2029-01-01 00:00:00 +0000" \
		GIT_COMMITTER_DATE="2019-01-01 00:00:00 +0000" git commit -q -a -m older &&
		echo three >file &&
		GIT_COMMITTER_DATE="2025-01-01 00:00:00 +0000" git commit -q -a -m loose &&
		git tag loose &&
		git reset -q --hard HEAD^ &&
		GIT_COMMITTER_DATE="2027-01-01 00:00:00 +0000" git tag -a -m release release main
	) &&
	git init -q --bare plain.git &&
	git -C work push -q ../plain.git main old loose release &&
	echo "2021-02-03 04:05:06 +0000" >expect &&
	echo last-modified >expect-entries &&
	echo kept >kept
'

for shell in $shells
do
	test_expect_success "the age hook writes the newest branch commit date under $shell" '
		rm -f plain.git/info/web/last-modified &&
		(cd plain.git && $run "$HOOK_DIRECTORY/post-receive.cgit-age" 2>../err) &&
		test_must_be_empty err &&
		test_cmp expect plain.git/info/web/last-modified &&
		ls plain.git/info/web >entries &&
		test_cmp expect-entries entries
	'

	test_expect_success "cgit shows the date the age hook wrote as the idle time under $shell" '
		cgitrc_repo agerc plain "repo.path=$PWD/plain.git" &&
		cgit_ok agerc "" >index &&
		test_grep "<td class=.col-idle.><time [^>]*data-ut=.1612325106." index
	'

	test_expect_success SANITY "the age hook shows a pusher no error under $shell" '
		cp kept plain.git/info/web/last-modified &&
		test_when_finished "chmod 755 plain.git/info/web" &&
		chmod 555 plain.git/info/web &&
		(cd plain.git && $run "$HOOK_DIRECTORY/post-receive.cgit-age" 2>../err) &&
		test_must_be_empty err &&
		test_cmp kept plain.git/info/web/last-modified &&
		ls plain.git/info/web >entries &&
		test_cmp expect-entries entries
	'

	test_expect_success "the age hook replaces a file it cannot write in a directory it can under $shell" '
		rm -f plain.git/info/web/last-modified &&
		cp kept plain.git/info/web/last-modified &&
		chmod 444 plain.git/info/web/last-modified &&
		(cd plain.git && $run "$HOOK_DIRECTORY/post-receive.cgit-age" 2>../err) &&
		test_must_be_empty err &&
		test_cmp expect plain.git/info/web/last-modified
	'

	test_expect_success "the age hook leaves a repository with no branches as it was under $shell" '
		git init -q --bare tags-$shell.git &&
		git -C work push -q ../tags-$shell.git release &&
		mkdir -p tags-$shell.git/info/web &&
		echo kept >tags-$shell.git/info/web/last-modified &&
		(cd tags-$shell.git && $run "$HOOK_DIRECTORY/post-receive.cgit-age" 2>../err) &&
		test_must_be_empty err &&
		test_cmp kept tags-$shell.git/info/web/last-modified
	'

	test_expect_success SANITY "the age hook shows no error when it cannot make its directory under $shell" '
		git init -q --bare closed-$shell.git &&
		git -C work push -q ../closed-$shell.git main &&
		test_when_finished "chmod 755 closed-$shell.git/info" &&
		chmod 555 closed-$shell.git/info &&
		(cd closed-$shell.git && $run "$HOOK_DIRECTORY/post-receive.cgit-age" 2>../err) &&
		test_must_be_empty err &&
		test_path_is_missing closed-$shell.git/info/web
	'

	# git keeps a shared repository group writable whatever the pusher's
	# umask, and the next member to push has to be able to replace the file.
	test_expect_success SANITY "the age hook keeps a shared directory group writable under $shell" '
		git init -q --bare --shared=group shared-$shell.git &&
		git -C work push -q ../shared-$shell.git main &&
		(cd shared-$shell.git && umask 022 && $run "$HOOK_DIRECTORY/post-receive.cgit-age" 2>../err) &&
		test_must_be_empty err &&
		ls -ld shared-$shell.git/info/web >mode &&
		test_grep "^drwxrw[xs]" mode
	'

	# The web server reads what the hooks write, so the pusher's own umask
	# must not keep it out.
	test_expect_success "the age hook writes a file anyone can read under a tight umask under $shell" '
		git init -q --bare private-$shell.git &&
		git -C work push -q ../private-$shell.git main &&
		(cd private-$shell.git && umask 077 && $run "$HOOK_DIRECTORY/post-receive.cgit-age" 2>../err) &&
		test_must_be_empty err &&
		ls -ld private-$shell.git/info/web private-$shell.git/info/web/last-modified >mode &&
		test_grep "^drwxr-xr-x" mode &&
		test_grep "^-rw-r--r--" mode
	'

	test_expect_success "the age hook reads core.sharedRepository as git does under $shell" '
		git -C private-$shell.git config core.sharedRepository FALSE &&
		rm private-$shell.git/info/web/last-modified &&
		(cd private-$shell.git && umask 077 && $run "$HOOK_DIRECTORY/post-receive.cgit-age" 2>../err) &&
		test_must_be_empty err &&
		ls -l private-$shell.git/info/web/last-modified >mode &&
		test_grep "^-rw-r--r--" mode &&
		git -C private-$shell.git config core.sharedRepository 0660 &&
		rm private-$shell.git/info/web/last-modified &&
		(cd private-$shell.git && umask 077 && $run "$HOOK_DIRECTORY/post-receive.cgit-age" 2>../err) &&
		test_must_be_empty err &&
		ls -l private-$shell.git/info/web/last-modified >mode &&
		test_grep "^-rw-rw-r--" mode
	'

	test_expect_success "the commit-graph hook writes a graph with path filters under $shell" '
		git init -q --bare graph-$shell.git &&
		git -C work push -q ../graph-$shell.git main &&
		(cd graph-$shell.git && $run "$HOOK_DIRECTORY/post-receive.commit-graph" 2>../err) &&
		test_must_be_empty err &&
		test_path_is_file graph-$shell.git/objects/info/commit-graphs/commit-graph-chain &&
		grep -q BDAT graph-$shell.git/objects/info/commit-graphs/*.graph &&
		git -C graph-$shell.git commit-graph verify
	'

	test_expect_success "the commit-graph hook writes a graph anyone can read under a tight umask under $shell" '
		git init -q --bare private-graph-$shell.git &&
		git -C work push -q ../private-graph-$shell.git main &&
		(cd private-graph-$shell.git && umask 077 && $run "$HOOK_DIRECTORY/post-receive.commit-graph" 2>../err) &&
		test_must_be_empty err &&
		ls -l private-graph-$shell.git/objects/info/commit-graphs >modes &&
		test_grep "commit-graph-chain" modes &&
		test_grep "\.graph" modes &&
		test_grep ! "^-r-------" modes
	'

	# The newest layer is the last line of the chain, and it has to be one
	# the push itself added.
	test_expect_success "a later push moves the graph on under $shell" '
		graphs=graph-$shell.git/objects/info/commit-graphs &&
		cp $graphs/commit-graph-chain chain-$shell &&
		test_commit -C work graph-$shell &&
		git -C work push -q ../graph-$shell.git HEAD:main &&
		(cd graph-$shell.git && $run "$HOOK_DIRECTORY/post-receive.commit-graph" 2>../err) &&
		test_must_be_empty err &&
		newest=$(tail -n 1 $graphs/commit-graph-chain) &&
		test -n "$newest" &&
		test_path_is_file $graphs/graph-$newest.graph &&
		test_grep ! "^$newest\$" chain-$shell &&
		git -C graph-$shell.git commit-graph verify
	'

	test_expect_success "a git too old to write the graph leaves it quietly under $shell" '
		mkdir -p old-git &&
		write_script old-git/git <<-\EOF &&
		if test "$1" = commit-graph
		then
			echo "error: unknown option" >&2
			exit 129
		fi
		exec "$REAL_GIT" "$@"
		EOF
		real_git=$(command -v git) &&
		shim="$PWD/old-git" &&
		graphs=graph-$shell.git/objects/info/commit-graphs &&
		cp $graphs/commit-graph-chain old-chain-$shell &&
		test_commit -C work old-$shell &&
		git -C work push -q ../graph-$shell.git HEAD:main &&
		(
			cd graph-$shell.git &&
			REAL_GIT=$real_git PATH="$shim:$PATH" $run "$HOOK_DIRECTORY/post-receive.commit-graph" 2>../err
		) &&
		test_must_be_empty err &&
		test_cmp old-chain-$shell $graphs/commit-graph-chain
	'
done

# Installed, a hook runs by its shebang with GIT_DIR set and the pushed refs
# on stdin, and whatever it prints reaches the pusher behind "remote:".
test_expect_success 'the age hook works installed in a repository pushed to' '
	git init -q --bare pushed-age.git &&
	cp "$HOOK_DIRECTORY/post-receive.cgit-age" pushed-age.git/hooks/post-receive &&
	git -C work push ../pushed-age.git main 2>push-err &&
	test_grep "main -> main" push-err &&
	test_grep ! "^remote:" push-err &&
	test_cmp expect pushed-age.git/info/web/last-modified
'

test_expect_success 'the cache hook works installed in a repository pushed to' '
	fresh_slots &&
	cp cache-hook scan/a.git/hooks/post-receive &&
	chmod +x scan/a.git/hooks/post-receive &&
	test_when_finished "rm -f scan/a.git/hooks/post-receive" &&
	test_commit -C pusher pushed &&
	git -C pusher push ../scan/a.git HEAD:refs/heads/main 2>push-err &&
	test_grep "HEAD -> main" push-err &&
	test_grep ! "^remote:" push-err &&
	cached_requests slots >left &&
	test_grep "|/b.git/log/" left &&
	test_grep ! "a.git" left
'

test_expect_success 'the commit-graph hook works installed in a repository pushed to' '
	git init -q --bare pushed-graph.git &&
	cp "$HOOK_DIRECTORY/post-receive.commit-graph" pushed-graph.git/hooks/post-receive &&
	git -C work push ../pushed-graph.git main 2>push-err &&
	test_grep "main -> main" push-err &&
	test_grep ! "^remote:" push-err &&
	test_path_is_file pushed-graph.git/objects/info/commit-graphs/commit-graph-chain &&
	git -C pushed-graph.git commit-graph verify
'

test_done