[thirdparty/git.git] / t / t1403-show-ref.sh

#!/bin/sh

test_description='show-ref'
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main
export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME

TEST_PASSES_SANITIZE_LEAK=true
. ./test-lib.sh

test_expect_success setup '
	test_commit --annotate A &&
	git checkout -b side &&
	test_commit --annotate B &&
	git checkout main &&
	test_commit C &&
	git branch B A^0
'

test_expect_success 'show-ref' '
	echo $(git rev-parse refs/tags/A) refs/tags/A >expect &&

	git show-ref A >actual &&
	test_cmp expect actual &&

	git show-ref tags/A >actual &&
	test_cmp expect actual &&

	git show-ref refs/tags/A >actual &&
	test_cmp expect actual &&

	test_must_fail git show-ref D >actual &&
	test_must_be_empty actual
'

test_expect_success 'show-ref -q' '
	git show-ref -q A >actual &&
	test_must_be_empty actual &&

	git show-ref -q tags/A >actual &&
	test_must_be_empty actual &&

	git show-ref -q refs/tags/A >actual &&
	test_must_be_empty actual &&

	test_must_fail git show-ref -q D >actual &&
	test_must_be_empty actual
'

test_expect_success 'show-ref --verify' '
	echo $(git rev-parse refs/tags/A) refs/tags/A >expect &&

	git show-ref --verify refs/tags/A >actual &&
	test_cmp expect actual &&

	test_must_fail git show-ref --verify A >actual &&
	test_must_be_empty actual &&

	test_must_fail git show-ref --verify tags/A >actual &&
	test_must_be_empty actual &&

	test_must_fail git show-ref --verify D >actual &&
	test_must_be_empty actual
'

test_expect_success 'show-ref --verify -q' '
	git show-ref --verify -q refs/tags/A >actual &&
	test_must_be_empty actual &&

	test_must_fail git show-ref --verify -q A >actual &&
	test_must_be_empty actual &&

	test_must_fail git show-ref --verify -q tags/A >actual &&
	test_must_be_empty actual &&

	test_must_fail git show-ref --verify -q D >actual &&
	test_must_be_empty actual
'

test_expect_success 'show-ref -d' '
	{
		echo $(git rev-parse refs/tags/A) refs/tags/A &&
		echo $(git rev-parse refs/tags/A^0) "refs/tags/A^{}" &&
		echo $(git rev-parse refs/tags/C) refs/tags/C
	} >expect &&
	git show-ref -d A C >actual &&
	test_cmp expect actual &&

	git show-ref -d tags/A tags/C >actual &&
	test_cmp expect actual &&

	git show-ref -d refs/tags/A refs/tags/C >actual &&
	test_cmp expect actual &&

	git show-ref --verify -d refs/tags/A refs/tags/C >actual &&
	test_cmp expect actual &&

	echo $(git rev-parse refs/heads/main) refs/heads/main >expect &&
	git show-ref -d main >actual &&
	test_cmp expect actual &&

	git show-ref -d heads/main >actual &&
	test_cmp expect actual &&

	git show-ref -d refs/heads/main >actual &&
	test_cmp expect actual &&

	git show-ref -d --verify refs/heads/main >actual &&
	test_cmp expect actual &&

	test_must_fail git show-ref -d --verify main >actual &&
	test_must_be_empty actual &&

	test_must_fail git show-ref -d --verify heads/main >actual &&
	test_must_be_empty actual &&

	test_must_fail git show-ref --verify -d A C >actual &&
	test_must_be_empty actual &&

	test_must_fail git show-ref --verify -d tags/A tags/C >actual &&
	test_must_be_empty actual

'

test_expect_success 'show-ref --heads, --tags, --head, pattern' '
	for branch in B main side
	do
		echo $(git rev-parse refs/heads/$branch) refs/heads/$branch || return 1
	done >expect.heads &&
	git show-ref --heads >actual &&
	test_cmp expect.heads actual &&

	for tag in A B C
	do
		echo $(git rev-parse refs/tags/$tag) refs/tags/$tag || return 1
	done >expect.tags &&
	git show-ref --tags >actual &&
	test_cmp expect.tags actual &&

	cat expect.heads expect.tags >expect &&
	git show-ref --heads --tags >actual &&
	test_cmp expect actual &&

	{
		echo $(git rev-parse HEAD) HEAD &&
		cat expect.heads expect.tags
	} >expect &&
	git show-ref --heads --tags --head >actual &&
	test_cmp expect actual &&

	{
		echo $(git rev-parse HEAD) HEAD &&
		echo $(git rev-parse refs/heads/B) refs/heads/B &&
		echo $(git rev-parse refs/tags/B) refs/tags/B
	} >expect &&
	git show-ref --head B >actual &&
	test_cmp expect actual &&

	{
		echo $(git rev-parse HEAD) HEAD &&
		echo $(git rev-parse refs/heads/B) refs/heads/B &&
		echo $(git rev-parse refs/tags/B) refs/tags/B &&
		echo $(git rev-parse refs/tags/B^0) "refs/tags/B^{}"
	} >expect &&
	git show-ref --head -d B >actual &&
	test_cmp expect actual
'

test_expect_success 'show-ref --verify HEAD' '
	echo $(git rev-parse HEAD) HEAD >expect &&
	git show-ref --verify HEAD >actual &&
	test_cmp expect actual &&

	git show-ref --verify -q HEAD >actual &&
	test_must_be_empty actual
'

test_expect_success 'show-ref --verify with dangling ref' '
	sha1_file() {
		echo "$*" | sed "s#..#.git/objects/&/#"
	} &&

	remove_object() {
		file=$(sha1_file "$*") &&
		test -e "$file" &&
		rm -f "$file"
	} &&

	test_when_finished "rm -rf dangling" &&
	(
		git init dangling &&
		cd dangling &&
		test_commit dangling &&
		sha=$(git rev-parse refs/tags/dangling) &&
		remove_object $sha &&
		test_must_fail git show-ref --verify refs/tags/dangling
	)
'

test_expect_success 'show-ref sub-modes are mutually exclusive' '
	test_must_fail git show-ref --verify --exclude-existing 2>err &&
	grep "verify" err &&
	grep "exclude-existing" err &&
	grep "cannot be used together" err &&

	test_must_fail git show-ref --verify --exists 2>err &&
	grep "verify" err &&
	grep "exists" err &&
	grep "cannot be used together" err &&

	test_must_fail git show-ref --exclude-existing --exists 2>err &&
	grep "exclude-existing" err &&
	grep "exists" err &&
	grep "cannot be used together" err
'

test_expect_success '--exists with existing reference' '
	git show-ref --exists refs/heads/$GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME
'

test_expect_success '--exists with missing reference' '
	test_expect_code 2 git show-ref --exists refs/heads/does-not-exist
'

test_expect_success '--exists does not use DWIM' '
	test_expect_code 2 git show-ref --exists $GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 2>err &&
	grep "reference does not exist" err
'

test_expect_success '--exists with HEAD' '
	git show-ref --exists HEAD
'

test_expect_success '--exists with bad reference name' '
	test_when_finished "git update-ref -d refs/heads/bad...name" &&
	new_oid=$(git rev-parse HEAD) &&
	test-tool ref-store main update-ref msg refs/heads/bad...name $new_oid $ZERO_OID REF_SKIP_REFNAME_VERIFICATION &&
	git show-ref --exists refs/heads/bad...name
'

test_expect_success '--exists with arbitrary symref' '
	test_when_finished "git symbolic-ref -d refs/symref" &&
	git symbolic-ref refs/symref refs/heads/$GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME &&
	git show-ref --exists refs/symref
'

test_expect_success '--exists with dangling symref' '
	test_when_finished "git symbolic-ref -d refs/heads/dangling" &&
	git symbolic-ref refs/heads/dangling refs/heads/does-not-exist &&
	git show-ref --exists refs/heads/dangling
'

test_expect_success '--exists with nonexistent object ID' '
	test-tool ref-store main update-ref msg refs/heads/missing-oid $(test_oid 001) $ZERO_OID REF_SKIP_OID_VERIFICATION &&
	git show-ref --exists refs/heads/missing-oid
'

test_expect_success '--exists with non-commit object' '
	tree_oid=$(git rev-parse HEAD^{tree}) &&
	test-tool ref-store main update-ref msg refs/heads/tree ${tree_oid} $ZERO_OID REF_SKIP_OID_VERIFICATION &&
	git show-ref --exists refs/heads/tree
'

test_expect_success '--exists with directory fails with generic error' '
	cat >expect <<-EOF &&
	error: reference does not exist
	EOF
	test_expect_code 2 git show-ref --exists refs/heads 2>err &&
	test_cmp expect err
'

test_expect_success '--exists with non-existent special ref' '
	test_expect_code 2 git show-ref --exists FETCH_HEAD
'

test_expect_success '--exists with existing special ref' '
	test_when_finished "rm .git/FETCH_HEAD" &&
	git rev-parse HEAD >.git/FETCH_HEAD &&
	git show-ref --exists FETCH_HEAD
'

test_done
Commit	Line	Data
3f3d0cea DB	1	#!/bin/sh
	2
	3	test_description='show-ref'
06d53148	4	GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main
334afbc7 JS	5	export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME
334afbc7 JS	6
9081a421	7	TEST_PASSES_SANITIZE_LEAK=true
3f3d0cea DB	8	. ./test-lib.sh
	9
	10	test_expect_success setup '
6cf8d96f	11	test_commit --annotate A &&
3f3d0cea	12	git checkout -b side &&
6cf8d96f	13	test_commit --annotate B &&
06d53148	14	git checkout main &&
3f3d0cea DB	15	test_commit C &&
	16	git branch B A^0
	17	'
	18
	19	test_expect_success 'show-ref' '
	20	echo $(git rev-parse refs/tags/A) refs/tags/A >expect &&
	21
	22	git show-ref A >actual &&
	23	test_cmp expect actual &&
	24
	25	git show-ref tags/A >actual &&
	26	test_cmp expect actual &&
	27
	28	git show-ref refs/tags/A >actual &&
	29	test_cmp expect actual &&
	30
8fb26872	31	test_must_fail git show-ref D >actual &&
d3c6751b	32	test_must_be_empty actual
3f3d0cea DB	33	'
	34
	35	test_expect_success 'show-ref -q' '
3f3d0cea	36	git show-ref -q A >actual &&
d3c6751b	37	test_must_be_empty actual &&
3f3d0cea DB	38
3f3d0cea DB	39	git show-ref -q tags/A >actual &&
d3c6751b	40	test_must_be_empty actual &&
3f3d0cea DB	41
3f3d0cea DB	42	git show-ref -q refs/tags/A >actual &&
d3c6751b	43	test_must_be_empty actual &&
3f3d0cea DB	44
3f3d0cea DB	45	test_must_fail git show-ref -q D >actual &&
d3c6751b	46	test_must_be_empty actual
3f3d0cea DB	47	'
	48
	49	test_expect_success 'show-ref --verify' '
	50	echo $(git rev-parse refs/tags/A) refs/tags/A >expect &&
	51
	52	git show-ref --verify refs/tags/A >actual &&
	53	test_cmp expect actual &&
	54
3f3d0cea	55	test_must_fail git show-ref --verify A >actual &&
d3c6751b	56	test_must_be_empty actual &&
3f3d0cea DB	57
3f3d0cea DB	58	test_must_fail git show-ref --verify tags/A >actual &&
d3c6751b	59	test_must_be_empty actual &&
3f3d0cea	60
8fb26872	61	test_must_fail git show-ref --verify D >actual &&
d3c6751b	62	test_must_be_empty actual
3f3d0cea DB	63	'
	64
	65	test_expect_success 'show-ref --verify -q' '
3f3d0cea	66	git show-ref --verify -q refs/tags/A >actual &&
d3c6751b	67	test_must_be_empty actual &&
3f3d0cea DB	68
3f3d0cea DB	69	test_must_fail git show-ref --verify -q A >actual &&
d3c6751b	70	test_must_be_empty actual &&
3f3d0cea DB	71
3f3d0cea DB	72	test_must_fail git show-ref --verify -q tags/A >actual &&
d3c6751b	73	test_must_be_empty actual &&
3f3d0cea	74
8fb26872	75	test_must_fail git show-ref --verify -q D >actual &&
d3c6751b	76	test_must_be_empty actual
3f3d0cea DB	77	'
	78
	79	test_expect_success 'show-ref -d' '
	80	{
	81	echo $(git rev-parse refs/tags/A) refs/tags/A &&
7abcbcb7	82	echo $(git rev-parse refs/tags/A^0) "refs/tags/A^{}" &&
3f3d0cea DB	83	echo $(git rev-parse refs/tags/C) refs/tags/C
	84	} >expect &&
	85	git show-ref -d A C >actual &&
	86	test_cmp expect actual &&
	87
	88	git show-ref -d tags/A tags/C >actual &&
	89	test_cmp expect actual &&
	90
	91	git show-ref -d refs/tags/A refs/tags/C >actual &&
	92	test_cmp expect actual &&
	93
f1627040 VP	94	git show-ref --verify -d refs/tags/A refs/tags/C >actual &&
	95	test_cmp expect actual &&
	96
06d53148 JS	97	echo $(git rev-parse refs/heads/main) refs/heads/main >expect &&
06d53148 JS	98	git show-ref -d main >actual &&
3f3d0cea DB	99	test_cmp expect actual &&
3f3d0cea DB	100
06d53148	101	git show-ref -d heads/main >actual &&
3f3d0cea DB	102	test_cmp expect actual &&
3f3d0cea DB	103
06d53148	104	git show-ref -d refs/heads/main >actual &&
8fb26872	105	test_cmp expect actual &&
3f3d0cea	106
06d53148	107	git show-ref -d --verify refs/heads/main >actual &&
8fb26872	108	test_cmp expect actual &&
3f3d0cea	109
06d53148	110	test_must_fail git show-ref -d --verify main >actual &&
d3c6751b	111	test_must_be_empty actual &&
3f3d0cea	112
06d53148	113	test_must_fail git show-ref -d --verify heads/main >actual &&
d3c6751b	114	test_must_be_empty actual &&
f1627040 VP	115
f1627040 VP	116	test_must_fail git show-ref --verify -d A C >actual &&
d3c6751b	117	test_must_be_empty actual &&
f1627040 VP	118
f1627040 VP	119	test_must_fail git show-ref --verify -d tags/A tags/C >actual &&
d3c6751b	120	test_must_be_empty actual
3f3d0cea DB	121
	122	'
	123
	124	test_expect_success 'show-ref --heads, --tags, --head, pattern' '
06d53148	125	for branch in B main side
3f3d0cea	126	do
db5875aa	127	echo $(git rev-parse refs/heads/$branch) refs/heads/$branch \|\| return 1
3f3d0cea DB	128	done >expect.heads &&
	129	git show-ref --heads >actual &&
	130	test_cmp expect.heads actual &&
	131
	132	for tag in A B C
	133	do
db5875aa	134	echo $(git rev-parse refs/tags/$tag) refs/tags/$tag \|\| return 1
3f3d0cea DB	135	done >expect.tags &&
	136	git show-ref --tags >actual &&
	137	test_cmp expect.tags actual &&
	138
	139	cat expect.heads expect.tags >expect &&
	140	git show-ref --heads --tags >actual &&
	141	test_cmp expect actual &&
	142
	143	{
	144	echo $(git rev-parse HEAD) HEAD &&
	145	cat expect.heads expect.tags
	146	} >expect &&
	147	git show-ref --heads --tags --head >actual &&
	148	test_cmp expect actual &&
	149
	150	{
	151	echo $(git rev-parse HEAD) HEAD &&
7abcbcb7	152	echo $(git rev-parse refs/heads/B) refs/heads/B &&
3f3d0cea DB	153	echo $(git rev-parse refs/tags/B) refs/tags/B
	154	} >expect &&
	155	git show-ref --head B >actual &&
	156	test_cmp expect actual &&
	157
	158	{
	159	echo $(git rev-parse HEAD) HEAD &&
7abcbcb7 ES	160	echo $(git rev-parse refs/heads/B) refs/heads/B &&
7abcbcb7 ES	161	echo $(git rev-parse refs/tags/B) refs/tags/B &&
3f3d0cea DB	162	echo $(git rev-parse refs/tags/B^0) "refs/tags/B^{}"
	163	} >expect &&
	164	git show-ref --head -d B >actual &&
	165	test_cmp expect actual
	166	'
	167
ec7c51bc VP	168	test_expect_success 'show-ref --verify HEAD' '
	169	echo $(git rev-parse HEAD) HEAD >expect &&
	170	git show-ref --verify HEAD >actual &&
	171	test_cmp expect actual &&
	172
ec7c51bc	173	git show-ref --verify -q HEAD >actual &&
d3c6751b	174	test_must_be_empty actual
ec7c51bc VP	175	'
ec7c51bc VP	176
d01b8203 VP	177	test_expect_success 'show-ref --verify with dangling ref' '
	178	sha1_file() {
	179	echo "$*" \| sed "s#..#.git/objects/&/#"
	180	} &&
	181
	182	remove_object() {
	183	file=$(sha1_file "$*") &&
	184	test -e "$file" &&
	185	rm -f "$file"
	186	} &&
	187
	188	test_when_finished "rm -rf dangling" &&
	189	(
	190	git init dangling &&
	191	cd dangling &&
	192	test_commit dangling &&
	193	sha=$(git rev-parse refs/tags/dangling) &&
	194	remove_object $sha &&
	195	test_must_fail git show-ref --verify refs/tags/dangling
	196	)
	197	'
	198
199970e7	199	test_expect_success 'show-ref sub-modes are mutually exclusive' '
199970e7	200	test_must_fail git show-ref --verify --exclude-existing 2>err &&
73824973 RS	201	grep "verify" err &&
	202	grep "exclude-existing" err &&
	203	grep "cannot be used together" err &&
9080a7f1 PS	204
9080a7f1 PS	205	test_must_fail git show-ref --verify --exists 2>err &&
73824973 RS	206	grep "verify" err &&
	207	grep "exists" err &&
	208	grep "cannot be used together" err &&
9080a7f1 PS	209
9080a7f1 PS	210	test_must_fail git show-ref --exclude-existing --exists 2>err &&
73824973 RS	211	grep "exclude-existing" err &&
	212	grep "exists" err &&
	213	grep "cannot be used together" err
9080a7f1 PS	214	'
	215
	216	test_expect_success '--exists with existing reference' '
	217	git show-ref --exists refs/heads/$GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME
	218	'
	219
	220	test_expect_success '--exists with missing reference' '
	221	test_expect_code 2 git show-ref --exists refs/heads/does-not-exist
	222	'
	223
	224	test_expect_success '--exists does not use DWIM' '
	225	test_expect_code 2 git show-ref --exists $GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME 2>err &&
	226	grep "reference does not exist" err
	227	'
	228
	229	test_expect_success '--exists with HEAD' '
	230	git show-ref --exists HEAD
	231	'
	232
	233	test_expect_success '--exists with bad reference name' '
	234	test_when_finished "git update-ref -d refs/heads/bad...name" &&
	235	new_oid=$(git rev-parse HEAD) &&
	236	test-tool ref-store main update-ref msg refs/heads/bad...name $new_oid $ZERO_OID REF_SKIP_REFNAME_VERIFICATION &&
	237	git show-ref --exists refs/heads/bad...name
	238	'
	239
	240	test_expect_success '--exists with arbitrary symref' '
	241	test_when_finished "git symbolic-ref -d refs/symref" &&
	242	git symbolic-ref refs/symref refs/heads/$GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME &&
	243	git show-ref --exists refs/symref
	244	'
	245
	246	test_expect_success '--exists with dangling symref' '
	247	test_when_finished "git symbolic-ref -d refs/heads/dangling" &&
	248	git symbolic-ref refs/heads/dangling refs/heads/does-not-exist &&
	249	git show-ref --exists refs/heads/dangling
	250	'
	251
	252	test_expect_success '--exists with nonexistent object ID' '
	253	test-tool ref-store main update-ref msg refs/heads/missing-oid $(test_oid 001) $ZERO_OID REF_SKIP_OID_VERIFICATION &&
	254	git show-ref --exists refs/heads/missing-oid
	255	'
	256
	257	test_expect_success '--exists with non-commit object' '
	258	tree_oid=$(git rev-parse HEAD^{tree}) &&
	259	test-tool ref-store main update-ref msg refs/heads/tree ${tree_oid} $ZERO_OID REF_SKIP_OID_VERIFICATION &&
	260	git show-ref --exists refs/heads/tree
	261	'
	262
	263	test_expect_success '--exists with directory fails with generic error' '
	264	cat >expect <<-EOF &&
0aabeaa5	265	error: reference does not exist
9080a7f1	266	EOF
0aabeaa5	267	test_expect_code 2 git show-ref --exists refs/heads 2>err &&
199970e7 PS	268	test_cmp expect err
	269	'
	270
668cdc04 PS	271	test_expect_success '--exists with non-existent special ref' '
	272	test_expect_code 2 git show-ref --exists FETCH_HEAD
	273	'
	274
	275	test_expect_success '--exists with existing special ref' '
	276	test_when_finished "rm .git/FETCH_HEAD" &&
	277	git rev-parse HEAD >.git/FETCH_HEAD &&
	278	git show-ref --exists FETCH_HEAD
	279	'
	280
3f3d0cea	281	test_done