t/t2080-parallel-checkout-basics.sh - jrn/git - Git at Google

 #!/bin/sh

 test_description='parallel-checkout basics

 Ensure that parallel-checkout basically works on clone and checkout, spawning
 the required number of workers and correctly populating both the index and the
 working tree.
 '

 TEST_NO_CREATE_REPO=1
 . ./test-lib.sh
 . "$TEST_DIRECTORY/lib-parallel-checkout.sh"

 # Test parallel-checkout with a branch switch containing a variety of file
 # creations, deletions, and modifications, involving different entry types.
 # The branches B1 and B2 have the following paths:
 #
 #      B1                 B2
 #  a/a (file)         a   (file)
 #  b   (file)         b/b (file)
 #
 #  c/c (file)         c   (symlink)
 #  d   (symlink)      d/d (file)
 #
 #  e/e (file)         e   (submodule)
 #  f   (submodule)    f/f (file)
 #
 #  g   (submodule)    g   (symlink)
 #  h   (symlink)      h   (submodule)
 #
 # Additionally, the following paths are present on both branches, but with
 # different contents:
 #
 #  i   (file)         i   (file)
 #  j   (symlink)      j   (symlink)
 #  k   (submodule)    k   (submodule)
 #
 # And the following paths are only present in one of the branches:
 #
 #  l/l (file)         -
 #  -                  m/m (file)
 #
 test_expect_success 'setup repo for checkout with various types of changes' '
 	test_config_global protocol.file.allow always &&

 	git init sub &&
 	(
 		cd sub &&
 		git checkout -b B2 &&
 		echo B2 >file &&
 		git add file &&
 		git commit -m file &&

 		git checkout -b B1 &&
 		echo B1 >file &&
 		git add file &&
 		git commit -m file
 	) &&

 	git init various &&
 	(
 		cd various &&

 		git checkout -b B1 &&
 		mkdir a c e &&
 		echo a/a >a/a &&
 		echo b >b &&
 		echo c/c >c/c &&
 		test_ln_s_add c d &&
 		echo e/e >e/e &&
 		git submodule add ../sub f &&
 		git submodule add ../sub g &&
 		test_ln_s_add c h &&

 		echo "B1 i" >i &&
 		test_ln_s_add c j &&
 		git submodule add -b B1 ../sub k &&
 		mkdir l &&
 		echo l/l >l/l &&

 		git add . &&
 		git commit -m B1 &&

 		git checkout -b B2 &&
 		git rm -rf :^.gitmodules :^k &&
 		mkdir b d f &&
 		echo a >a &&
 		echo b/b >b/b &&
 		test_ln_s_add b c &&
 		echo d/d >d/d &&
 		git submodule add ../sub e &&
 		echo f/f >f/f &&
 		test_ln_s_add b g &&
 		git submodule add ../sub h &&

 		echo "B2 i" >i &&
 		test_ln_s_add b j &&
 		git -C k checkout B2 &&
 		mkdir m &&
 		echo m/m >m/m &&

 		git add . &&
 		git commit -m B2 &&

 		git checkout --recurse-submodules B1
 	)
 '

 for mode in sequential parallel sequential-fallback
 do
 	case $mode in
 	sequential)          workers=1 threshold=0 expected_workers=0 ;;
 	parallel)            workers=2 threshold=0 expected_workers=2 ;;
 	sequential-fallback) workers=2 threshold=100 expected_workers=0 ;;
 	esac

 	test_expect_success "$mode checkout" '
 		repo=various_$mode &&
 		cp -R -P various $repo &&

 		# The just copied files have more recent timestamps than their
 		# associated index entries. So refresh the cached timestamps
 		# to avoid an "entry not up-to-date" error from `git checkout`.
 		# We only have to do this for the submodules as `git checkout`
 		# will already refresh the superproject index before performing
 		# the up-to-date check.
 		#
 		git -C $repo submodule foreach "git update-index --refresh" &&

 		set_checkout_config $workers $threshold &&
 		test_checkout_workers $expected_workers \
 			git -C $repo checkout --recurse-submodules B2 &&
 		verify_checkout $repo
 	'
 done

 for mode in parallel sequential-fallback
 do
 	case $mode in
 	parallel)            workers=2 threshold=0 expected_workers=2 ;;
 	sequential-fallback) workers=2 threshold=100 expected_workers=0 ;;
 	esac

 	test_expect_success "$mode checkout on clone" '
 		test_config_global protocol.file.allow always &&
 		repo=various_${mode}_clone &&
 		set_checkout_config $workers $threshold &&
 		test_checkout_workers $expected_workers \
 			git clone --recurse-submodules --branch B2 various $repo &&
 		verify_checkout $repo
 	'
 done

 # Just to be paranoid, actually compare the working trees' contents directly.
 test_expect_success 'compare the working trees' '
 	rm -rf various_*/.git &&
 	rm -rf various_*/*/.git &&

 	# We use `git diff` instead of `diff -r` because the latter would
 	# follow symlinks, and not all `diff` implementations support the
 	# `--no-dereference` option.
 	#
 	git diff --no-index various_sequential various_parallel &&
 	git diff --no-index various_sequential various_parallel_clone &&
 	git diff --no-index various_sequential various_sequential-fallback &&
 	git diff --no-index various_sequential various_sequential-fallback_clone
 '

 # Currently, each submodule is checked out in a separated child process, but
 # these subprocesses must also be able to use parallel checkout workers to
 # write the submodules' entries.
 test_expect_success 'submodules can use parallel checkout' '
 	set_checkout_config 2 0 &&
 	git init super &&
 	(
 		cd super &&
 		git init sub &&
 		test_commit -C sub A &&
 		test_commit -C sub B &&
 		git submodule add ./sub &&
 		git commit -m sub &&
 		rm sub/* &&
 		test_checkout_workers 2 git checkout --recurse-submodules .
 	)
 '

 test_expect_success 'parallel checkout respects --[no]-force' '
 	set_checkout_config 2 0 &&
 	git init dirty &&
 	(
 		cd dirty &&
 		mkdir D &&
 		test_commit D/F &&
 		test_commit F &&

 		rm -rf D &&
 		echo changed >D &&
 		echo changed >F.t &&

 		# We expect 0 workers because there is nothing to be done
 		test_checkout_workers 0 git checkout HEAD &&
 		test_path_is_file D &&
 		grep changed D &&
 		grep changed F.t &&

 		test_checkout_workers 2 git checkout --force HEAD &&
 		test_path_is_dir D &&
 		grep D/F D/F.t &&
 		grep F F.t
 	)
 '

 test_expect_success SYMLINKS 'parallel checkout checks for symlinks in leading dirs' '
 	set_checkout_config 2 0 &&
 	git init symlinks &&
 	(
 		cd symlinks &&
 		mkdir D untracked &&
 		# Commit 2 files to have enough work for 2 parallel workers
 		test_commit D/A &&
 		test_commit D/B &&
 		rm -rf D &&
 		ln -s untracked D &&

 		test_checkout_workers 2 git checkout --force HEAD &&
 		! test -h D &&
 		grep D/A D/A.t &&
 		grep D/B D/B.t
 	)
 '

 # This test is here (and not in e.g. t2022-checkout-paths.sh), because we
 # check the final report including sequential, parallel, and delayed entries
 # all at the same time. So we must have finer control of the parallel checkout
 # variables.
 test_expect_success '"git checkout ." report should not include failed entries' '
 	test_config_global filter.delay.process \
 		"test-tool rot13-filter --always-delay --log=delayed.log clean smudge delay" &&
 	test_config_global filter.delay.required true &&
 	test_config_global filter.cat.clean cat  &&
 	test_config_global filter.cat.smudge cat  &&
 	test_config_global filter.cat.required true  &&

 	set_checkout_config 2 0 &&
 	git init failed_entries &&
 	(
 		cd failed_entries &&
 		cat >.gitattributes <<-EOF &&
 		*delay*              filter=delay
 		parallel-ineligible* filter=cat
 		EOF
 		echo a >missing-delay.a &&
 		echo a >parallel-ineligible.a &&
 		echo a >parallel-eligible.a &&
 		echo b >success-delay.b &&
 		echo b >parallel-ineligible.b &&
 		echo b >parallel-eligible.b &&
 		git add -A &&
 		git commit -m files &&

 		a_blob="$(git rev-parse :parallel-ineligible.a)" &&
 		rm .git/objects/$(test_oid_to_path $a_blob) &&
 		rm *.a *.b &&

 		test_checkout_workers 2 test_must_fail git checkout . 2>err &&

 		# All *.b entries should succeed and all *.a entries should fail:
 		#  - missing-delay.a: the delay filter will drop this path
 		#  - parallel-*.a: the blob will be missing
 		#
 		grep "Updated 3 paths from the index" err &&
 		test_stdout_line_count = 3 ls *.b &&
 		! ls *.a
 	)
 '

 test_done
	#!/bin/sh

	test_description='parallel-checkout basics

	Ensure that parallel-checkout basically works on clone and checkout, spawning
	the required number of workers and correctly populating both the index and the
	working tree.
	'

	TEST_NO_CREATE_REPO=1
	. ./test-lib.sh
	. "$TEST_DIRECTORY/lib-parallel-checkout.sh"

	# Test parallel-checkout with a branch switch containing a variety of file
	# creations, deletions, and modifications, involving different entry types.
	# The branches B1 and B2 have the following paths:
	#
	# B1 B2
	# a/a (file) a (file)
	# b (file) b/b (file)
	#
	# c/c (file) c (symlink)
	# d (symlink) d/d (file)
	#
	# e/e (file) e (submodule)
	# f (submodule) f/f (file)
	#
	# g (submodule) g (symlink)
	# h (symlink) h (submodule)
	#
	# Additionally, the following paths are present on both branches, but with
	# different contents:
	#
	# i (file) i (file)
	# j (symlink) j (symlink)
	# k (submodule) k (submodule)
	#
	# And the following paths are only present in one of the branches:
	#
	# l/l (file) -
	# - m/m (file)
	#
	test_expect_success 'setup repo for checkout with various types of changes' '
	test_config_global protocol.file.allow always &&

	git init sub &&
	(
	cd sub &&
	git checkout -b B2 &&
	echo B2 >file &&
	git add file &&
	git commit -m file &&

	git checkout -b B1 &&
	echo B1 >file &&
	git add file &&
	git commit -m file
	) &&

	git init various &&
	(
	cd various &&

	git checkout -b B1 &&
	mkdir a c e &&
	echo a/a >a/a &&
	echo b >b &&
	echo c/c >c/c &&
	test_ln_s_add c d &&
	echo e/e >e/e &&
	git submodule add ../sub f &&
	git submodule add ../sub g &&
	test_ln_s_add c h &&

	echo "B1 i" >i &&
	test_ln_s_add c j &&
	git submodule add -b B1 ../sub k &&
	mkdir l &&
	echo l/l >l/l &&

	git add . &&
	git commit -m B1 &&

	git checkout -b B2 &&
	git rm -rf :^.gitmodules :^k &&
	mkdir b d f &&
	echo a >a &&
	echo b/b >b/b &&
	test_ln_s_add b c &&
	echo d/d >d/d &&
	git submodule add ../sub e &&
	echo f/f >f/f &&
	test_ln_s_add b g &&
	git submodule add ../sub h &&

	echo "B2 i" >i &&
	test_ln_s_add b j &&
	git -C k checkout B2 &&
	mkdir m &&
	echo m/m >m/m &&

	git add . &&
	git commit -m B2 &&

	git checkout --recurse-submodules B1
	)
	'

	for mode in sequential parallel sequential-fallback
	do
	case $mode in
	sequential) workers=1 threshold=0 expected_workers=0 ;;
	parallel) workers=2 threshold=0 expected_workers=2 ;;
	sequential-fallback) workers=2 threshold=100 expected_workers=0 ;;
	esac

	test_expect_success "$mode checkout" '
	repo=various_$mode &&
	cp -R -P various $repo &&

	# The just copied files have more recent timestamps than their
	# associated index entries. So refresh the cached timestamps
	# to avoid an "entry not up-to-date" error from `git checkout`.
	# We only have to do this for the submodules as `git checkout`
	# will already refresh the superproject index before performing
	# the up-to-date check.
	#
	git -C $repo submodule foreach "git update-index --refresh" &&

	set_checkout_config $workers $threshold &&
	test_checkout_workers $expected_workers \
	git -C $repo checkout --recurse-submodules B2 &&
	verify_checkout $repo
	'
	done

	for mode in parallel sequential-fallback
	do
	case $mode in
	parallel) workers=2 threshold=0 expected_workers=2 ;;
	sequential-fallback) workers=2 threshold=100 expected_workers=0 ;;
	esac

	test_expect_success "$mode checkout on clone" '
	test_config_global protocol.file.allow always &&
	repo=various_${mode}_clone &&
	set_checkout_config $workers $threshold &&
	test_checkout_workers $expected_workers \
	git clone --recurse-submodules --branch B2 various $repo &&
	verify_checkout $repo
	'
	done

	# Just to be paranoid, actually compare the working trees' contents directly.
	test_expect_success 'compare the working trees' '
	rm -rf various_*/.git &&
	rm -rf various_//.git &&

	# We use `git diff` instead of `diff -r` because the latter would
	# follow symlinks, and not all `diff` implementations support the
	# `--no-dereference` option.
	#
	git diff --no-index various_sequential various_parallel &&
	git diff --no-index various_sequential various_parallel_clone &&
	git diff --no-index various_sequential various_sequential-fallback &&
	git diff --no-index various_sequential various_sequential-fallback_clone
	'

	# Currently, each submodule is checked out in a separated child process, but
	# these subprocesses must also be able to use parallel checkout workers to
	# write the submodules' entries.
	test_expect_success 'submodules can use parallel checkout' '
	set_checkout_config 2 0 &&
	git init super &&
	(
	cd super &&
	git init sub &&
	test_commit -C sub A &&
	test_commit -C sub B &&
	git submodule add ./sub &&
	git commit -m sub &&
	rm sub/* &&
	test_checkout_workers 2 git checkout --recurse-submodules .
	)
	'

	test_expect_success 'parallel checkout respects --[no]-force' '
	set_checkout_config 2 0 &&
	git init dirty &&
	(
	cd dirty &&
	mkdir D &&
	test_commit D/F &&
	test_commit F &&

	rm -rf D &&
	echo changed >D &&
	echo changed >F.t &&

	# We expect 0 workers because there is nothing to be done
	test_checkout_workers 0 git checkout HEAD &&
	test_path_is_file D &&
	grep changed D &&
	grep changed F.t &&

	test_checkout_workers 2 git checkout --force HEAD &&
	test_path_is_dir D &&
	grep D/F D/F.t &&
	grep F F.t
	)
	'

	test_expect_success SYMLINKS 'parallel checkout checks for symlinks in leading dirs' '
	set_checkout_config 2 0 &&
	git init symlinks &&
	(
	cd symlinks &&
	mkdir D untracked &&
	# Commit 2 files to have enough work for 2 parallel workers
	test_commit D/A &&
	test_commit D/B &&
	rm -rf D &&
	ln -s untracked D &&

	test_checkout_workers 2 git checkout --force HEAD &&
	! test -h D &&
	grep D/A D/A.t &&
	grep D/B D/B.t
	)
	'

	# This test is here (and not in e.g. t2022-checkout-paths.sh), because we
	# check the final report including sequential, parallel, and delayed entries
	# all at the same time. So we must have finer control of the parallel checkout
	# variables.
	test_expect_success '"git checkout ." report should not include failed entries' '
	test_config_global filter.delay.process \
	"test-tool rot13-filter --always-delay --log=delayed.log clean smudge delay" &&
	test_config_global filter.delay.required true &&
	test_config_global filter.cat.clean cat &&
	test_config_global filter.cat.smudge cat &&
	test_config_global filter.cat.required true &&

	set_checkout_config 2 0 &&
	git init failed_entries &&
	(
	cd failed_entries &&
	cat >.gitattributes <<-EOF &&
	delay filter=delay
	parallel-ineligible* filter=cat
	EOF
	echo a >missing-delay.a &&
	echo a >parallel-ineligible.a &&
	echo a >parallel-eligible.a &&
	echo b >success-delay.b &&
	echo b >parallel-ineligible.b &&
	echo b >parallel-eligible.b &&
	git add -A &&
	git commit -m files &&

	a_blob="$(git rev-parse :parallel-ineligible.a)" &&
	rm .git/objects/$(test_oid_to_path $a_blob) &&
	rm .a .b &&

	test_checkout_workers 2 test_must_fail git checkout . 2>err &&

	# All .b entries should succeed and all .a entries should fail:
	# - missing-delay.a: the delay filter will drop this path
	# - parallel-*.a: the blob will be missing
	#
	grep "Updated 3 paths from the index" err &&
	test_stdout_line_count = 3 ls *.b &&
	! ls *.a
	)
	'

	test_done