index : cgit

#!/bin/sh

# The index page, one row per repository in cgitrc. The checks look for each
# fixture repository and its description, for the escaping a name with a
# plus or a space needs in a link, and for the absence of the tree and log
# links that belong to a repository's own pages unless enable-index-links
# asks for them. The page's head also stands in for every page's, with one
# link per css and js entry.

test_description='Check content on index page'
. ./setup.sh

test_expect_success 'generate index page' 'cgit_ok_url "" >tmp'
test_expect_success 'find foo repo' 'grep ">foo</a>" tmp'
test_expect_success 'find foo description' 'grep "href=./foo/.>\[no description\]</a>" tmp'
test_expect_success 'find bar repo' 'grep ">bar</a>" tmp'
test_expect_success 'find bar description' 'grep "the bar repo" tmp'
test_expect_success 'find foo+bar repo' 'grep ">foo+bar<" tmp'
test_expect_success 'verify foo+bar links' 'test $(grep -o "href=./foo%2Bbar/." tmp | wc -l) = 2'
test_expect_success 'verify "with%20space" links' 'test $(grep -o "href=./with%20space/." tmp | wc -l) = 2'

test_expect_success 'the index links no tree or log by default' '
	cgit_ok_url "" >tmp &&
	test_grep ">foo</a>" tmp &&
	test_grep ! "foo/tree" tmp &&
	test_grep ! "foo/log" tmp
'

test_expect_success 'index links lead to the summary, log and tree' '
	cgitrc_copy linksrc enable-index-links=1 &&
	cgit_ok linksrc "url=" >tmp &&
	grep "<a class=.button. href=./foo/.>summary</a><a class=.button. href=./foo/log/.>log</a>" tmp &&
	grep "href=./foo/log/.>log</a><a class=.button. href=./foo/tree/.>tree<" tmp
'

test_expect_success 'each css and js entry gets a link of its own' '
	cgitrc_copy headrc css=/a.css css=/b.css js=/a.js js= js=/b.js &&
	cgit_ok headrc "url=" >tmp &&
	grep "<link rel=.stylesheet. href=./a.css.>" tmp &&
	grep "<link rel=.stylesheet. href=./b.css.>" tmp &&
	grep "<script src=" tmp >scripts &&
	test_line_count = 2 scripts &&
	grep "/a.js" scripts &&
	grep "/b.js" scripts
'

# root-readme is the site's own file rather than repository content, so it
# goes out as written, on an about page of its own.
test_expect_success 'root-readme without a filter is its own page, as written' '
	echo "<b>site</b>" >root.html &&
	cgitrc_copy rootrc "root-readme=$PWD/root.html" &&
	cgit_ok rootrc "url=" >tmp &&
	test_grep "<li><a title=.About this site. href=./?p=about.>about</a>" tmp &&
	test_grep ! "<b>site</b>" tmp &&
	cgit_ok rootrc "p=about" >tmp &&
	test_grep "^<b>site</b>$" tmp
'

# The description limit counts bytes, so a cut has to land between
# characters rather than leave half of one on the page.
test_expect_success 'a cut description keeps whole characters' '
	cgitrc_copy descrc max-repodesc-length=10 &&
	{
		echo "repo.url=mb" &&
		echo "repo.path=$PWD/repos/foo/.git" &&
		echo "repo.desc=日本語の説明文です"
	} >>descrc &&
	cgit_ok descrc "url=" >tmp &&
	grep ">日本語\.\.\.</a>" tmp
'

test_expect_success 'a description limit of 0 or less leaves the ellipsis alone' '
	for limit in 0 -1
	do
		cgitrc_copy limitrc max-repodesc-length=$limit &&
		cgit_ok limitrc "url=" >tmp &&
		test_grep "href=./bar/.>\.\.\.</a>" tmp || return 1
	done
'

# A url naming no repository falls through to the index as a prefix that
# matches none, which is not the same as a search finding nothing.
test_expect_success 'a url matching no repository says so' '
	cgit_url "nonexistent/tree/" >tmp &&
	grep "^Status: 404" tmp &&
	grep "<div class=.error.>Nothing matches this url</div>" tmp &&
	cgit_query "q=nonexistent" >tmp &&
	grep "^Status: 404" tmp &&
	grep "<div class=.error.>No repositories found</div>" tmp
'

test_expect_success 'a search finding nothing under a url prefix says so' '
	cgitrc_repos prefixrc \
		repo.url=a/x "repo.path=$PWD/repos/foo/.git" \
		repo.url=a/y "repo.path=$PWD/repos/foo/.git" &&
	cgit_ok prefixrc "url=a/" >tmp &&
	test_grep ">a/x</a>" tmp &&
	test_grep ">a/y</a>" tmp &&
	cgit_rc prefixrc "url=a/&q=zzz" >tmp &&
	test_grep "^Status: 404" tmp &&
	test_grep "<div class=.error.>No repositories found</div>" tmp
'

# Fails unless the index of orderrc, asked for with the query given first,
# lists the repositories in the order the rest name.
test_index_order() {
	cgit_ok orderrc "$1" >tmp &&
	sed -n "s/.*class=.col-name toplevel-repo.><a href=.\/.\/.>\(.\)<\/a>.*/\1/p" tmp >order &&
	shift &&
	printf "%s\n" "$@" >expect &&
	test_cmp expect order
}

# Each column sorts these three into an order of its own, and none of them
# is the cgitrc order an unsorted index keeps. The age files date them in
# the reverse of the order they are made in, so the ref times alone cannot
# put the idle sort right.
test_expect_success 'set up repositories each column sorts apart' '
	for name in b a c
	do
		git init -q --bare "orders/$name.git" &&
		mkdir "orders/$name.git/info/web" || return 1
	done &&
	echo "2005-04-03 10:00:00 +0000" >orders/a.git/info/web/last-modified &&
	echo "2005-04-05 10:00:00 +0000" >orders/b.git/info/web/last-modified &&
	echo "2005-04-01 10:00:00 +0000" >orders/c.git/info/web/last-modified &&
	cgitrc_repos orderrc \
		repo.url=c "repo.path=$PWD/orders/c.git" \
		"repo.desc=first by description" "repo.owner=second owner" \
		repo.url=a "repo.path=$PWD/orders/a.git" \
		"repo.desc=third by description" "repo.owner=first owner" \
		repo.url=b "repo.path=$PWD/orders/b.git" \
		"repo.desc=second by description" "repo.owner=third owner" &&
	test_index_order "url=" c a b
'

test_expect_success 'the index sorts by each column on request' '
	test_index_order "s=name" a b c &&
	test_index_order "s=desc" c b a &&
	test_index_order "s=owner" a c b &&
	test_index_order "s=idle" b a c
'

test_expect_success 'the idle column shows the date the age file holds' '
	cgit_ok orderrc "url=" >tmp &&
	test_grep "<td class=.col-idle.><time class=.age-years. datetime=.2005-04-05T10:00:00Z." tmp
'

# Fails unless the index of the config named first, asked for with the query
# given second, lists the sections, bracketed, and the repositories under
# them in the order the rest name. A section heading spans every column,
# which comes to five with the owner and links columns both on.
test_section_order() {
	cgit_ok "$1" "$2" >tmp &&
	sed -n -e "s/.*<td colspan=.5. class=.reposection.>\(.*\)<\/td>.*/[\1]/p" \
		-e "s/.*class=.col-name sublevel-repo.><a href=[^>]*>\([^<]*\)<\/a>.*/\1/p" tmp >order &&
	shift 2 &&
	printf "%s\n" "$@" >expect &&
	test_cmp expect order
}

# The age files order the alpha section apart from both its cgitrc order and
# its names.
test_expect_success 'set up repositories in two sections' '
	for name in z1 a2 a3 a1
	do
		git init -q --bare "sections/$name.git" &&
		mkdir "sections/$name.git/info/web" || return 1
	done &&
	echo "2005-04-01 10:00:00 +0000" >sections/a2.git/info/web/last-modified &&
	echo "2005-04-05 10:00:00 +0000" >sections/a3.git/info/web/last-modified &&
	echo "2005-04-03 10:00:00 +0000" >sections/a1.git/info/web/last-modified &&
	cgitrc_repos sectionrc enable-index-links=1 \
		section=zeta \
		repo.url=z1 "repo.path=$PWD/sections/z1.git" \
		section=alpha \
		repo.url=a2 "repo.path=$PWD/sections/a2.git" \
		repo.url=a3 "repo.path=$PWD/sections/a3.git" \
		repo.url=a1 "repo.path=$PWD/sections/a1.git" &&
	{
		echo "section-sort=1" &&
		cat sectionrc
	} >sectionsortrc &&
	{
		echo "repository-sort=age" &&
		cat sectionsortrc
	} >sectionagerc
'

test_expect_success 'the index keeps the cgitrc order of sections' '
	test_section_order sectionrc "url=" "[zeta]" z1 "[alpha]" a2 a3 a1
'

test_expect_success 'section-sort orders the sections and their repositories' '
	test_section_order sectionsortrc "url=" "[alpha]" a1 a2 a3 "[zeta]" z1 &&
	test_section_order sectionagerc "url=" "[alpha]" a3 a1 a2 "[zeta]" z1
'

# Sorted by a column, the rows no longer run section by section.
test_expect_success 'an index sorted by a column drops the sections' '
	cgit_ok sectionrc "s=name" >tmp &&
	test_grep "class=.col-name toplevel-repo.><a href=./a1/.>a1</a>" tmp &&
	test_grep ! "reposection" tmp &&
	test_grep ! "sublevel-repo" tmp
'

# Only the heading of the column the index is sorted by tells a screen reader
# so. Idle lists the latest change first, so it is ascending like the rest.
test_expect_success 'the sorted column heading says which way it runs' '
	for s in name desc owner idle
	do
		cgit_ok_url "&s=$s" >tmp &&
		grep "<th class=.left col-$s. scope=.col. aria-sort=.ascending.>" tmp &&
		test $(grep -o "aria-sort" tmp | wc -l) = 1 || return 1
	done &&
	cgit_ok_url "" >tmp &&
	test_grep "<th class=.left col-name. scope=.col.><a href=./?s=name.>Name</a></th>" tmp &&
	test_grep ! "aria-sort" tmp
'

# A scan has no cgitrc order for the index to keep, so it lists what it finds
# by path whatever order the directory hands back, comparing names the way
# case-sensitive-sort tells the index to.
test_expect_success 'a scan lists repositories in path order' '
	for name in proj9 Proj3 proj7 proj1 Proj5 proj8 proj2 proj6 proj4
	do
		git init -q --bare "sorted/$name.git" || return 1
	done &&
	{
		echo "virtual-root=/" &&
		echo "cache-size=0" &&
		echo "scan-path=$PWD/sorted"
	} >sortrc &&
	{
		echo "case-sensitive-sort=0" &&
		cat sortrc
	} >foldrc &&
	cgit_ok sortrc "url=" >tmp &&
	sed -n "s/.*>\([Pp]roj[0-9]\)\.git<\/a>.*/\1/p" tmp >order &&
	printf "%s\n" Proj3 Proj5 proj1 proj2 proj4 proj6 proj7 proj8 proj9 >expect &&
	test_cmp expect order &&
	cgit_ok foldrc "url=" >tmp &&
	sed -n "s/.*>\([Pp]roj[0-9]\)\.git<\/a>.*/\1/p" tmp >order &&
	printf "%s\n" proj1 proj2 Proj3 proj4 Proj5 proj6 proj7 proj8 proj9 >expect &&
	test_cmp expect order
'

# A repository listed without repo.desc shows the first line of its own
# description file, as a scanned one does. A repo.desc after the repo.path
# still wins, and git's placeholder still reads as no description.
test_expect_success 'a repository without repo.desc reads its description file' '
	mkrepo repos/described 1 &&
	printf "told by the file\nsecond line\n" >repos/described/.git/description &&
	cgitrc_repos describedrc \
		repo.url=described "repo.path=$PWD/repos/described/.git" \
		repo.url=overridden "repo.path=$PWD/repos/described/.git" \
		"repo.desc=from cgitrc" \
		repo.url=placeholder "repo.path=$PWD/repos/foo/.git" &&
	cgit_ok describedrc "url=" >tmp &&
	grep "href=./described/.>told by the file</a>" tmp &&
	grep "href=./overridden/.>from cgitrc</a>" tmp &&
	grep "href=./placeholder/.>\[no description\]</a>" tmp &&
	test_grep ! "second line" tmp &&
	cgit_ok describedrc "url=described/" >tmp &&
	grep "<meta name=.description. content=.told by the file.>" tmp
'

# The search and the sort look at descriptions too, so the file has to be
# read before either of them.
test_expect_success 'the search and the sort see a description file' '
	cgit_ok describedrc "q=told" >tmp &&
	test_grep "href=./described/.>told by the file</a>" tmp &&
	test_grep ! ">overridden</a>" tmp &&
	cgit_ok describedrc "s=desc" >tmp &&
	sed -n "s/.*class=.col-name toplevel-repo.><a href=.\/[a-z]*\/.>\([a-z]*\)<\/a>.*/\1/p" tmp >order &&
	printf "%s\n" placeholder overridden described >expect &&
	test_cmp expect order
'

test_done