[thirdparty/git.git] / t / t5526-fetch-submodules.sh

#!/bin/sh
# Copyright (c) 2010, Jens Lehmann

test_description='Recursive "git fetch" for submodules'

. ./test-lib.sh

pwd=$(pwd)

add_upstream_commit() {
	(
		cd submodule &&
		head1=$(git rev-parse --short HEAD) &&
		echo new >> subfile &&
		test_tick &&
		git add subfile &&
		git commit -m new subfile &&
		head2=$(git rev-parse --short HEAD) &&
		echo "Fetching submodule submodule" > ../expect.err &&
		echo "From $pwd/submodule" >> ../expect.err &&
		echo "   $head1..$head2  master     -> origin/master" >> ../expect.err
	) &&
	(
		cd deepsubmodule &&
		head1=$(git rev-parse --short HEAD) &&
		echo new >> deepsubfile &&
		test_tick &&
		git add deepsubfile &&
		git commit -m new deepsubfile &&
		head2=$(git rev-parse --short HEAD) &&
		echo "Fetching submodule submodule/subdir/deepsubmodule" >> ../expect.err
		echo "From $pwd/deepsubmodule" >> ../expect.err &&
		echo "   $head1..$head2  master     -> origin/master" >> ../expect.err
	)
}

test_expect_success setup '
	mkdir deepsubmodule &&
	(
		cd deepsubmodule &&
		git init &&
		echo deepsubcontent > deepsubfile &&
		git add deepsubfile &&
		git commit -m new deepsubfile
	) &&
	mkdir submodule &&
	(
		cd submodule &&
		git init &&
		echo subcontent > subfile &&
		git add subfile &&
		git submodule add "$pwd/deepsubmodule" subdir/deepsubmodule &&
		git commit -a -m new
	) &&
	git submodule add "$pwd/submodule" submodule &&
	git commit -am initial &&
	git clone . downstream &&
	(
		cd downstream &&
		git submodule update --init --recursive
	)
'

test_expect_success "fetch --recurse-submodules recurses into submodules" '
	add_upstream_commit &&
	(
		cd downstream &&
		git fetch --recurse-submodules >../actual.out 2>../actual.err
	) &&
	test_must_be_empty actual.out &&
	test_i18ncmp expect.err actual.err
'

test_expect_success "submodule.recurse option triggers recursive fetch" '
	add_upstream_commit &&
	(
		cd downstream &&
		git -c submodule.recurse fetch >../actual.out 2>../actual.err
	) &&
	test_must_be_empty actual.out &&
	test_i18ncmp expect.err actual.err
'

test_expect_success "fetch --recurse-submodules -j2 has the same output behaviour" '
	add_upstream_commit &&
	(
		cd downstream &&
		GIT_TRACE="$TRASH_DIRECTORY/trace.out" git fetch --recurse-submodules -j2 2>../actual.err
	) &&
	test_must_be_empty actual.out &&
	test_i18ncmp expect.err actual.err &&
	grep "2 tasks" trace.out
'

test_expect_success "fetch alone only fetches superproject" '
	add_upstream_commit &&
	(
		cd downstream &&
		git fetch >../actual.out 2>../actual.err
	) &&
	test_must_be_empty actual.out &&
	test_must_be_empty actual.err
'

test_expect_success "fetch --no-recurse-submodules only fetches superproject" '
	(
		cd downstream &&
		git fetch --no-recurse-submodules >../actual.out 2>../actual.err
	) &&
	test_must_be_empty actual.out &&
	test_must_be_empty actual.err
'

test_expect_success "using fetchRecurseSubmodules=true in .gitmodules recurses into submodules" '
	(
		cd downstream &&
		git config -f .gitmodules submodule.submodule.fetchRecurseSubmodules true &&
		git fetch >../actual.out 2>../actual.err
	) &&
	test_must_be_empty actual.out &&
	test_i18ncmp expect.err actual.err
'

test_expect_success "--no-recurse-submodules overrides .gitmodules config" '
	add_upstream_commit &&
	(
		cd downstream &&
		git fetch --no-recurse-submodules >../actual.out 2>../actual.err
	) &&
	test_must_be_empty actual.out &&
	test_must_be_empty actual.err
'

test_expect_success "using fetchRecurseSubmodules=false in .git/config overrides setting in .gitmodules" '
	(
		cd downstream &&
		git config submodule.submodule.fetchRecurseSubmodules false &&
		git fetch >../actual.out 2>../actual.err
	) &&
	test_must_be_empty actual.out &&
	test_must_be_empty actual.err
'

test_expect_success "--recurse-submodules overrides fetchRecurseSubmodules setting from .git/config" '
	(
		cd downstream &&
		git fetch --recurse-submodules >../actual.out 2>../actual.err &&
		git config --unset -f .gitmodules submodule.submodule.fetchRecurseSubmodules &&
		git config --unset submodule.submodule.fetchRecurseSubmodules
	) &&
	test_must_be_empty actual.out &&
	test_i18ncmp expect.err actual.err
'

test_expect_success "--quiet propagates to submodules" '
	(
		cd downstream &&
		git fetch --recurse-submodules --quiet >../actual.out 2>../actual.err
	) &&
	test_must_be_empty actual.out &&
	test_must_be_empty actual.err
'

test_expect_success "--quiet propagates to parallel submodules" '
	(
		cd downstream &&
		git fetch --recurse-submodules -j 2 --quiet  >../actual.out 2>../actual.err
	) &&
	test_must_be_empty actual.out &&
	test_must_be_empty actual.err
'

test_expect_success "--dry-run propagates to submodules" '
	add_upstream_commit &&
	(
		cd downstream &&
		git fetch --recurse-submodules --dry-run >../actual.out 2>../actual.err
	) &&
	test_must_be_empty actual.out &&
	test_i18ncmp expect.err actual.err
'

test_expect_success "Without --dry-run propagates to submodules" '
	(
		cd downstream &&
		git fetch --recurse-submodules >../actual.out 2>../actual.err
	) &&
	test_must_be_empty actual.out &&
	test_i18ncmp expect.err actual.err
'

test_expect_success "recurseSubmodules=true propagates into submodules" '
	add_upstream_commit &&
	(
		cd downstream &&
		git config fetch.recurseSubmodules true &&
		git fetch >../actual.out 2>../actual.err
	) &&
	test_must_be_empty actual.out &&
	test_i18ncmp expect.err actual.err
'

test_expect_success "--recurse-submodules overrides config in submodule" '
	add_upstream_commit &&
	(
		cd downstream &&
		(
			cd submodule &&
			git config fetch.recurseSubmodules false
		) &&
		git fetch --recurse-submodules >../actual.out 2>../actual.err
	) &&
	test_must_be_empty actual.out &&
	test_i18ncmp expect.err actual.err
'

test_expect_success "--no-recurse-submodules overrides config setting" '
	add_upstream_commit &&
	(
		cd downstream &&
		git config fetch.recurseSubmodules true &&
		git fetch --no-recurse-submodules >../actual.out 2>../actual.err
	) &&
	test_must_be_empty actual.out &&
	test_must_be_empty actual.err
'

test_expect_success "Recursion doesn't happen when no new commits are fetched in the superproject" '
	(
		cd downstream &&
		(
			cd submodule &&
			git config --unset fetch.recurseSubmodules
		) &&
		git config --unset fetch.recurseSubmodules &&
		git fetch >../actual.out 2>../actual.err
	) &&
	test_must_be_empty actual.out &&
	test_must_be_empty actual.err
'

test_expect_success "Recursion stops when no new submodule commits are fetched" '
	head1=$(git rev-parse --short HEAD) &&
	git add submodule &&
	git commit -m "new submodule" &&
	head2=$(git rev-parse --short HEAD) &&
	echo "From $pwd/." > expect.err.sub &&
	echo "   $head1..$head2  master     -> origin/master" >>expect.err.sub &&
	head -3 expect.err >> expect.err.sub &&
	(
		cd downstream &&
		git fetch >../actual.out 2>../actual.err
	) &&
	test_i18ncmp expect.err.sub actual.err &&
	test_must_be_empty actual.out
'

test_expect_success "Recursion doesn't happen when new superproject commits don't change any submodules" '
	add_upstream_commit &&
	head1=$(git rev-parse --short HEAD) &&
	echo a > file &&
	git add file &&
	git commit -m "new file" &&
	head2=$(git rev-parse --short HEAD) &&
	echo "From $pwd/." > expect.err.file &&
	echo "   $head1..$head2  master     -> origin/master" >> expect.err.file &&
	(
		cd downstream &&
		git fetch >../actual.out 2>../actual.err
	) &&
	test_must_be_empty actual.out &&
	test_i18ncmp expect.err.file actual.err
'

test_expect_success "Recursion picks up config in submodule" '
	(
		cd downstream &&
		git fetch --recurse-submodules &&
		(
			cd submodule &&
			git config fetch.recurseSubmodules true
		)
	) &&
	add_upstream_commit &&
	head1=$(git rev-parse --short HEAD) &&
	git add submodule &&
	git commit -m "new submodule" &&
	head2=$(git rev-parse --short HEAD) &&
	echo "From $pwd/." > expect.err.sub &&
	echo "   $head1..$head2  master     -> origin/master" >> expect.err.sub &&
	cat expect.err >> expect.err.sub &&
	(
		cd downstream &&
		git fetch >../actual.out 2>../actual.err &&
		(
			cd submodule &&
			git config --unset fetch.recurseSubmodules
		)
	) &&
	test_i18ncmp expect.err.sub actual.err &&
	test_must_be_empty actual.out
'

test_expect_success "Recursion picks up all submodules when necessary" '
	add_upstream_commit &&
	(
		cd submodule &&
		(
			cd subdir/deepsubmodule &&
			git fetch &&
			git checkout -q FETCH_HEAD
		) &&
		head1=$(git rev-parse --short HEAD^) &&
		git add subdir/deepsubmodule &&
		git commit -m "new deepsubmodule" &&
		head2=$(git rev-parse --short HEAD) &&
		echo "Fetching submodule submodule" > ../expect.err.sub &&
		echo "From $pwd/submodule" >> ../expect.err.sub &&
		echo "   $head1..$head2  master     -> origin/master" >> ../expect.err.sub
	) &&
	head1=$(git rev-parse --short HEAD) &&
	git add submodule &&
	git commit -m "new submodule" &&
	head2=$(git rev-parse --short HEAD) &&
	echo "From $pwd/." > expect.err.2 &&
	echo "   $head1..$head2  master     -> origin/master" >> expect.err.2 &&
	cat expect.err.sub >> expect.err.2 &&
	tail -3 expect.err >> expect.err.2 &&
	(
		cd downstream &&
		git fetch >../actual.out 2>../actual.err
	) &&
	test_i18ncmp expect.err.2 actual.err &&
	test_must_be_empty actual.out
'

test_expect_success "'--recurse-submodules=on-demand' doesn't recurse when no new commits are fetched in the superproject (and ignores config)" '
	add_upstream_commit &&
	(
		cd submodule &&
		(
			cd subdir/deepsubmodule &&
			git fetch &&
			git checkout -q FETCH_HEAD
		) &&
		head1=$(git rev-parse --short HEAD^) &&
		git add subdir/deepsubmodule &&
		git commit -m "new deepsubmodule" &&
		head2=$(git rev-parse --short HEAD) &&
		echo Fetching submodule submodule > ../expect.err.sub &&
		echo "From $pwd/submodule" >> ../expect.err.sub &&
		echo "   $head1..$head2  master     -> origin/master" >> ../expect.err.sub
	) &&
	(
		cd downstream &&
		git config fetch.recurseSubmodules true &&
		git fetch --recurse-submodules=on-demand >../actual.out 2>../actual.err &&
		git config --unset fetch.recurseSubmodules
	) &&
	test_must_be_empty actual.out &&
	test_must_be_empty actual.err
'

test_expect_success "'--recurse-submodules=on-demand' recurses as deep as necessary (and ignores config)" '
	head1=$(git rev-parse --short HEAD) &&
	git add submodule &&
	git commit -m "new submodule" &&
	head2=$(git rev-parse --short HEAD) &&
	tail -3 expect.err > expect.err.deepsub &&
	echo "From $pwd/." > expect.err &&
	echo "   $head1..$head2  master     -> origin/master" >>expect.err &&
	cat expect.err.sub >> expect.err &&
	cat expect.err.deepsub >> expect.err &&
	(
		cd downstream &&
		git config fetch.recurseSubmodules false &&
		(
			cd submodule &&
			git config -f .gitmodules submodule.subdir/deepsubmodule.fetchRecursive false
		) &&
		git fetch --recurse-submodules=on-demand >../actual.out 2>../actual.err &&
		git config --unset fetch.recurseSubmodules
		(
			cd submodule &&
			git config --unset -f .gitmodules submodule.subdir/deepsubmodule.fetchRecursive
		)
	) &&
	test_must_be_empty actual.out &&
	test_i18ncmp expect.err actual.err
'

test_expect_success "'--recurse-submodules=on-demand' stops when no new submodule commits are found in the superproject (and ignores config)" '
	add_upstream_commit &&
	head1=$(git rev-parse --short HEAD) &&
	echo a >> file &&
	git add file &&
	git commit -m "new file" &&
	head2=$(git rev-parse --short HEAD) &&
	echo "From $pwd/." > expect.err.file &&
	echo "   $head1..$head2  master     -> origin/master" >> expect.err.file &&
	(
		cd downstream &&
		git fetch --recurse-submodules=on-demand >../actual.out 2>../actual.err
	) &&
	test_must_be_empty actual.out &&
	test_i18ncmp expect.err.file actual.err
'

test_expect_success "'fetch.recurseSubmodules=on-demand' overrides global config" '
	(
		cd downstream &&
		git fetch --recurse-submodules
	) &&
	add_upstream_commit &&
	git config --global fetch.recurseSubmodules false &&
	head1=$(git rev-parse --short HEAD) &&
	git add submodule &&
	git commit -m "new submodule" &&
	head2=$(git rev-parse --short HEAD) &&
	echo "From $pwd/." > expect.err.2 &&
	echo "   $head1..$head2  master     -> origin/master" >>expect.err.2 &&
	head -3 expect.err >> expect.err.2 &&
	(
		cd downstream &&
		git config fetch.recurseSubmodules on-demand &&
		git fetch >../actual.out 2>../actual.err
	) &&
	git config --global --unset fetch.recurseSubmodules &&
	(
		cd downstream &&
		git config --unset fetch.recurseSubmodules
	) &&
	test_must_be_empty actual.out &&
	test_i18ncmp expect.err.2 actual.err
'

test_expect_success "'submodule.<sub>.fetchRecurseSubmodules=on-demand' overrides fetch.recurseSubmodules" '
	(
		cd downstream &&
		git fetch --recurse-submodules
	) &&
	add_upstream_commit &&
	git config fetch.recurseSubmodules false &&
	head1=$(git rev-parse --short HEAD) &&
	git add submodule &&
	git commit -m "new submodule" &&
	head2=$(git rev-parse --short HEAD) &&
	echo "From $pwd/." > expect.err.2 &&
	echo "   $head1..$head2  master     -> origin/master" >>expect.err.2 &&
	head -3 expect.err >> expect.err.2 &&
	(
		cd downstream &&
		git config submodule.submodule.fetchRecurseSubmodules on-demand &&
		git fetch >../actual.out 2>../actual.err
	) &&
	git config --unset fetch.recurseSubmodules &&
	(
		cd downstream &&
		git config --unset submodule.submodule.fetchRecurseSubmodules
	) &&
	test_must_be_empty actual.out &&
	test_i18ncmp expect.err.2 actual.err
'

test_expect_success "don't fetch submodule when newly recorded commits are already present" '
	(
		cd submodule &&
		git checkout -q HEAD^^
	) &&
	head1=$(git rev-parse --short HEAD) &&
	git add submodule &&
	git commit -m "submodule rewound" &&
	head2=$(git rev-parse --short HEAD) &&
	echo "From $pwd/." > expect.err &&
	echo "   $head1..$head2  master     -> origin/master" >> expect.err &&
	(
		cd downstream &&
		git fetch >../actual.out 2>../actual.err
	) &&
	test_must_be_empty actual.out &&
	test_i18ncmp expect.err actual.err &&
	(
		cd submodule &&
		git checkout -q master
	)
'

test_expect_success "'fetch.recurseSubmodules=on-demand' works also without .gitmodules entry" '
	(
		cd downstream &&
		git fetch --recurse-submodules
	) &&
	add_upstream_commit &&
	head1=$(git rev-parse --short HEAD) &&
	git add submodule &&
	git rm .gitmodules &&
	git commit -m "new submodule without .gitmodules" &&
	head2=$(git rev-parse --short HEAD) &&
	echo "From $pwd/." >expect.err.2 &&
	echo "   $head1..$head2  master     -> origin/master" >>expect.err.2 &&
	head -3 expect.err >>expect.err.2 &&
	(
		cd downstream &&
		rm .gitmodules &&
		git config fetch.recurseSubmodules on-demand &&
		# fake submodule configuration to avoid skipping submodule handling
		git config -f .gitmodules submodule.fake.path fake &&
		git config -f .gitmodules submodule.fake.url fakeurl &&
		git add .gitmodules &&
		git config --unset submodule.submodule.url &&
		git fetch >../actual.out 2>../actual.err &&
		# cleanup
		git config --unset fetch.recurseSubmodules &&
		git reset --hard
	) &&
	test_must_be_empty actual.out &&
	test_i18ncmp expect.err.2 actual.err &&
	git checkout HEAD^ -- .gitmodules &&
	git add .gitmodules &&
	git commit -m "new submodule restored .gitmodules"
'

test_expect_success 'fetching submodules respects parallel settings' '
	git config fetch.recurseSubmodules true &&
	(
		cd downstream &&
		GIT_TRACE=$(pwd)/trace.out git fetch --jobs 7 &&
		grep "7 tasks" trace.out &&
		git config submodule.fetchJobs 8 &&
		GIT_TRACE=$(pwd)/trace.out git fetch &&
		grep "8 tasks" trace.out &&
		GIT_TRACE=$(pwd)/trace.out git fetch --jobs 9 &&
		grep "9 tasks" trace.out
	)
'

test_expect_success 'fetching submodule into a broken repository' '
	# Prepare src and src/sub nested in it
	git init src &&
	(
		cd src &&
		git init sub &&
		git -C sub commit --allow-empty -m "initial in sub" &&
		git submodule add -- ./sub sub &&
		git commit -m "initial in top"
	) &&

	# Clone the old-fashoned way
	git clone src dst &&
	git -C dst clone ../src/sub sub &&

	# Make sure that old-fashoned layout is still supported
	git -C dst status &&

	# "diff" would find no change
	git -C dst diff --exit-code &&

	# Recursive-fetch works fine
	git -C dst fetch --recurse-submodules &&

	# Break the receiving submodule
	rm -f dst/sub/.git/HEAD &&

	# NOTE: without the fix the following tests will recurse forever!
	# They should terminate with an error.

	test_must_fail git -C dst status &&
	test_must_fail git -C dst diff &&
	test_must_fail git -C dst fetch --recurse-submodules
'

test_expect_success "fetch new commits when submodule got renamed" '
	git clone . downstream_rename &&
	(
		cd downstream_rename &&
		git submodule update --init --recursive &&
		git checkout -b rename &&
		git mv submodule submodule_renamed &&
		(
			cd submodule_renamed &&
			git checkout -b rename_sub &&
			echo a >a &&
			git add a &&
			git commit -ma &&
			git push origin rename_sub &&
			git rev-parse HEAD >../../expect
		) &&
		git add submodule_renamed &&
		git commit -m "update renamed submodule" &&
		git push origin rename
	) &&
	(
		cd downstream &&
		git fetch --recurse-submodules=on-demand &&
		(
			cd submodule &&
			git rev-parse origin/rename_sub >../../actual
		)
	) &&
	test_cmp expect actual
'

test_done
Commit	Line	Data
7dce19d3 JL	1	#!/bin/sh
	2	# Copyright (c) 2010, Jens Lehmann
	3
	4	test_description='Recursive "git fetch" for submodules'
	5
	6	. ./test-lib.sh
	7
	8	pwd=$(pwd)
	9
	10	add_upstream_commit() {
	11	(
	12	cd submodule &&
	13	head1=$(git rev-parse --short HEAD) &&
	14	echo new >> subfile &&
	15	test_tick &&
	16	git add subfile &&
	17	git commit -m new subfile &&
	18	head2=$(git rev-parse --short HEAD) &&
fbf71645 JN	19	echo "Fetching submodule submodule" > ../expect.err &&
fbf71645 JN	20	echo "From $pwd/submodule" >> ../expect.err &&
7dce19d3 JL	21	echo " $head1..$head2 master -> origin/master" >> ../expect.err
	22	) &&
	23	(
	24	cd deepsubmodule &&
	25	head1=$(git rev-parse --short HEAD) &&
	26	echo new >> deepsubfile &&
	27	test_tick &&
	28	git add deepsubfile &&
	29	git commit -m new deepsubfile &&
	30	head2=$(git rev-parse --short HEAD) &&
fbf71645	31	echo "Fetching submodule submodule/subdir/deepsubmodule" >> ../expect.err
7dce19d3 JL	32	echo "From $pwd/deepsubmodule" >> ../expect.err &&
	33	echo " $head1..$head2 master -> origin/master" >> ../expect.err
	34	)
	35	}
	36
	37	test_expect_success setup '
	38	mkdir deepsubmodule &&
	39	(
	40	cd deepsubmodule &&
	41	git init &&
	42	echo deepsubcontent > deepsubfile &&
	43	git add deepsubfile &&
	44	git commit -m new deepsubfile
	45	) &&
	46	mkdir submodule &&
	47	(
	48	cd submodule &&
	49	git init &&
	50	echo subcontent > subfile &&
	51	git add subfile &&
ea2d325b	52	git submodule add "$pwd/deepsubmodule" subdir/deepsubmodule &&
7dce19d3 JL	53	git commit -a -m new
	54	) &&
	55	git submodule add "$pwd/submodule" submodule &&
	56	git commit -am initial &&
	57	git clone . downstream &&
	58	(
	59	cd downstream &&
	60	git submodule update --init --recursive
fbf71645	61	)
7dce19d3 JL	62	'
	63
	64	test_expect_success "fetch --recurse-submodules recurses into submodules" '
	65	add_upstream_commit &&
	66	(
	67	cd downstream &&
	68	git fetch --recurse-submodules >../actual.out 2>../actual.err
cabdee2c	69	) &&
fbf71645	70	test_must_be_empty actual.out &&
cabdee2c	71	test_i18ncmp expect.err actual.err
7dce19d3 JL	72	'
7dce19d3 JL	73
58f4203e SB	74	test_expect_success "submodule.recurse option triggers recursive fetch" '
	75	add_upstream_commit &&
	76	(
	77	cd downstream &&
	78	git -c submodule.recurse fetch >../actual.out 2>../actual.err
	79	) &&
	80	test_must_be_empty actual.out &&
	81	test_i18ncmp expect.err actual.err
	82	'
	83
62104ba1 SB	84	test_expect_success "fetch --recurse-submodules -j2 has the same output behaviour" '
	85	add_upstream_commit &&
	86	(
	87	cd downstream &&
9b2ac68f	88	GIT_TRACE="$TRASH_DIRECTORY/trace.out" git fetch --recurse-submodules -j2 2>../actual.err
62104ba1 SB	89	) &&
	90	test_must_be_empty actual.out &&
	91	test_i18ncmp expect.err actual.err &&
	92	grep "2 tasks" trace.out
	93	'
	94
7dce19d3 JL	95	test_expect_success "fetch alone only fetches superproject" '
	96	add_upstream_commit &&
	97	(
	98	cd downstream &&
	99	git fetch >../actual.out 2>../actual.err
	100	) &&
ec10b018 SG	101	test_must_be_empty actual.out &&
ec10b018 SG	102	test_must_be_empty actual.err
7dce19d3 JL	103	'
7dce19d3 JL	104
c1a3c364 JL	105	test_expect_success "fetch --no-recurse-submodules only fetches superproject" '
	106	(
	107	cd downstream &&
	108	git fetch --no-recurse-submodules >../actual.out 2>../actual.err
	109	) &&
ec10b018 SG	110	test_must_be_empty actual.out &&
ec10b018 SG	111	test_must_be_empty actual.err
c1a3c364 JL	112	'
	113
	114	test_expect_success "using fetchRecurseSubmodules=true in .gitmodules recurses into submodules" '
	115	(
	116	cd downstream &&
	117	git config -f .gitmodules submodule.submodule.fetchRecurseSubmodules true &&
	118	git fetch >../actual.out 2>../actual.err
cabdee2c	119	) &&
fbf71645	120	test_must_be_empty actual.out &&
cabdee2c	121	test_i18ncmp expect.err actual.err
c1a3c364 JL	122	'
	123
	124	test_expect_success "--no-recurse-submodules overrides .gitmodules config" '
	125	add_upstream_commit &&
	126	(
	127	cd downstream &&
	128	git fetch --no-recurse-submodules >../actual.out 2>../actual.err
	129	) &&
ec10b018 SG	130	test_must_be_empty actual.out &&
ec10b018 SG	131	test_must_be_empty actual.err
c1a3c364 JL	132	'
	133
	134	test_expect_success "using fetchRecurseSubmodules=false in .git/config overrides setting in .gitmodules" '
	135	(
	136	cd downstream &&
	137	git config submodule.submodule.fetchRecurseSubmodules false &&
	138	git fetch >../actual.out 2>../actual.err
	139	) &&
ec10b018 SG	140	test_must_be_empty actual.out &&
ec10b018 SG	141	test_must_be_empty actual.err
c1a3c364 JL	142	'
	143
	144	test_expect_success "--recurse-submodules overrides fetchRecurseSubmodules setting from .git/config" '
	145	(
	146	cd downstream &&
	147	git fetch --recurse-submodules >../actual.out 2>../actual.err &&
a2a56468	148	git config --unset -f .gitmodules submodule.submodule.fetchRecurseSubmodules &&
c1a3c364	149	git config --unset submodule.submodule.fetchRecurseSubmodules
cabdee2c	150	) &&
fbf71645	151	test_must_be_empty actual.out &&
cabdee2c	152	test_i18ncmp expect.err actual.err
c1a3c364 JL	153	'
c1a3c364 JL	154
7dce19d3 JL	155	test_expect_success "--quiet propagates to submodules" '
	156	(
	157	cd downstream &&
	158	git fetch --recurse-submodules --quiet >../actual.out 2>../actual.err
	159	) &&
ec10b018 SG	160	test_must_be_empty actual.out &&
ec10b018 SG	161	test_must_be_empty actual.err
7dce19d3 JL	162	'
7dce19d3 JL	163
62104ba1 SB	164	test_expect_success "--quiet propagates to parallel submodules" '
	165	(
	166	cd downstream &&
	167	git fetch --recurse-submodules -j 2 --quiet >../actual.out 2>../actual.err
	168	) &&
ec10b018 SG	169	test_must_be_empty actual.out &&
ec10b018 SG	170	test_must_be_empty actual.err
62104ba1 SB	171	'
62104ba1 SB	172
7dce19d3 JL	173	test_expect_success "--dry-run propagates to submodules" '
	174	add_upstream_commit &&
	175	(
	176	cd downstream &&
	177	git fetch --recurse-submodules --dry-run >../actual.out 2>../actual.err
cabdee2c	178	) &&
fbf71645	179	test_must_be_empty actual.out &&
cabdee2c	180	test_i18ncmp expect.err actual.err
502681cd ÆAB	181	'
	182
	183	test_expect_success "Without --dry-run propagates to submodules" '
7dce19d3 JL	184	(
	185	cd downstream &&
	186	git fetch --recurse-submodules >../actual.out 2>../actual.err
cabdee2c	187	) &&
fbf71645	188	test_must_be_empty actual.out &&
cabdee2c	189	test_i18ncmp expect.err actual.err
7dce19d3 JL	190	'
7dce19d3 JL	191
be254a0e JL	192	test_expect_success "recurseSubmodules=true propagates into submodules" '
	193	add_upstream_commit &&
	194	(
	195	cd downstream &&
2aac933c	196	git config fetch.recurseSubmodules true &&
be254a0e	197	git fetch >../actual.out 2>../actual.err
cabdee2c	198	) &&
fbf71645	199	test_must_be_empty actual.out &&
cabdee2c	200	test_i18ncmp expect.err actual.err
be254a0e JL	201	'
	202
	203	test_expect_success "--recurse-submodules overrides config in submodule" '
	204	add_upstream_commit &&
	205	(
	206	cd downstream &&
	207	(
	208	cd submodule &&
	209	git config fetch.recurseSubmodules false
	210	) &&
	211	git fetch --recurse-submodules >../actual.out 2>../actual.err
cabdee2c	212	) &&
fbf71645	213	test_must_be_empty actual.out &&
cabdee2c	214	test_i18ncmp expect.err actual.err
be254a0e JL	215	'
	216
	217	test_expect_success "--no-recurse-submodules overrides config setting" '
	218	add_upstream_commit &&
	219	(
	220	cd downstream &&
2aac933c	221	git config fetch.recurseSubmodules true &&
be254a0e JL	222	git fetch --no-recurse-submodules >../actual.out 2>../actual.err
be254a0e JL	223	) &&
ec10b018 SG	224	test_must_be_empty actual.out &&
ec10b018 SG	225	test_must_be_empty actual.err
be254a0e JL	226	'
be254a0e JL	227
88a21979 JL	228	test_expect_success "Recursion doesn't happen when no new commits are fetched in the superproject" '
	229	(
	230	cd downstream &&
	231	(
	232	cd submodule &&
	233	git config --unset fetch.recurseSubmodules
	234	) &&
2aac933c	235	git config --unset fetch.recurseSubmodules &&
88a21979 JL	236	git fetch >../actual.out 2>../actual.err
88a21979 JL	237	) &&
ec10b018 SG	238	test_must_be_empty actual.out &&
ec10b018 SG	239	test_must_be_empty actual.err
88a21979 JL	240	'
	241
	242	test_expect_success "Recursion stops when no new submodule commits are fetched" '
	243	head1=$(git rev-parse --short HEAD) &&
	244	git add submodule &&
	245	git commit -m "new submodule" &&
	246	head2=$(git rev-parse --short HEAD) &&
88a21979	247	echo "From $pwd/." > expect.err.sub &&
99094a7a	248	echo " $head1..$head2 master -> origin/master" >>expect.err.sub &&
fbf71645	249	head -3 expect.err >> expect.err.sub &&
88a21979 JL	250	(
	251	cd downstream &&
	252	git fetch >../actual.out 2>../actual.err
	253	) &&
cabdee2c	254	test_i18ncmp expect.err.sub actual.err &&
fbf71645	255	test_must_be_empty actual.out
88a21979 JL	256	'
	257
	258	test_expect_success "Recursion doesn't happen when new superproject commits don't change any submodules" '
	259	add_upstream_commit &&
	260	head1=$(git rev-parse --short HEAD) &&
	261	echo a > file &&
	262	git add file &&
	263	git commit -m "new file" &&
	264	head2=$(git rev-parse --short HEAD) &&
	265	echo "From $pwd/." > expect.err.file &&
	266	echo " $head1..$head2 master -> origin/master" >> expect.err.file &&
	267	(
	268	cd downstream &&
	269	git fetch >../actual.out 2>../actual.err
	270	) &&
ec10b018	271	test_must_be_empty actual.out &&
cabdee2c	272	test_i18ncmp expect.err.file actual.err
88a21979 JL	273	'
	274
	275	test_expect_success "Recursion picks up config in submodule" '
	276	(
	277	cd downstream &&
	278	git fetch --recurse-submodules &&
	279	(
	280	cd submodule &&
	281	git config fetch.recurseSubmodules true
	282	)
	283	) &&
	284	add_upstream_commit &&
	285	head1=$(git rev-parse --short HEAD) &&
	286	git add submodule &&
	287	git commit -m "new submodule" &&
	288	head2=$(git rev-parse --short HEAD) &&
	289	echo "From $pwd/." > expect.err.sub &&
	290	echo " $head1..$head2 master -> origin/master" >> expect.err.sub &&
	291	cat expect.err >> expect.err.sub &&
	292	(
	293	cd downstream &&
	294	git fetch >../actual.out 2>../actual.err &&
	295	(
	296	cd submodule &&
	297	git config --unset fetch.recurseSubmodules
	298	)
	299	) &&
cabdee2c	300	test_i18ncmp expect.err.sub actual.err &&
fbf71645	301	test_must_be_empty actual.out
88a21979 JL	302	'
	303
	304	test_expect_success "Recursion picks up all submodules when necessary" '
	305	add_upstream_commit &&
	306	(
	307	cd submodule &&
	308	(
ea2d325b	309	cd subdir/deepsubmodule &&
88a21979 JL	310	git fetch &&
	311	git checkout -q FETCH_HEAD
	312	) &&
	313	head1=$(git rev-parse --short HEAD^) &&
ea2d325b	314	git add subdir/deepsubmodule &&
2aac933c	315	git commit -m "new deepsubmodule" &&
88a21979	316	head2=$(git rev-parse --short HEAD) &&
fbf71645 JN	317	echo "Fetching submodule submodule" > ../expect.err.sub &&
fbf71645 JN	318	echo "From $pwd/submodule" >> ../expect.err.sub &&
88a21979 JL	319	echo " $head1..$head2 master -> origin/master" >> ../expect.err.sub
	320	) &&
	321	head1=$(git rev-parse --short HEAD) &&
	322	git add submodule &&
	323	git commit -m "new submodule" &&
	324	head2=$(git rev-parse --short HEAD) &&
	325	echo "From $pwd/." > expect.err.2 &&
	326	echo " $head1..$head2 master -> origin/master" >> expect.err.2 &&
	327	cat expect.err.sub >> expect.err.2 &&
fbf71645	328	tail -3 expect.err >> expect.err.2 &&
88a21979 JL	329	(
	330	cd downstream &&
	331	git fetch >../actual.out 2>../actual.err
	332	) &&
cabdee2c	333	test_i18ncmp expect.err.2 actual.err &&
fbf71645	334	test_must_be_empty actual.out
88a21979 JL	335	'
88a21979 JL	336
8f0700dd JL	337	test_expect_success "'--recurse-submodules=on-demand' doesn't recurse when no new commits are fetched in the superproject (and ignores config)" '
	338	add_upstream_commit &&
	339	(
	340	cd submodule &&
	341	(
ea2d325b	342	cd subdir/deepsubmodule &&
8f0700dd JL	343	git fetch &&
	344	git checkout -q FETCH_HEAD
	345	) &&
	346	head1=$(git rev-parse --short HEAD^) &&
ea2d325b	347	git add subdir/deepsubmodule &&
99094a7a	348	git commit -m "new deepsubmodule" &&
8f0700dd	349	head2=$(git rev-parse --short HEAD) &&
fbf71645 JN	350	echo Fetching submodule submodule > ../expect.err.sub &&
fbf71645 JN	351	echo "From $pwd/submodule" >> ../expect.err.sub &&
8f0700dd JL	352	echo " $head1..$head2 master -> origin/master" >> ../expect.err.sub
	353	) &&
	354	(
	355	cd downstream &&
	356	git config fetch.recurseSubmodules true &&
	357	git fetch --recurse-submodules=on-demand >../actual.out 2>../actual.err &&
	358	git config --unset fetch.recurseSubmodules
	359	) &&
ec10b018 SG	360	test_must_be_empty actual.out &&
ec10b018 SG	361	test_must_be_empty actual.err
8f0700dd JL	362	'
	363
	364	test_expect_success "'--recurse-submodules=on-demand' recurses as deep as necessary (and ignores config)" '
	365	head1=$(git rev-parse --short HEAD) &&
	366	git add submodule &&
	367	git commit -m "new submodule" &&
	368	head2=$(git rev-parse --short HEAD) &&
fbf71645	369	tail -3 expect.err > expect.err.deepsub &&
8f0700dd	370	echo "From $pwd/." > expect.err &&
99094a7a	371	echo " $head1..$head2 master -> origin/master" >>expect.err &&
8f0700dd JL	372	cat expect.err.sub >> expect.err &&
	373	cat expect.err.deepsub >> expect.err &&
	374	(
	375	cd downstream &&
	376	git config fetch.recurseSubmodules false &&
	377	(
	378	cd submodule &&
ea2d325b	379	git config -f .gitmodules submodule.subdir/deepsubmodule.fetchRecursive false
8f0700dd JL	380	) &&
	381	git fetch --recurse-submodules=on-demand >../actual.out 2>../actual.err &&
	382	git config --unset fetch.recurseSubmodules
	383	(
	384	cd submodule &&
ea2d325b	385	git config --unset -f .gitmodules submodule.subdir/deepsubmodule.fetchRecursive
8f0700dd JL	386	)
8f0700dd JL	387	) &&
fbf71645	388	test_must_be_empty actual.out &&
cabdee2c	389	test_i18ncmp expect.err actual.err
8f0700dd JL	390	'
	391
	392	test_expect_success "'--recurse-submodules=on-demand' stops when no new submodule commits are found in the superproject (and ignores config)" '
	393	add_upstream_commit &&
	394	head1=$(git rev-parse --short HEAD) &&
	395	echo a >> file &&
	396	git add file &&
	397	git commit -m "new file" &&
	398	head2=$(git rev-parse --short HEAD) &&
	399	echo "From $pwd/." > expect.err.file &&
	400	echo " $head1..$head2 master -> origin/master" >> expect.err.file &&
	401	(
	402	cd downstream &&
	403	git fetch --recurse-submodules=on-demand >../actual.out 2>../actual.err
	404	) &&
ec10b018	405	test_must_be_empty actual.out &&
cabdee2c	406	test_i18ncmp expect.err.file actual.err
8f0700dd JL	407	'
8f0700dd JL	408
1fb25502 JL	409	test_expect_success "'fetch.recurseSubmodules=on-demand' overrides global config" '
	410	(
	411	cd downstream &&
	412	git fetch --recurse-submodules
	413	) &&
	414	add_upstream_commit &&
	415	git config --global fetch.recurseSubmodules false &&
	416	head1=$(git rev-parse --short HEAD) &&
	417	git add submodule &&
	418	git commit -m "new submodule" &&
	419	head2=$(git rev-parse --short HEAD) &&
	420	echo "From $pwd/." > expect.err.2 &&
99094a7a	421	echo " $head1..$head2 master -> origin/master" >>expect.err.2 &&
fbf71645	422	head -3 expect.err >> expect.err.2 &&
1fb25502 JL	423	(
	424	cd downstream &&
	425	git config fetch.recurseSubmodules on-demand &&
	426	git fetch >../actual.out 2>../actual.err
	427	) &&
	428	git config --global --unset fetch.recurseSubmodules &&
	429	(
	430	cd downstream &&
	431	git config --unset fetch.recurseSubmodules
	432	) &&
fbf71645	433	test_must_be_empty actual.out &&
cabdee2c	434	test_i18ncmp expect.err.2 actual.err
1fb25502 JL	435	'
1fb25502 JL	436
bf42b384 JL	437	test_expect_success "'submodule.<sub>.fetchRecurseSubmodules=on-demand' overrides fetch.recurseSubmodules" '
	438	(
	439	cd downstream &&
	440	git fetch --recurse-submodules
	441	) &&
	442	add_upstream_commit &&
	443	git config fetch.recurseSubmodules false &&
	444	head1=$(git rev-parse --short HEAD) &&
	445	git add submodule &&
	446	git commit -m "new submodule" &&
	447	head2=$(git rev-parse --short HEAD) &&
	448	echo "From $pwd/." > expect.err.2 &&
99094a7a	449	echo " $head1..$head2 master -> origin/master" >>expect.err.2 &&
fbf71645	450	head -3 expect.err >> expect.err.2 &&
bf42b384 JL	451	(
	452	cd downstream &&
	453	git config submodule.submodule.fetchRecurseSubmodules on-demand &&
	454	git fetch >../actual.out 2>../actual.err
	455	) &&
	456	git config --unset fetch.recurseSubmodules &&
	457	(
	458	cd downstream &&
	459	git config --unset submodule.submodule.fetchRecurseSubmodules
	460	) &&
fbf71645	461	test_must_be_empty actual.out &&
cabdee2c	462	test_i18ncmp expect.err.2 actual.err
bf42b384 JL	463	'
bf42b384 JL	464
c16c3e40 JL	465	test_expect_success "don't fetch submodule when newly recorded commits are already present" '
	466	(
	467	cd submodule &&
	468	git checkout -q HEAD^^
	469	) &&
	470	head1=$(git rev-parse --short HEAD) &&
	471	git add submodule &&
	472	git commit -m "submodule rewound" &&
	473	head2=$(git rev-parse --short HEAD) &&
	474	echo "From $pwd/." > expect.err &&
	475	echo " $head1..$head2 master -> origin/master" >> expect.err &&
	476	(
	477	cd downstream &&
	478	git fetch >../actual.out 2>../actual.err
	479	) &&
ec10b018	480	test_must_be_empty actual.out &&
01ce1225 HV	481	test_i18ncmp expect.err actual.err &&
	482	(
	483	cd submodule &&
	484	git checkout -q master
	485	)
	486	'
	487
5aea9fe6	488	test_expect_success "'fetch.recurseSubmodules=on-demand' works also without .gitmodules entry" '
01ce1225 HV	489	(
	490	cd downstream &&
	491	git fetch --recurse-submodules
	492	) &&
	493	add_upstream_commit &&
	494	head1=$(git rev-parse --short HEAD) &&
	495	git add submodule &&
	496	git rm .gitmodules &&
	497	git commit -m "new submodule without .gitmodules" &&
01ce1225 HV	498	head2=$(git rev-parse --short HEAD) &&
	499	echo "From $pwd/." >expect.err.2 &&
	500	echo " $head1..$head2 master -> origin/master" >>expect.err.2 &&
	501	head -3 expect.err >>expect.err.2 &&
	502	(
	503	cd downstream &&
	504	rm .gitmodules &&
	505	git config fetch.recurseSubmodules on-demand &&
	506	# fake submodule configuration to avoid skipping submodule handling
	507	git config -f .gitmodules submodule.fake.path fake &&
	508	git config -f .gitmodules submodule.fake.url fakeurl &&
	509	git add .gitmodules &&
	510	git config --unset submodule.submodule.url &&
	511	git fetch >../actual.out 2>../actual.err &&
	512	# cleanup
	513	git config --unset fetch.recurseSubmodules &&
	514	git reset --hard
	515	) &&
1c5e94f4	516	test_must_be_empty actual.out &&
01ce1225 HV	517	test_i18ncmp expect.err.2 actual.err &&
	518	git checkout HEAD^ -- .gitmodules &&
	519	git add .gitmodules &&
	520	git commit -m "new submodule restored .gitmodules"
c16c3e40 JL	521	'
c16c3e40 JL	522
a028a193 SB	523	test_expect_success 'fetching submodules respects parallel settings' '
	524	git config fetch.recurseSubmodules true &&
	525	(
	526	cd downstream &&
	527	GIT_TRACE=$(pwd)/trace.out git fetch --jobs 7 &&
	528	grep "7 tasks" trace.out &&
	529	git config submodule.fetchJobs 8 &&
	530	GIT_TRACE=$(pwd)/trace.out git fetch &&
	531	grep "8 tasks" trace.out &&
	532	GIT_TRACE=$(pwd)/trace.out git fetch --jobs 9 &&
	533	grep "9 tasks" trace.out
	534	)
	535	'
	536
10f5c526 JH	537	test_expect_success 'fetching submodule into a broken repository' '
	538	# Prepare src and src/sub nested in it
	539	git init src &&
	540	(
	541	cd src &&
	542	git init sub &&
	543	git -C sub commit --allow-empty -m "initial in sub" &&
	544	git submodule add -- ./sub sub &&
	545	git commit -m "initial in top"
	546	) &&
	547
	548	# Clone the old-fashoned way
	549	git clone src dst &&
	550	git -C dst clone ../src/sub sub &&
	551
	552	# Make sure that old-fashoned layout is still supported
	553	git -C dst status &&
	554
	555	# "diff" would find no change
	556	git -C dst diff --exit-code &&
	557
	558	# Recursive-fetch works fine
	559	git -C dst fetch --recurse-submodules &&
	560
	561	# Break the receiving submodule
	562	rm -f dst/sub/.git/HEAD &&
	563
	564	# NOTE: without the fix the following tests will recurse forever!
	565	# They should terminate with an error.
	566
	567	test_must_fail git -C dst status &&
	568	test_must_fail git -C dst diff &&
	569	test_must_fail git -C dst fetch --recurse-submodules
	570	'
	571
c68f8375 HV	572	test_expect_success "fetch new commits when submodule got renamed" '
	573	git clone . downstream_rename &&
	574	(
	575	cd downstream_rename &&
c3749f6e	576	git submodule update --init --recursive &&
c68f8375 HV	577	git checkout -b rename &&
	578	git mv submodule submodule_renamed &&
	579	(
	580	cd submodule_renamed &&
	581	git checkout -b rename_sub &&
	582	echo a >a &&
	583	git add a &&
	584	git commit -ma &&
	585	git push origin rename_sub &&
	586	git rev-parse HEAD >../../expect
	587	) &&
	588	git add submodule_renamed &&
	589	git commit -m "update renamed submodule" &&
	590	git push origin rename
	591	) &&
	592	(
	593	cd downstream &&
	594	git fetch --recurse-submodules=on-demand &&
	595	(
	596	cd submodule &&
	597	git rev-parse origin/rename_sub >../../actual
	598	)
	599	) &&
	600	test_cmp expect actual
	601	'
	602
7dce19d3	603	test_done