[thirdparty/git.git] / t / t7006-pager.sh

#!/bin/sh

test_description='Test automatic use of a pager.'

. ./test-lib.sh
. "$TEST_DIRECTORY"/lib-pager.sh
. "$TEST_DIRECTORY"/lib-terminal.sh

test_expect_success 'setup' '
	sane_unset GIT_PAGER GIT_PAGER_IN_USE &&
	test_unconfig core.pager &&

	PAGER="cat >paginated.out" &&
	export PAGER &&

	test_commit initial
'

test_expect_success TTY 'some commands use a pager' '
	rm -f paginated.out &&
	test_terminal git log &&
	test -e paginated.out
'

test_expect_failure TTY 'pager runs from subdir' '
	echo subdir/paginated.out >expected &&
	mkdir -p subdir &&
	rm -f paginated.out subdir/paginated.out &&
	(
		cd subdir &&
		test_terminal git log
	) &&
	{
		ls paginated.out subdir/paginated.out ||
		:
	} >actual &&
	test_cmp expected actual
'

test_expect_success TTY 'LESS and LV envvars are set for pagination' '
	(
		sane_unset LESS LV &&
		PAGER="env >pager-env.out; wc" &&
		export PAGER &&

		test_terminal git log
	) &&
	grep ^LESS= pager-env.out &&
	grep ^LV= pager-env.out
'

test_expect_success !MINGW,TTY 'LESS and LV envvars set by git-sh-setup' '
	(
		sane_unset LESS LV &&
		PAGER="env >pager-env.out; wc" &&
		export PAGER &&
		PATH="$(git --exec-path):$PATH" &&
		export PATH &&
		test_terminal sh -c ". git-sh-setup && git_pager"
	) &&
	grep ^LESS= pager-env.out &&
	grep ^LV= pager-env.out
'

test_expect_success TTY 'some commands do not use a pager' '
	rm -f paginated.out &&
	test_terminal git rev-list HEAD &&
	! test -e paginated.out
'

test_expect_success 'no pager when stdout is a pipe' '
	rm -f paginated.out &&
	git log | cat &&
	! test -e paginated.out
'

test_expect_success 'no pager when stdout is a regular file' '
	rm -f paginated.out &&
	git log >file &&
	! test -e paginated.out
'

test_expect_success TTY 'git --paginate rev-list uses a pager' '
	rm -f paginated.out &&
	test_terminal git --paginate rev-list HEAD &&
	test -e paginated.out
'

test_expect_success 'no pager even with --paginate when stdout is a pipe' '
	rm -f file paginated.out &&
	git --paginate log | cat &&
	! test -e paginated.out
'

test_expect_success TTY 'no pager with --no-pager' '
	rm -f paginated.out &&
	test_terminal git --no-pager log &&
	! test -e paginated.out
'

test_expect_success TTY 'configuration can disable pager' '
	rm -f paginated.out &&
	test_unconfig pager.grep &&
	test_terminal git grep initial &&
	test -e paginated.out &&

	rm -f paginated.out &&
	test_config pager.grep false &&
	test_terminal git grep initial &&
	! test -e paginated.out
'

test_expect_success TTY 'git config uses a pager if configured to' '
	rm -f paginated.out &&
	test_config pager.config true &&
	test_terminal git config --list &&
	test -e paginated.out
'

test_expect_success TTY 'configuration can enable pager (from subdir)' '
	rm -f paginated.out &&
	mkdir -p subdir &&
	test_config pager.bundle true &&

	git bundle create test.bundle --all &&
	rm -f paginated.out subdir/paginated.out &&
	(
		cd subdir &&
		test_terminal git bundle unbundle ../test.bundle
	) &&
	{
		test -e paginated.out ||
		test -e subdir/paginated.out
	}
'

test_expect_success TTY 'git tag -l defaults to paging' '
	rm -f paginated.out &&
	test_terminal git tag -l &&
	test -e paginated.out
'

test_expect_success TTY 'git tag -l respects pager.tag' '
	rm -f paginated.out &&
	test_terminal git -c pager.tag=false tag -l &&
	! test -e paginated.out
'

test_expect_success TTY 'git tag -l respects --no-pager' '
	rm -f paginated.out &&
	test_terminal git -c pager.tag --no-pager tag -l &&
	! test -e paginated.out
'

test_expect_success TTY 'git tag with no args defaults to paging' '
	# no args implies -l so this should page like -l
	rm -f paginated.out &&
	test_terminal git tag &&
	test -e paginated.out
'

test_expect_success TTY 'git tag with no args respects pager.tag' '
	# no args implies -l so this should page like -l
	rm -f paginated.out &&
	test_terminal git -c pager.tag=false tag &&
	! test -e paginated.out
'

test_expect_success TTY 'git tag --contains defaults to paging' '
	# --contains implies -l so this should page like -l
	rm -f paginated.out &&
	test_terminal git tag --contains &&
	test -e paginated.out
'

test_expect_success TTY 'git tag --contains respects pager.tag' '
	# --contains implies -l so this should page like -l
	rm -f paginated.out &&
	test_terminal git -c pager.tag=false tag --contains &&
	! test -e paginated.out
'

test_expect_success TTY 'git tag -a defaults to not paging' '
	test_when_finished "git tag -d newtag" &&
	rm -f paginated.out &&
	test_terminal git tag -am message newtag &&
	! test -e paginated.out
'

test_expect_success TTY 'git tag -a ignores pager.tag' '
	test_when_finished "git tag -d newtag" &&
	rm -f paginated.out &&
	test_terminal git -c pager.tag tag -am message newtag &&
	! test -e paginated.out
'

test_expect_success TTY 'git tag -a respects --paginate' '
	test_when_finished "git tag -d newtag" &&
	rm -f paginated.out &&
	test_terminal git --paginate tag -am message newtag &&
	test -e paginated.out
'

test_expect_success TTY 'git tag as alias ignores pager.tag with -a' '
	test_when_finished "git tag -d newtag" &&
	rm -f paginated.out &&
	test_terminal git -c pager.tag -c alias.t=tag t -am message newtag &&
	! test -e paginated.out
'

test_expect_success TTY 'git tag as alias respects pager.tag with -l' '
	rm -f paginated.out &&
	test_terminal git -c pager.tag=false -c alias.t=tag t -l &&
	! test -e paginated.out
'

test_expect_success TTY 'git branch defaults to paging' '
	rm -f paginated.out &&
	test_terminal git branch &&
	test -e paginated.out
'

test_expect_success TTY 'git branch respects pager.branch' '
	rm -f paginated.out &&
	test_terminal git -c pager.branch=false branch &&
	! test -e paginated.out
'

test_expect_success TTY 'git branch respects --no-pager' '
	rm -f paginated.out &&
	test_terminal git --no-pager branch &&
	! test -e paginated.out
'

test_expect_success TTY 'git branch --edit-description ignores pager.branch' '
	rm -f paginated.out editor.used &&
	write_script editor <<-\EOF &&
		echo "New description" >"$1"
		touch editor.used
	EOF
	EDITOR=./editor test_terminal git -c pager.branch branch --edit-description &&
	! test -e paginated.out &&
	test -e editor.used
'

test_expect_success TTY 'git branch --set-upstream-to ignores pager.branch' '
	rm -f paginated.out &&
	git branch other &&
	test_when_finished "git branch -D other" &&
	test_terminal git -c pager.branch branch --set-upstream-to=other &&
	test_when_finished "git branch --unset-upstream" &&
	! test -e paginated.out
'

# A colored commit log will begin with an appropriate ANSI escape
# for the first color; the text "commit" comes later.
colorful() {
	read firstline <$1
	! expr "$firstline" : "[a-zA-Z]" >/dev/null
}

test_expect_success 'tests can detect color' '
	rm -f colorful.log colorless.log &&
	git log --no-color >colorless.log &&
	git log --color >colorful.log &&
	! colorful colorless.log &&
	colorful colorful.log
'

test_expect_success 'no color when stdout is a regular file' '
	rm -f colorless.log &&
	test_config color.ui auto &&
	git log >colorless.log &&
	! colorful colorless.log
'

test_expect_success TTY 'color when writing to a pager' '
	rm -f paginated.out &&
	test_config color.ui auto &&
	test_terminal git log &&
	colorful paginated.out
'

test_expect_success TTY 'colors are suppressed by color.pager' '
	rm -f paginated.out &&
	test_config color.ui auto &&
	test_config color.pager false &&
	test_terminal git log &&
	! colorful paginated.out
'

test_expect_success 'color when writing to a file intended for a pager' '
	rm -f colorful.log &&
	test_config color.ui auto &&
	(
		TERM=vt100 &&
		GIT_PAGER_IN_USE=true &&
		export TERM GIT_PAGER_IN_USE &&
		git log >colorful.log
	) &&
	colorful colorful.log
'

test_expect_success TTY 'colors are sent to pager for external commands' '
	test_config alias.externallog "!git log" &&
	test_config color.ui auto &&
	test_terminal git -p externallog &&
	colorful paginated.out
'

# Use this helper to make it easy for the caller of your
# terminal-using function to specify whether it should fail.
# If you write
#
#	your_test() {
#		parse_args "$@"
#
#		$test_expectation "$cmd - behaves well" "
#			...
#			$full_command &&
#			...
#		"
#	}
#
# then your test can be used like this:
#
#	your_test expect_(success|failure) [test_must_fail] 'git foo'
#
parse_args() {
	test_expectation="test_$1"
	shift
	if test "$1" = test_must_fail
	then
		full_command="test_must_fail test_terminal "
		shift
	else
		full_command="test_terminal "
	fi
	cmd=$1
	full_command="$full_command $1"
}

test_default_pager() {
	parse_args "$@"

	$test_expectation SIMPLEPAGER,TTY "$cmd - default pager is used by default" "
		sane_unset PAGER GIT_PAGER &&
		test_unconfig core.pager &&
		rm -f default_pager_used &&
		cat >\$less <<-\EOF &&
		#!/bin/sh
		wc >default_pager_used
		EOF
		chmod +x \$less &&
		(
			PATH=.:\$PATH &&
			export PATH &&
			$full_command
		) &&
		test -e default_pager_used
	"
}

test_PAGER_overrides() {
	parse_args "$@"

	$test_expectation TTY "$cmd - PAGER overrides default pager" "
		sane_unset GIT_PAGER &&
		test_unconfig core.pager &&
		rm -f PAGER_used &&
		PAGER='wc >PAGER_used' &&
		export PAGER &&
		$full_command &&
		test -e PAGER_used
	"
}

test_core_pager_overrides() {
	if_local_config=
	used_if_wanted='overrides PAGER'
	test_core_pager "$@"
}

test_local_config_ignored() {
	if_local_config='! '
	used_if_wanted='is not used'
	test_core_pager "$@"
}

test_core_pager() {
	parse_args "$@"

	$test_expectation TTY "$cmd - repository-local core.pager setting $used_if_wanted" "
		sane_unset GIT_PAGER &&
		rm -f core.pager_used &&
		PAGER=wc &&
		export PAGER &&
		test_config core.pager 'wc >core.pager_used' &&
		$full_command &&
		${if_local_config}test -e core.pager_used
	"
}

test_core_pager_subdir() {
	if_local_config=
	used_if_wanted='overrides PAGER'
	test_pager_subdir_helper "$@"
}

test_no_local_config_subdir() {
	if_local_config='! '
	used_if_wanted='is not used'
	test_pager_subdir_helper "$@"
}

test_pager_subdir_helper() {
	parse_args "$@"

	$test_expectation TTY "$cmd - core.pager $used_if_wanted from subdirectory" "
		sane_unset GIT_PAGER &&
		rm -f core.pager_used &&
		rm -fr sub &&
		PAGER=wc &&
		stampname=\$(pwd)/core.pager_used &&
		export PAGER stampname &&
		test_config core.pager 'wc >\"\$stampname\"' &&
		mkdir sub &&
		(
			cd sub &&
			$full_command
		) &&
		${if_local_config}test -e core.pager_used
	"
}

test_GIT_PAGER_overrides() {
	parse_args "$@"

	$test_expectation TTY "$cmd - GIT_PAGER overrides core.pager" "
		rm -f GIT_PAGER_used &&
		test_config core.pager wc &&
		GIT_PAGER='wc >GIT_PAGER_used' &&
		export GIT_PAGER &&
		$full_command &&
		test -e GIT_PAGER_used
	"
}

test_doesnt_paginate() {
	parse_args "$@"

	$test_expectation TTY "no pager for '$cmd'" "
		rm -f GIT_PAGER_used &&
		GIT_PAGER='wc >GIT_PAGER_used' &&
		export GIT_PAGER &&
		$full_command &&
		! test -e GIT_PAGER_used
	"
}

test_pager_choices() {
	test_default_pager        expect_success "$@"
	test_PAGER_overrides      expect_success "$@"
	test_core_pager_overrides expect_success "$@"
	test_core_pager_subdir    expect_success "$@"
	test_GIT_PAGER_overrides  expect_success "$@"
}

test_expect_success 'setup: some aliases' '
	git config alias.aliasedlog log &&
	git config alias.true "!true"
'

test_pager_choices                       'git log'
test_pager_choices                       'git -p log'
test_pager_choices                       'git aliasedlog'

test_default_pager        expect_success 'git -p aliasedlog'
test_PAGER_overrides      expect_success 'git -p aliasedlog'
test_core_pager_overrides expect_success 'git -p aliasedlog'
test_core_pager_subdir    expect_success 'git -p aliasedlog'
test_GIT_PAGER_overrides  expect_success 'git -p aliasedlog'

test_default_pager        expect_success 'git -p true'
test_PAGER_overrides      expect_success 'git -p true'
test_core_pager_overrides expect_success 'git -p true'
test_core_pager_subdir    expect_success 'git -p true'
test_GIT_PAGER_overrides  expect_success 'git -p true'

test_default_pager        expect_success test_must_fail 'git -p request-pull'
test_PAGER_overrides      expect_success test_must_fail 'git -p request-pull'
test_core_pager_overrides expect_success test_must_fail 'git -p request-pull'
test_core_pager_subdir    expect_success test_must_fail 'git -p request-pull'
test_GIT_PAGER_overrides  expect_success test_must_fail 'git -p request-pull'

test_default_pager        expect_success test_must_fail 'git -p'
test_PAGER_overrides      expect_success test_must_fail 'git -p'
test_local_config_ignored expect_failure test_must_fail 'git -p'
test_GIT_PAGER_overrides  expect_success test_must_fail 'git -p'

test_expect_success TTY 'core.pager in repo config works and retains cwd' '
	sane_unset GIT_PAGER &&
	test_config core.pager "cat >cwd-retained" &&
	(
		cd sub &&
		rm -f cwd-retained &&
		test_terminal git -p rev-parse HEAD &&
		test_path_is_file cwd-retained
	)
'

test_expect_success TTY 'core.pager is found via alias in subdirectory' '
	sane_unset GIT_PAGER &&
	test_config core.pager "cat >via-alias" &&
	(
		cd sub &&
		rm -f via-alias &&
		test_terminal git -c alias.r="-p rev-parse" r HEAD &&
		test_path_is_file via-alias
	)
'

test_doesnt_paginate      expect_failure test_must_fail 'git -p nonsense'

test_pager_choices                       'git shortlog'
test_expect_success 'setup: configure shortlog not to paginate' '
	git config pager.shortlog false
'
test_doesnt_paginate      expect_success 'git shortlog'
test_no_local_config_subdir expect_success 'git shortlog'
test_default_pager        expect_success 'git -p shortlog'
test_core_pager_subdir    expect_success 'git -p shortlog'

test_core_pager_subdir    expect_success test_must_fail \
					 'git -p apply </dev/null'

test_expect_success TTY 'command-specific pager' '
	sane_unset PAGER GIT_PAGER &&
	echo "foo:initial" >expect &&
	>actual &&
	test_unconfig core.pager &&
	test_config pager.log "sed s/^/foo:/ >actual" &&
	test_terminal git log --format=%s -1 &&
	test_cmp expect actual
'

test_expect_success TTY 'command-specific pager overrides core.pager' '
	sane_unset PAGER GIT_PAGER &&
	echo "foo:initial" >expect &&
	>actual &&
	test_config core.pager "exit 1" &&
	test_config pager.log "sed s/^/foo:/ >actual" &&
	test_terminal git log --format=%s -1 &&
	test_cmp expect actual
'

test_expect_success TTY 'command-specific pager overridden by environment' '
	GIT_PAGER="sed s/^/foo:/ >actual" && export GIT_PAGER &&
	>actual &&
	echo "foo:initial" >expect &&
	test_config pager.log "exit 1" &&
	test_terminal git log --format=%s -1 &&
	test_cmp expect actual
'

test_expect_success 'setup external command' '
	cat >git-external <<-\EOF &&
	#!/bin/sh
	git "$@"
	EOF
	chmod +x git-external
'

test_expect_success TTY 'command-specific pager works for external commands' '
	sane_unset PAGER GIT_PAGER &&
	echo "foo:initial" >expect &&
	>actual &&
	test_config pager.external "sed s/^/foo:/ >actual" &&
	test_terminal git --exec-path="$(pwd)" external log --format=%s -1 &&
	test_cmp expect actual
'

test_expect_success TTY 'sub-commands of externals use their own pager' '
	sane_unset PAGER GIT_PAGER &&
	echo "foo:initial" >expect &&
	>actual &&
	test_config pager.log "sed s/^/foo:/ >actual" &&
	test_terminal git --exec-path=. external log --format=%s -1 &&
	test_cmp expect actual
'

test_expect_success TTY 'external command pagers override sub-commands' '
	sane_unset PAGER GIT_PAGER &&
	>expect &&
	>actual &&
	test_config pager.external false &&
	test_config pager.log "sed s/^/log:/ >actual" &&
	test_terminal git --exec-path=. external log --format=%s -1 &&
	test_cmp expect actual
'

test_expect_success 'command with underscores does not complain' '
	write_script git-under_score <<-\EOF &&
	echo ok
	EOF
	git --exec-path=. under_score >actual 2>&1 &&
	echo ok >expect &&
	test_cmp expect actual
'

test_expect_success TTY 'git tag with auto-columns ' '
	test_commit one &&
	test_commit two &&
	test_commit three &&
	test_commit four &&
	test_commit five &&
	cat >expect <<-\EOF &&
	initial  one      two      three    four     five
	EOF
	test_terminal env PAGER="cat >actual" COLUMNS=80 \
		git -c column.ui=auto tag --sort=authordate &&
	test_cmp expect actual
'

test_done
Commit	Line	Data
60b6e220 JN	1	#!/bin/sh
	2
	3	test_description='Test automatic use of a pager.'
	4
	5	. ./test-lib.sh
678e484b	6	. "$TEST_DIRECTORY"/lib-pager.sh
cc4e48fc	7	. "$TEST_DIRECTORY"/lib-terminal.sh
60b6e220	8
60b6e220	9	test_expect_success 'setup' '
00648ba0	10	sane_unset GIT_PAGER GIT_PAGER_IN_USE &&
8d68a6d5	11	test_unconfig core.pager &&
fdf1bc48 JN	12
	13	PAGER="cat >paginated.out" &&
	14	export PAGER &&
	15
60b6e220 JN	16	test_commit initial
	17	'
	18
60b6e220	19	test_expect_success TTY 'some commands use a pager' '
0d164519	20	rm -f paginated.out &&
2d3ca216	21	test_terminal git log &&
60b6e220 JN	22	test -e paginated.out
	23	'
	24
2cb60093 NTND	25	test_expect_failure TTY 'pager runs from subdir' '
	26	echo subdir/paginated.out >expected &&
	27	mkdir -p subdir &&
	28	rm -f paginated.out subdir/paginated.out &&
	29	(
	30	cd subdir &&
	31	test_terminal git log
	32	) &&
	33	{
	34	ls paginated.out subdir/paginated.out \|\|
	35	:
	36	} >actual &&
	37	test_cmp expected actual
	38	'
	39
e54c1f2d JN	40	test_expect_success TTY 'LESS and LV envvars are set for pagination' '
	41	(
	42	sane_unset LESS LV &&
52c02f65	43	PAGER="env >pager-env.out; wc" &&
e54c1f2d JN	44	export PAGER &&
	45
	46	test_terminal git log
	47	) &&
	48	grep ^LESS= pager-env.out &&
	49	grep ^LV= pager-env.out
	50	'
	51
995bc22d EW	52	test_expect_success !MINGW,TTY 'LESS and LV envvars set by git-sh-setup' '
	53	(
	54	sane_unset LESS LV &&
	55	PAGER="env >pager-env.out; wc" &&
	56	export PAGER &&
	57	PATH="$(git --exec-path):$PATH" &&
	58	export PATH &&
	59	test_terminal sh -c ". git-sh-setup && git_pager"
	60	) &&
	61	grep ^LESS= pager-env.out &&
	62	grep ^LV= pager-env.out
	63	'
	64
60b6e220	65	test_expect_success TTY 'some commands do not use a pager' '
0d164519	66	rm -f paginated.out &&
2d3ca216	67	test_terminal git rev-list HEAD &&
60b6e220 JN	68	! test -e paginated.out
	69	'
	70
60b6e220	71	test_expect_success 'no pager when stdout is a pipe' '
0d164519	72	rm -f paginated.out &&
60b6e220 JN	73	git log \| cat &&
	74	! test -e paginated.out
	75	'
	76
60b6e220	77	test_expect_success 'no pager when stdout is a regular file' '
0d164519	78	rm -f paginated.out &&
fdf1bc48	79	git log >file &&
60b6e220 JN	80	! test -e paginated.out
	81	'
	82
60b6e220	83	test_expect_success TTY 'git --paginate rev-list uses a pager' '
0d164519	84	rm -f paginated.out &&
2d3ca216	85	test_terminal git --paginate rev-list HEAD &&
60b6e220 JN	86	test -e paginated.out
	87	'
	88
60b6e220	89	test_expect_success 'no pager even with --paginate when stdout is a pipe' '
0d164519	90	rm -f file paginated.out &&
60b6e220 JN	91	git --paginate log \| cat &&
	92	! test -e paginated.out
	93	'
	94
60b6e220	95	test_expect_success TTY 'no pager with --no-pager' '
0d164519	96	rm -f paginated.out &&
2d3ca216	97	test_terminal git --no-pager log &&
60b6e220 JN	98	! test -e paginated.out
	99	'
	100
ff38d1a9 NTND	101	test_expect_success TTY 'configuration can disable pager' '
ff38d1a9 NTND	102	rm -f paginated.out &&
8d68a6d5	103	test_unconfig pager.grep &&
ff38d1a9 NTND	104	test_terminal git grep initial &&
	105	test -e paginated.out &&
	106
	107	rm -f paginated.out &&
8d68a6d5	108	test_config pager.grep false &&
ff38d1a9 NTND	109	test_terminal git grep initial &&
	110	! test -e paginated.out
	111	'
	112
41bf3bc2	113	test_expect_success TTY 'git config uses a pager if configured to' '
3ba7e6e2	114	rm -f paginated.out &&
8d68a6d5	115	test_config pager.config true &&
3ba7e6e2 NTND	116	test_terminal git config --list &&
	117	test -e paginated.out
	118	'
	119
41bf3bc2	120	test_expect_success TTY 'configuration can enable pager (from subdir)' '
2cb60093 NTND	121	rm -f paginated.out &&
2cb60093 NTND	122	mkdir -p subdir &&
8d68a6d5	123	test_config pager.bundle true &&
2cb60093 NTND	124
	125	git bundle create test.bundle --all &&
	126	rm -f paginated.out subdir/paginated.out &&
	127	(
	128	cd subdir &&
	129	test_terminal git bundle unbundle ../test.bundle
	130	) &&
	131	{
	132	test -e paginated.out \|\|
	133	test -e subdir/paginated.out
	134	}
	135	'
	136
ff1e7248	137	test_expect_success TTY 'git tag -l defaults to paging' '
b3ee740c MÅ	138	rm -f paginated.out &&
b3ee740c MÅ	139	test_terminal git tag -l &&
ff1e7248	140	test -e paginated.out
b3ee740c MÅ	141	'
	142
	143	test_expect_success TTY 'git tag -l respects pager.tag' '
	144	rm -f paginated.out &&
ff1e7248 MÅ	145	test_terminal git -c pager.tag=false tag -l &&
ff1e7248 MÅ	146	! test -e paginated.out
b3ee740c MÅ	147	'
	148
	149	test_expect_success TTY 'git tag -l respects --no-pager' '
	150	rm -f paginated.out &&
	151	test_terminal git -c pager.tag --no-pager tag -l &&
	152	! test -e paginated.out
	153	'
	154
ff1e7248	155	test_expect_success TTY 'git tag with no args defaults to paging' '
b3ee740c MÅ	156	# no args implies -l so this should page like -l
	157	rm -f paginated.out &&
	158	test_terminal git tag &&
ff1e7248	159	test -e paginated.out
b3ee740c MÅ	160	'
	161
	162	test_expect_success TTY 'git tag with no args respects pager.tag' '
	163	# no args implies -l so this should page like -l
	164	rm -f paginated.out &&
ff1e7248 MÅ	165	test_terminal git -c pager.tag=false tag &&
ff1e7248 MÅ	166	! test -e paginated.out
b3ee740c MÅ	167	'
b3ee740c MÅ	168
ff1e7248	169	test_expect_success TTY 'git tag --contains defaults to paging' '
b3ee740c MÅ	170	# --contains implies -l so this should page like -l
	171	rm -f paginated.out &&
	172	test_terminal git tag --contains &&
ff1e7248	173	test -e paginated.out
b3ee740c MÅ	174	'
	175
	176	test_expect_success TTY 'git tag --contains respects pager.tag' '
	177	# --contains implies -l so this should page like -l
	178	rm -f paginated.out &&
ff1e7248 MÅ	179	test_terminal git -c pager.tag=false tag --contains &&
ff1e7248 MÅ	180	! test -e paginated.out
b3ee740c MÅ	181	'
	182
	183	test_expect_success TTY 'git tag -a defaults to not paging' '
	184	test_when_finished "git tag -d newtag" &&
	185	rm -f paginated.out &&
	186	test_terminal git tag -am message newtag &&
	187	! test -e paginated.out
	188	'
	189
de121ffe	190	test_expect_success TTY 'git tag -a ignores pager.tag' '
b3ee740c MÅ	191	test_when_finished "git tag -d newtag" &&
	192	rm -f paginated.out &&
	193	test_terminal git -c pager.tag tag -am message newtag &&
	194	! test -e paginated.out
	195	'
	196
	197	test_expect_success TTY 'git tag -a respects --paginate' '
	198	test_when_finished "git tag -d newtag" &&
	199	rm -f paginated.out &&
	200	test_terminal git --paginate tag -am message newtag &&
	201	test -e paginated.out
	202	'
	203
595d59e2	204	test_expect_success TTY 'git tag as alias ignores pager.tag with -a' '
de121ffe MÅ	205	test_when_finished "git tag -d newtag" &&
	206	rm -f paginated.out &&
	207	test_terminal git -c pager.tag -c alias.t=tag t -am message newtag &&
	208	! test -e paginated.out
	209	'
	210
	211	test_expect_success TTY 'git tag as alias respects pager.tag with -l' '
	212	rm -f paginated.out &&
ff1e7248 MÅ	213	test_terminal git -c pager.tag=false -c alias.t=tag t -l &&
ff1e7248 MÅ	214	! test -e paginated.out
de121ffe MÅ	215	'
de121ffe MÅ	216
0ae19de7	217	test_expect_success TTY 'git branch defaults to paging' '
ed104fa9 MÅ	218	rm -f paginated.out &&
ed104fa9 MÅ	219	test_terminal git branch &&
0ae19de7	220	test -e paginated.out
ed104fa9 MÅ	221	'
	222
	223	test_expect_success TTY 'git branch respects pager.branch' '
	224	rm -f paginated.out &&
0ae19de7 MÅ	225	test_terminal git -c pager.branch=false branch &&
0ae19de7 MÅ	226	! test -e paginated.out
ed104fa9 MÅ	227	'
	228
	229	test_expect_success TTY 'git branch respects --no-pager' '
	230	rm -f paginated.out &&
0ae19de7	231	test_terminal git --no-pager branch &&
ed104fa9 MÅ	232	! test -e paginated.out
	233	'
	234
d74b541e	235	test_expect_success TTY 'git branch --edit-description ignores pager.branch' '
ed104fa9 MÅ	236	rm -f paginated.out editor.used &&
	237	write_script editor <<-\EOF &&
	238	echo "New description" >"$1"
	239	touch editor.used
	240	EOF
	241	EDITOR=./editor test_terminal git -c pager.branch branch --edit-description &&
	242	! test -e paginated.out &&
	243	test -e editor.used
	244	'
	245
d74b541e	246	test_expect_success TTY 'git branch --set-upstream-to ignores pager.branch' '
ed104fa9 MÅ	247	rm -f paginated.out &&
	248	git branch other &&
	249	test_when_finished "git branch -D other" &&
	250	test_terminal git -c pager.branch branch --set-upstream-to=other &&
	251	test_when_finished "git branch --unset-upstream" &&
d74b541e	252	! test -e paginated.out
ed104fa9 MÅ	253	'
ed104fa9 MÅ	254
60b6e220 JN	255	# A colored commit log will begin with an appropriate ANSI escape
	256	# for the first color; the text "commit" comes later.
	257	colorful() {
fdf1bc48	258	read firstline <$1
e0ae1e6f	259	! expr "$firstline" : "[a-zA-Z]" >/dev/null
60b6e220 JN	260	}
60b6e220 JN	261
60b6e220	262	test_expect_success 'tests can detect color' '
0d164519	263	rm -f colorful.log colorless.log &&
fdf1bc48 JN	264	git log --no-color >colorless.log &&
fdf1bc48 JN	265	git log --color >colorful.log &&
60b6e220 JN	266	! colorful colorless.log &&
	267	colorful colorful.log
	268	'
	269
60b6e220	270	test_expect_success 'no color when stdout is a regular file' '
fdf1bc48	271	rm -f colorless.log &&
0d164519	272	test_config color.ui auto &&
fdf1bc48	273	git log >colorless.log &&
60b6e220 JN	274	! colorful colorless.log
	275	'
	276
60b6e220	277	test_expect_success TTY 'color when writing to a pager' '
fdf1bc48	278	rm -f paginated.out &&
0d164519	279	test_config color.ui auto &&
e433749d	280	test_terminal git log &&
60b6e220 JN	281	colorful paginated.out
	282	'
	283
daa0c3d9 JK	284	test_expect_success TTY 'colors are suppressed by color.pager' '
	285	rm -f paginated.out &&
	286	test_config color.ui auto &&
	287	test_config color.pager false &&
e433749d	288	test_terminal git log &&
daa0c3d9 JK	289	! colorful paginated.out
	290	'
	291
60b6e220	292	test_expect_success 'color when writing to a file intended for a pager' '
fdf1bc48	293	rm -f colorful.log &&
0d164519	294	test_config color.ui auto &&
fdf1bc48 JN	295	(
	296	TERM=vt100 &&
	297	GIT_PAGER_IN_USE=true &&
	298	export TERM GIT_PAGER_IN_USE &&
	299	git log >colorful.log
	300	) &&
60b6e220 JN	301	colorful colorful.log
	302	'
	303
2e6c012e JK	304	test_expect_success TTY 'colors are sent to pager for external commands' '
	305	test_config alias.externallog "!git log" &&
	306	test_config color.ui auto &&
e433749d	307	test_terminal git -p externallog &&
2e6c012e JK	308	colorful paginated.out
	309	'
	310
3c7406d4 JN	311	# Use this helper to make it easy for the caller of your
	312	# terminal-using function to specify whether it should fail.
	313	# If you write
	314	#
	315	# your_test() {
	316	# parse_args "$@"
	317	#
	318	# $test_expectation "$cmd - behaves well" "
	319	# ...
	320	# $full_command &&
	321	# ...
	322	# "
	323	# }
	324	#
	325	# then your test can be used like this:
	326	#
	327	# your_test expect_(success\|failure) [test_must_fail] 'git foo'
	328	#
	329	parse_args() {
	330	test_expectation="test_$1"
	331	shift
	332	if test "$1" = test_must_fail
	333	then
	334	full_command="test_must_fail test_terminal "
	335	shift
	336	else
	337	full_command="test_terminal "
	338	fi
	339	cmd=$1
	340	full_command="$full_command $1"
	341	}
fdf1bc48	342
8f81449e JN	343	test_default_pager() {
	344	parse_args "$@"
	345
996621eb	346	$test_expectation SIMPLEPAGER,TTY "$cmd - default pager is used by default" "
00648ba0	347	sane_unset PAGER GIT_PAGER &&
8d68a6d5	348	test_unconfig core.pager &&
0d164519	349	rm -f default_pager_used &&
8f81449e JN	350	cat >\$less <<-\EOF &&
	351	#!/bin/sh
	352	wc >default_pager_used
	353	EOF
	354	chmod +x \$less &&
	355	(
	356	PATH=.:\$PATH &&
	357	export PATH &&
	358	$full_command
	359	) &&
	360	test -e default_pager_used
	361	"
	362	}
60b6e220	363
8f81449e JN	364	test_PAGER_overrides() {
8f81449e JN	365	parse_args "$@"
fdf1bc48	366
8f81449e	367	$test_expectation TTY "$cmd - PAGER overrides default pager" "
00648ba0	368	sane_unset GIT_PAGER &&
8d68a6d5	369	test_unconfig core.pager &&
0d164519	370	rm -f PAGER_used &&
8f81449e JN	371	PAGER='wc >PAGER_used' &&
	372	export PAGER &&
	373	$full_command &&
	374	test -e PAGER_used
	375	"
	376	}
fdf1bc48	377
8f81449e	378	test_core_pager_overrides() {
73e25e7c NTND	379	if_local_config=
	380	used_if_wanted='overrides PAGER'
	381	test_core_pager "$@"
	382	}
60b6e220	383
73e25e7c NTND	384	test_local_config_ignored() {
	385	if_local_config='! '
	386	used_if_wanted='is not used'
	387	test_core_pager "$@"
	388	}
fdf1bc48	389
73e25e7c	390	test_core_pager() {
8f81449e JN	391	parse_args "$@"
8f81449e JN	392
73e25e7c	393	$test_expectation TTY "$cmd - repository-local core.pager setting $used_if_wanted" "
00648ba0	394	sane_unset GIT_PAGER &&
0d164519	395	rm -f core.pager_used &&
8f81449e JN	396	PAGER=wc &&
8f81449e JN	397	export PAGER &&
8d68a6d5	398	test_config core.pager 'wc >core.pager_used' &&
8f81449e	399	$full_command &&
73e25e7c	400	${if_local_config}test -e core.pager_used
8f81449e JN	401	"
	402	}
	403
bce2c9ae	404	test_core_pager_subdir() {
73e25e7c NTND	405	if_local_config=
	406	used_if_wanted='overrides PAGER'
	407	test_pager_subdir_helper "$@"
	408	}
	409
	410	test_no_local_config_subdir() {
	411	if_local_config='! '
	412	used_if_wanted='is not used'
	413	test_pager_subdir_helper "$@"
	414	}
	415
	416	test_pager_subdir_helper() {
bce2c9ae JN	417	parse_args "$@"
bce2c9ae JN	418
73e25e7c	419	$test_expectation TTY "$cmd - core.pager $used_if_wanted from subdirectory" "
00648ba0	420	sane_unset GIT_PAGER &&
bce2c9ae	421	rm -f core.pager_used &&
0d164519	422	rm -fr sub &&
bce2c9ae JN	423	PAGER=wc &&
	424	stampname=\$(pwd)/core.pager_used &&
	425	export PAGER stampname &&
8d68a6d5	426	test_config core.pager 'wc >\"\$stampname\"' &&
bce2c9ae JN	427	mkdir sub &&
	428	(
	429	cd sub &&
	430	$full_command
	431	) &&
73e25e7c	432	${if_local_config}test -e core.pager_used
bce2c9ae JN	433	"
	434	}
	435
8f81449e JN	436	test_GIT_PAGER_overrides() {
	437	parse_args "$@"
	438
	439	$test_expectation TTY "$cmd - GIT_PAGER overrides core.pager" "
0d164519	440	rm -f GIT_PAGER_used &&
8d68a6d5	441	test_config core.pager wc &&
8f81449e JN	442	GIT_PAGER='wc >GIT_PAGER_used' &&
	443	export GIT_PAGER &&
	444	$full_command &&
	445	test -e GIT_PAGER_used
	446	"
	447	}
fdf1bc48	448
73e25e7c NTND	449	test_doesnt_paginate() {
	450	parse_args "$@"
	451
	452	$test_expectation TTY "no pager for '$cmd'" "
0d164519	453	rm -f GIT_PAGER_used &&
73e25e7c NTND	454	GIT_PAGER='wc >GIT_PAGER_used' &&
	455	export GIT_PAGER &&
	456	$full_command &&
	457	! test -e GIT_PAGER_used
	458	"
	459	}
	460
030149a4 JN	461	test_pager_choices() {
	462	test_default_pager expect_success "$@"
	463	test_PAGER_overrides expect_success "$@"
	464	test_core_pager_overrides expect_success "$@"
	465	test_core_pager_subdir expect_success "$@"
	466	test_GIT_PAGER_overrides expect_success "$@"
	467	}
	468
	469	test_expect_success 'setup: some aliases' '
	470	git config alias.aliasedlog log &&
	471	git config alias.true "!true"
60b6e220 JN	472	'
60b6e220 JN	473
030149a4 JN	474	test_pager_choices 'git log'
	475	test_pager_choices 'git -p log'
	476	test_pager_choices 'git aliasedlog'
	477
	478	test_default_pager expect_success 'git -p aliasedlog'
	479	test_PAGER_overrides expect_success 'git -p aliasedlog'
	480	test_core_pager_overrides expect_success 'git -p aliasedlog'
1a27409a	481	test_core_pager_subdir expect_success 'git -p aliasedlog'
030149a4 JN	482	test_GIT_PAGER_overrides expect_success 'git -p aliasedlog'
	483
	484	test_default_pager expect_success 'git -p true'
	485	test_PAGER_overrides expect_success 'git -p true'
	486	test_core_pager_overrides expect_success 'git -p true'
1a27409a	487	test_core_pager_subdir expect_success 'git -p true'
030149a4 JN	488	test_GIT_PAGER_overrides expect_success 'git -p true'
	489
	490	test_default_pager expect_success test_must_fail 'git -p request-pull'
	491	test_PAGER_overrides expect_success test_must_fail 'git -p request-pull'
	492	test_core_pager_overrides expect_success test_must_fail 'git -p request-pull'
1a27409a	493	test_core_pager_subdir expect_success test_must_fail 'git -p request-pull'
030149a4	494	test_GIT_PAGER_overrides expect_success test_must_fail 'git -p request-pull'
8f81449e JN	495
	496	test_default_pager expect_success test_must_fail 'git -p'
	497	test_PAGER_overrides expect_success test_must_fail 'git -p'
73e25e7c	498	test_local_config_ignored expect_failure test_must_fail 'git -p'
8f81449e JN	499	test_GIT_PAGER_overrides expect_success test_must_fail 'git -p'
8f81449e JN	500
1a27409a	501	test_expect_success TTY 'core.pager in repo config works and retains cwd' '
551d535d JS	502	sane_unset GIT_PAGER &&
	503	test_config core.pager "cat >cwd-retained" &&
	504	(
	505	cd sub &&
	506	rm -f cwd-retained &&
	507	test_terminal git -p rev-parse HEAD &&
	508	test_path_is_file cwd-retained
	509	)
	510	'
	511
a9bcf658	512	test_expect_success TTY 'core.pager is found via alias in subdirectory' '
3f9c5dfb JS	513	sane_unset GIT_PAGER &&
	514	test_config core.pager "cat >via-alias" &&
	515	(
	516	cd sub &&
	517	rm -f via-alias &&
	518	test_terminal git -c alias.r="-p rev-parse" r HEAD &&
	519	test_path_is_file via-alias
	520	)
	521	'
	522
030149a4	523	test_doesnt_paginate expect_failure test_must_fail 'git -p nonsense'
60b6e220	524
773b69bf NTND	525	test_pager_choices 'git shortlog'
	526	test_expect_success 'setup: configure shortlog not to paginate' '
	527	git config pager.shortlog false
	528	'
	529	test_doesnt_paginate expect_success 'git shortlog'
	530	test_no_local_config_subdir expect_success 'git shortlog'
	531	test_default_pager expect_success 'git -p shortlog'
	532	test_core_pager_subdir expect_success 'git -p shortlog'
	533
d1ea8962 NTND	534	test_core_pager_subdir expect_success test_must_fail \
	535	'git -p apply </dev/null'
	536
9bad7233	537	test_expect_success TTY 'command-specific pager' '
212ad944	538	sane_unset PAGER GIT_PAGER &&
9bad7233 JK	539	echo "foo:initial" >expect &&
9bad7233 JK	540	>actual &&
8d68a6d5 JK	541	test_unconfig core.pager &&
8d68a6d5 JK	542	test_config pager.log "sed s/^/foo:/ >actual" &&
9bad7233 JK	543	test_terminal git log --format=%s -1 &&
	544	test_cmp expect actual
	545	'
	546
	547	test_expect_success TTY 'command-specific pager overrides core.pager' '
212ad944	548	sane_unset PAGER GIT_PAGER &&
9bad7233 JK	549	echo "foo:initial" >expect &&
9bad7233 JK	550	>actual &&
99094a7a	551	test_config core.pager "exit 1" &&
8d68a6d5	552	test_config pager.log "sed s/^/foo:/ >actual" &&
9bad7233 JK	553	test_terminal git log --format=%s -1 &&
	554	test_cmp expect actual
	555	'
	556
	557	test_expect_success TTY 'command-specific pager overridden by environment' '
	558	GIT_PAGER="sed s/^/foo:/ >actual" && export GIT_PAGER &&
	559	>actual &&
	560	echo "foo:initial" >expect &&
8d68a6d5	561	test_config pager.log "exit 1" &&
9bad7233 JK	562	test_terminal git log --format=%s -1 &&
	563	test_cmp expect actual
	564	'
	565
92058e4d JK	566	test_expect_success 'setup external command' '
	567	cat >git-external <<-\EOF &&
	568	#!/bin/sh
	569	git "$@"
	570	EOF
	571	chmod +x git-external
	572	'
	573
	574	test_expect_success TTY 'command-specific pager works for external commands' '
	575	sane_unset PAGER GIT_PAGER &&
	576	echo "foo:initial" >expect &&
	577	>actual &&
	578	test_config pager.external "sed s/^/foo:/ >actual" &&
90ae5d27	579	test_terminal git --exec-path="$(pwd)" external log --format=%s -1 &&
92058e4d JK	580	test_cmp expect actual
	581	'
	582
	583	test_expect_success TTY 'sub-commands of externals use their own pager' '
	584	sane_unset PAGER GIT_PAGER &&
	585	echo "foo:initial" >expect &&
	586	>actual &&
	587	test_config pager.log "sed s/^/foo:/ >actual" &&
	588	test_terminal git --exec-path=. external log --format=%s -1 &&
	589	test_cmp expect actual
	590	'
	591
	592	test_expect_success TTY 'external command pagers override sub-commands' '
	593	sane_unset PAGER GIT_PAGER &&
	594	>expect &&
	595	>actual &&
	596	test_config pager.external false &&
	597	test_config pager.log "sed s/^/log:/ >actual" &&
	598	test_terminal git --exec-path=. external log --format=%s -1 &&
	599	test_cmp expect actual
	600	'
	601
9e9de18f JK	602	test_expect_success 'command with underscores does not complain' '
	603	write_script git-under_score <<-\EOF &&
	604	echo ok
	605	EOF
	606	git --exec-path=. under_score >actual 2>&1 &&
	607	echo ok >expect &&
	608	test_cmp expect actual
	609	'
	610
b2d3fd28 KD	611	test_expect_success TTY 'git tag with auto-columns ' '
	612	test_commit one &&
	613	test_commit two &&
	614	test_commit three &&
	615	test_commit four &&
	616	test_commit five &&
	617	cat >expect <<-\EOF &&
	618	initial one two three four five
	619	EOF
	620	test_terminal env PAGER="cat >actual" COLUMNS=80 \
	621	git -c column.ui=auto tag --sort=authordate &&
	622	test_cmp expect actual
	623	'
	624
60b6e220	625	test_done