index : cgit

#!/bin/sh

# Checks the source, about, commit and email filters, which hand a piece of
# page content to an outside program before it is written out. The checks in
# the loop run once per kind of filter, the exec kind always and the lua kind
# only where cgit was built with lua, because both have to produce the same
# page from the same repository. Elsewhere the lua kind shows as skipped.

test_description='Check filtered content'
. ./setup.sh

for prefix in exec lua
do
	filter_prereq=
	test "$prefix" = exec || filter_prereq=CGIT_LUA

	# Page output is buffered and has to be flushed as stdout is handed
	# to a filter and back. A missed flush reorders the page rather than
	# losing any of it, so the test below watches which side of the
	# filtered text the surrounding markup lands on.
	test_expect_success $filter_prereq "the $prefix source filter gets the file name and fills the code cell" '
		cgit_ok_url "filter-$prefix/tree/a%2bb" >tmp &&
		grep "<code>a+b HELLO$" tmp &&
		tr -d "\n" <tmp >flat.out &&
		grep "<code>a+b HELLO</code>" flat.out
	'

	test_expect_success $filter_prereq "the $prefix about filter gets the readme name and the tree url" '
		cgit_ok_url "filter-$prefix/about/" >tmp &&
		grep "<div id=.about.>a+b /filter-$prefix/tree/  HELLO$" tmp
	'

	test_expect_success $filter_prereq "the $prefix commit filter rewrites the subject" '
		cgit_ok_url "filter-$prefix/commit/" >tmp &&
		grep "<div class=.commit-subject.>ADD A+B" tmp
	'

	test_expect_success $filter_prereq "the $prefix email filter gets the author's address and name" '
		cgit_ok_url "filter-$prefix/commit/" >tmp &&
		grep "<author@example.com> commit A U THOR &LT;AUTHOR@EXAMPLE.COM&GT;" tmp
	'

	test_expect_success $filter_prereq "the $prefix email filter gets the committer's address and name" '
		cgit_ok_url "filter-$prefix/commit/" >tmp &&
		grep "<committer@example.com> commit C O MITTER &LT;COMMITTER@EXAMPLE.COM&GT;" tmp
	'
done

test_expect_success 'the blame page goes through the source filter too' '
	cgitrc_copy blamerc enable-blame=1 &&
	cgit_rc blamerc "url=filter-exec/blame/a%2bb" >tmp &&
	grep "<td class=.linenumbers.>" tmp &&
	grep "<code>a+b HELLO$" tmp
'

# A readme read at another branch links into the tree at that branch, which
# the filter is told as the query to follow a path with.
test_expect_success 'the about filter gets the tree url at the readme branch' '
	cgitrc_repo aboutargsrc filtered readme=:a+b "about-filter=exec:$FILTER_DIRECTORY/dump.sh" "root-readme=$PWD/root.txt" "repo.path=$PWD/repos/filter/.git" &&
	cgit_rc aboutargsrc "url=filtered/about/&h=1%2b2" >tmp &&
	grep "<div id=.about.>a+b /filtered/tree/ ?h=1%2B2 HELLO" tmp
'

test_expect_success 'the site readme leaves the tree url empty' '
	echo site >root.txt &&
	cgit_rc aboutargsrc "p=about" >tmp &&
	grep "root.txt   SITE" tmp
'

test_expect_success 'only a repository page hands filters its variables' '
	write_script env.sh <<-\EOF &&
	cat >/dev/null
	echo "repo url: $CGIT_REPO_URL."
	EOF
	sed "s|^about-filter=.*|about-filter=exec:$PWD/env.sh|" aboutargsrc >envrc &&
	cgit_rc envrc "url=filtered/about/" >tmp &&
	grep "repo url: filtered\." tmp &&
	cgit_rc envrc "p=about" >tmp &&
	grep "repo url: \." tmp
'

# Only the auth filter's exit status means anything, so a content filter that
# fails after writing its output still leaves the page whole.
test_expect_success 'a content filter that exits non-zero still renders the page' '
	write_script failing-filter <<-\EOF &&
	cat
	exit 3
	EOF
	cgitrc_repo failingrc foo "repo.commit-filter=exec:$PWD/failing-filter" &&
	cgit_ok failingrc "url=foo/commit/" >tmp &&
	test_grep "<div class=.commit-subject.>commit 5" tmp
'

# A die inside a lua filter has to reach the visitor as an error page rather
# than being fed back into the filter that just failed, and the reason goes to
# the log.
test_expect_success CGIT_LUA 'a failing lua filter still renders an error page' '
	cat >broken.lua <<-\EOF &&
	function filter_open(...) error("boom") end
	function filter_write(str) end
	function filter_close() return 0 end
	EOF
	{
		echo "cache-size=0" &&
		echo "repo.url=foo" &&
		echo "repo.path=$PWD/repos/foo/.git" &&
		echo "auth-filter=lua:$PWD/broken.lua"
	} >brokenrc &&
	cgit_rc brokenrc "url=foo/commit" >tmp 2>err &&
	grep "Status: 500" tmp &&
	grep "Lua error in" err
'

# A script may raise a value that is no string, which the log still names.
test_expect_success CGIT_LUA 'a lua filter raising a table is named by type' '
	cat >tabled.lua <<-\EOF &&
	function filter_open(...) error({}) end
	function filter_write(str) end
	function filter_close() return 0 end
	EOF
	sed "s|broken.lua|tabled.lua|" brokenrc >tabledrc &&
	cgit_rc tabledrc "url=foo/commit" >tmp 2>err &&
	grep "Status: 500" tmp &&
	grep "Lua error in .*tabled.lua: (error object is a table value)" err
'

# A script runs its top level before cgit hooks stdout for it, so what it
# writes there goes straight onto the page instead of tripping the hook.
test_expect_success CGIT_LUA 'a lua filter that writes while loading still renders' '
	cat >loud.lua <<-\EOF &&
	html("written while loading")
	function filter_open(...) end
	function filter_write(str) html(str) end
	function filter_close() return 0 end
	EOF
	{
		echo "cache-size=0" &&
		echo "repo.url=foo" &&
		echo "repo.path=$PWD/repos/foo/.git" &&
		echo "repo.commit-filter=lua:$PWD/loud.lua"
	} >loudrc &&
	cgit_rc loudrc "url=foo/commit" >tmp &&
	grep "written while loading" tmp &&
	grep "</html>" tmp
'

# A Lua build replaces write, and git writes its trace before cgit has run a
# line of its own.
test_expect_success CGIT_LUA 'git can trace before the filters are set up' '
	CGIT_CONFIG="$PWD/cgitrc" GIT_TRACE2="$PWD/trace2.out" QUERY_STRING="url=foo/" cgit >tmp &&
	grep "</html>" tmp &&
	test -s trace2.out
'

# html_url_arg and html_include are the two calls a Lua filter has beyond
# plain html, and nothing else drives them.
test_expect_success CGIT_LUA 'a lua filter can encode an argument and include a file' '
	echo "included <b>bold</b>" >include.txt &&
	cat >apis.lua <<-EOF &&
	function filter_open(...) end
	function filter_write(str)
		html_url_arg("a b&c")
		html("|")
		html_include("$PWD/include.txt")
	end
	function filter_close() return 0 end
	EOF
	sed "s|loud.lua|apis.lua|" loudrc >apisrc &&
	cgit_rc apisrc "url=foo/commit" >tmp &&
	grep "a+b%26c|included <b>bold</b>" tmp
'

# The print of LuaJIT and Lua 5.1 leaves its line in stdio's buffer, which only
# reached the page as cgit exited, behind the closing tag. A print lands where
# the filter runs.
test_expect_success CGIT_LUA 'a lua filter prints where it runs' '
	cat >print.lua <<-\EOF &&
	function filter_open(...) end
	function filter_write(str)
		print("printed", 1, nil, true)
		html(str)
	end
	function filter_close() return 0 end
	EOF
	sed "s|loud.lua|print.lua|" loudrc >printrc &&
	cgit_rc printrc "url=foo/commit" >tmp &&
	tab=$(printf "\t") &&
	grep "<div class=.commit-subject.>printed${tab}1${tab}nil${tab}true$" tmp &&
	sed -n "/<\/html>/,\$p" tmp >tail &&
	! grep printed tail
'

test_done