summaryrefslogtreecommitdiff
path: root/t/t7006-pager.sh
blob: 7d00d49d0da6487bec345176411e1f51e712f137 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
#!/bin/sh
 
test_description='Test automatic use of a pager.'
 
. ./test-lib.sh
. "$TEST_DIRECTORY"/lib-pager.sh
 
cleanup_fail() {
	echo >&2 cleanup failed
	(exit 1)
}
 
test_expect_success 'set up terminal for tests' '
	rm -f stdout_is_tty ||
	cleanup_fail &&
 
	if test -t 1
	then
		>stdout_is_tty
	elif
		test_have_prereq PERL &&
		"$PERL_PATH" "$TEST_DIRECTORY"/t7006/test-terminal.perl \
			sh -c "test -t 1"
	then
		>test_terminal_works
	fi
'
 
if test -e stdout_is_tty
then
	test_terminal() { "$@"; }
	test_set_prereq TTY
elif test -e test_terminal_works
then
	test_terminal() {
		"$PERL_PATH" "$TEST_DIRECTORY"/t7006/test-terminal.perl "$@"
	}
	test_set_prereq TTY
else
	say "# no usable terminal, so skipping some tests"
fi
 
test_expect_success 'setup' '
	sane_unset GIT_PAGER GIT_PAGER_IN_USE &&
	test_might_fail git config --unset core.pager &&
 
	PAGER="cat >paginated.out" &&
	export PAGER &&
 
	test_commit initial
'
 
test_expect_success TTY 'some commands use a pager' '
	rm -f paginated.out ||
	cleanup_fail &&
 
	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 'some commands do not use a pager' '
	rm -f paginated.out ||
	cleanup_fail &&
 
	test_terminal git rev-list HEAD &&
	! test -e paginated.out
'
 
test_expect_success 'no pager when stdout is a pipe' '
	rm -f paginated.out ||
	cleanup_fail &&
 
	git log | cat &&
	! test -e paginated.out
'
 
test_expect_success 'no pager when stdout is a regular file' '
	rm -f paginated.out ||
	cleanup_fail &&
 
	git log >file &&
	! test -e paginated.out
'
 
test_expect_success TTY 'git --paginate rev-list uses a pager' '
	rm -f paginated.out ||
	cleanup_fail &&
 
	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 ||
	cleanup_fail &&
 
	git --paginate log | cat &&
	! test -e paginated.out
'
 
test_expect_success TTY 'no pager with --no-pager' '
	rm -f paginated.out ||
	cleanup_fail &&
 
	test_terminal git --no-pager log &&
	! test -e paginated.out
'
 
test_expect_success TTY 'configuration can disable pager' '
	rm -f paginated.out &&
	test_might_fail git config --unset pager.grep &&
	test_terminal git grep initial &&
	test -e paginated.out &&
 
	rm -f paginated.out &&
	git config pager.grep false &&
	test_when_finished "git config --unset pager.grep" &&
	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 &&
	git config pager.config true &&
	test_when_finished "git config --unset pager.config" &&
	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 &&
	git config pager.bundle true &&
	test_when_finished "git config --unset pager.bundle" &&
 
	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
	}
'
 
# 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 ||
	cleanup_fail &&
 
	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 &&
	git config color.ui auto ||
	cleanup_fail &&
 
	git log >colorless.log &&
	! colorful colorless.log
'
 
test_expect_success TTY 'color when writing to a pager' '
	rm -f paginated.out &&
	git config color.ui auto ||
	cleanup_fail &&
 
	(
		TERM=vt100 &&
		export TERM &&
		test_terminal git log
	) &&
	colorful paginated.out
'
 
test_expect_success 'color when writing to a file intended for a pager' '
	rm -f colorful.log &&
	git config color.ui auto ||
	cleanup_fail &&
 
	(
		TERM=vt100 &&
		GIT_PAGER_IN_USE=true &&
		export TERM GIT_PAGER_IN_USE &&
		git log >colorful.log
	) &&
	colorful colorful.log
'
 
if test_have_prereq SIMPLEPAGER && test_have_prereq TTY
then
	test_set_prereq SIMPLEPAGERTTY
fi
 
# 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 SIMPLEPAGERTTY "$cmd - default pager is used by default" "
		sane_unset PAGER GIT_PAGER &&
		test_might_fail git config --unset core.pager &&
		rm -f default_pager_used ||
		cleanup_fail &&
 
		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_might_fail git config --unset core.pager &&
		rm -f PAGER_used ||
		cleanup_fail &&
 
		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 ||
		cleanup_fail &&
 
		PAGER=wc &&
		export PAGER &&
		git 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 ||
		cleanup_fail &&
 
		PAGER=wc &&
		stampname=\$(pwd)/core.pager_used &&
		export PAGER stampname &&
		git 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 ||
		cleanup_fail &&
 
		git 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 ||
		cleanup_fail &&
 
		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_failure '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_failure '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_failure 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_no_local_config_subdir expect_success test_must_fail 'git -p'
test_GIT_PAGER_overrides  expect_success test_must_fail 'git -p'
 
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_done