1 # Create a submodule layout used for all tests below.
3 # The following use cases are covered:
4 # - New submodule (no_submodule => add_sub1)
5 # - Removed submodule (add_sub1 => remove_sub1)
6 # - Updated submodule (add_sub1 => modify_sub1)
7 # - Updated submodule recursively (add_nested_sub => modify_sub1_recursively)
8 # - Submodule updated to invalid commit (add_sub1 => invalid_sub1)
9 # - Submodule updated from invalid commit (invalid_sub1 => valid_sub1)
10 # - Submodule replaced by tracked files in directory (add_sub1 =>
11 # replace_sub1_with_directory)
12 # - Directory containing tracked files replaced by submodule
13 # (replace_sub1_with_directory => replace_directory_with_sub1)
14 # - Submodule replaced by tracked file with the same name (add_sub1 =>
15 # replace_sub1_with_file)
16 # - Tracked file replaced by submodule (replace_sub1_with_file =>
17 # replace_file_with_sub1)
23 # add_sub1 /-------O---------O--------O modify_sub1_recursively
24 # | / ^ add_nested_sub
27 # O------O-----------O---------O
28 # ^ \ ^ replace_directory_with_sub1
29 # | \ replace_sub1_with_directory
32 # \ ^ replace_file_with_sub1
33 # \ replace_sub1_with_file
40 create_lib_submodule_repo
() {
41 git init submodule_update_sub1
&&
43 cd submodule_update_sub1
&&
44 echo "expect" >>.gitignore
&&
45 echo "actual" >>.gitignore
&&
48 git add .gitignore file1 file2
&&
49 git commit
-m "Base inside first submodule" &&
50 git branch
"no_submodule"
52 git init submodule_update_sub2
&&
54 cd submodule_update_sub2
55 echo "expect" >>.gitignore
&&
56 echo "actual" >>.gitignore
&&
59 git add .gitignore file1 file2
&&
60 git commit
-m "nested submodule base" &&
61 git branch
"no_submodule"
63 git init submodule_update_repo
&&
65 cd submodule_update_repo
&&
66 branch
=$
(git symbolic-ref
--short HEAD
) &&
67 echo "expect" >>.gitignore
&&
68 echo "actual" >>.gitignore
&&
71 git add .gitignore file1 file2
&&
72 git commit
-m "Base" &&
73 git branch
"no_submodule" &&
75 git checkout
-b "add_sub1" &&
76 git submodule add ..
/submodule_update_sub1 sub1
&&
77 git submodule add ..
/submodule_update_sub1 uninitialized_sub
&&
78 git config
-f .gitmodules submodule.sub1.ignore all
&&
79 git config submodule.sub1.ignore all
&&
80 git add .gitmodules
&&
81 git commit
-m "Add sub1" &&
83 git checkout
-b remove_sub1 add_sub1
&&
86 git checkout
-b modify_sub1 add_sub1
&&
87 git submodule update
&&
91 git checkout
-b "modifications" &&
94 git add file2 file3
&&
95 git commit
-m "modified file2 and added file3" &&
96 git push origin modifications
99 git commit
-m "Modify sub1" &&
101 git checkout
-b add_nested_sub modify_sub1
&&
102 git
-C sub1 checkout
-b "add_nested_sub" &&
103 git
-C sub1 submodule add
--branch no_submodule ..
/submodule_update_sub2 sub2
&&
104 git
-C sub1 commit
-a -m "add a nested submodule" &&
106 git commit
-a -m "update submodule, that updates a nested submodule" &&
107 git checkout
-b modify_sub1_recursively
&&
108 git
-C sub1 checkout
-b modify_sub1_recursively
&&
109 git
-C sub
1/sub2 checkout
-b modify_sub1_recursively
&&
110 echo change
>sub
1/sub
2/file3
&&
111 git
-C sub
1/sub2 add file3
&&
112 git
-C sub
1/sub2 commit
-m "make a change in nested sub" &&
113 git
-C sub1 add sub2
&&
114 git
-C sub1 commit
-m "update nested sub" &&
116 git commit
-m "update sub1, that updates nested sub" &&
117 git
-C sub1 push origin modify_sub1_recursively
&&
118 git
-C sub
1/sub2 push origin modify_sub1_recursively
&&
119 git
-C sub1 submodule deinit
-f --all &&
121 git checkout
-b replace_sub1_with_directory add_sub1
&&
122 git submodule update
&&
123 git
-C sub1 checkout modifications
&&
124 git
rm --cached sub1
&&
126 git config
-f .gitmodules
--remove-section "submodule.sub1" &&
127 git add .gitmodules sub
1/* &&
128 git commit
-m "Replace sub1 with directory" &&
130 git checkout
-b replace_directory_with_sub1
&&
133 git checkout
-b replace_sub1_with_file add_sub1
&&
135 echo "content" >sub1
&&
137 git commit
-m "Replace sub1 with file" &&
139 git checkout
-b replace_file_with_sub1
&&
142 git checkout
-b invalid_sub1 add_sub1
&&
143 git update-index
--cacheinfo 160000 $
(test_oid numeric
) sub1
&&
144 git commit
-m "Invalid sub1 commit" &&
145 git checkout
-b valid_sub1
&&
148 git checkout
"$branch"
152 # Helper function to replace gitfile with .git directory
153 replace_gitfile_with_git_dir
() {
156 git_dir
="$(git rev-parse --git-dir)" &&
158 cp -R "$git_dir" .git
&&
159 GIT_WORK_TREE
=. git config
--unset core.worktree
163 # Test that the .git directory in the submodule is unchanged (except for the
164 # core.worktree setting, which appears only in $GIT_DIR/modules/$1/config).
165 # Call this function before test_submodule_content as the latter might
166 # write the index file leading to false positive index differences.
168 # Note that this only supports submodules at the root level of the
169 # superproject, with the default name, i.e. same as its path.
170 test_git_directory_is_unchanged
() {
172 cd ".git/modules/$1" &&
173 # does core.worktree point at the right place?
174 test "$(git config core.worktree)" = "../../../$1" &&
175 # remove it temporarily before comparing, as
176 # "$1/.git/config" lacks it...
177 git config
--unset core.worktree
179 diff -r ".git/modules/$1" "$1/.git" &&
181 # ... and then restore.
182 cd ".git/modules/$1" &&
183 git config core.worktree
"../../../$1"
187 test_git_directory_exists
() {
188 test -e ".git/modules/$1" &&
191 # does core.worktree point at the right place?
192 test "$(git -C .git/modules/$1 config core.worktree)" = "../../../$1"
196 # Helper function to be executed at the start of every test below, it sets up
197 # the submodule repo if it doesn't exist and configures the most problematic
198 # settings for diff.ignoreSubmodules.
200 (test -d submodule_update_repo || create_lib_submodule_repo
) &&
201 test_config_global
diff.ignoreSubmodules all
&&
202 test_config
diff.ignoreSubmodules all
205 # Helper function to bring work tree back into the state given by the
206 # commit. This includes trying to populate sub1 accordingly if it exists and
207 # should be updated to an existing commit.
208 reset_work_tree_to
() {
209 rm -rf submodule_update
&&
210 git clone
--template= submodule_update_repo submodule_update
&&
212 cd submodule_update
&&
214 git checkout
-f "$1" &&
215 git status
-u -s >actual
&&
216 test_must_be_empty actual
&&
217 hash=$
(git rev-parse
--revs-only HEAD
:sub1
) &&
218 if test -n "$hash" &&
219 test $
(cd "../submodule_update_sub1" && git rev-parse
--verify "$hash^{commit}")
221 git submodule update
--init --recursive "sub1"
226 reset_work_tree_to_interested
() {
227 reset_work_tree_to
$1 &&
228 # make the submodule git dirs available
229 if ! test -d submodule_update
/.git
/modules
/sub1
231 mkdir
-p submodule_update
/.git
/modules
&&
232 cp -r submodule_update_repo
/.git
/modules
/sub1 submodule_update
/.git
/modules
/sub1
233 GIT_WORK_TREE
=. git
-C submodule_update
/.git
/modules
/sub1 config
--unset core.worktree
235 if ! test -d submodule_update
/.git
/modules
/sub
1/modules
/sub2
237 mkdir
-p submodule_update
/.git
/modules
/sub
1/modules
&&
238 cp -r submodule_update_repo
/.git
/modules
/sub
1/modules
/sub2 submodule_update
/.git
/modules
/sub
1/modules
/sub2
239 # core.worktree is unset for sub2 as it is not checked out
241 # indicate we are interested in the submodule:
242 git
-C submodule_update config submodule.sub1.url
"bogus" &&
243 # sub1 might not be checked out, so use the git dir
244 git
-C submodule_update
/.git
/modules
/sub1 config submodule.sub2.url
"bogus"
247 # Test that the superproject contains the content according to commit "$1"
248 # (the work tree must match the index for everything but submodules but the
249 # index must exactly match the given commit including any submodule SHA-1s).
250 test_superproject_content
() {
251 git diff-index
--cached "$1" >actual
&&
252 test_must_be_empty actual
&&
253 git diff-files
--ignore-submodules >actual
&&
254 test_must_be_empty actual
257 # Test that the given submodule at path "$1" contains the content according
258 # to the submodule commit recorded in the superproject's commit "$2"
259 test_submodule_content
() {
260 if test x
"$1" = "x-C"
267 echo "test_submodule_content needs two arguments"
272 test -d "$submodule"/ &&
273 if ! test -f "$submodule"/.git
&& ! test -d "$submodule"/.git
275 echo "Submodule $submodule is not populated"
278 sha1
=$
(git rev-parse
--verify "$commit:$submodule") &&
281 echo "Couldn't retrieve SHA-1 of $submodule for $commit"
286 git status
-u -s >actual
&&
287 test_must_be_empty actual
&&
288 git
diff "$sha1" >actual
&&
289 test_must_be_empty actual
293 # Test that the following transitions are correctly handled:
294 # - Updated submodule
296 # - Removed submodule
297 # - Directory containing tracked files replaced by submodule
298 # - Submodule replaced by tracked files in directory
299 # - Submodule replaced by tracked file with the same name
300 # - Tracked file replaced by submodule
302 # The default is that submodule contents aren't changed until "git submodule
303 # update" is run. And even then that command doesn't delete the work tree of
304 # a removed submodule.
306 # The first argument of the callback function will be the name of the submodule.
308 # Removing a submodule containing a .git directory must fail even when forced
309 # to protect the history! If we are testing this case, the second argument of
310 # the callback function will be 'test_must_fail', else it will be the empty
314 # Internal function; use test_submodule_switch_func(), test_submodule_switch(),
315 # or test_submodule_forced_switch() instead.
316 test_submodule_switch_common
() {
318 ######################### Appearing submodule #########################
319 # Switching to a commit letting a submodule appear creates empty dir ...
320 test_expect_success
"$command: added submodule creates empty directory" '
322 reset_work_tree_to no_submodule &&
324 cd submodule_update &&
325 git branch -t add_sub1 origin/add_sub1 &&
327 test_superproject_content origin/add_sub1 &&
328 test_dir_is_empty sub1 &&
329 git submodule update --init --recursive &&
330 test_submodule_content sub1 origin/add_sub1
333 # ... and doesn't care if it already exists.
334 if test "$KNOWN_FAILURE_STASH_DOES_IGNORE_SUBMODULE_CHANGES" = 1
336 # Restoring stash fails to restore submodule index entry
341 test_expect_
$RESULT "$command: added submodule leaves existing empty directory alone" '
343 reset_work_tree_to no_submodule &&
345 cd submodule_update &&
347 git branch -t add_sub1 origin/add_sub1 &&
349 test_superproject_content origin/add_sub1 &&
350 test_dir_is_empty sub1 &&
351 git submodule update --init --recursive &&
352 test_submodule_content sub1 origin/add_sub1
355 # Replacing a tracked file with a submodule produces an empty
357 test_expect_
$RESULT "$command: replace tracked file with submodule creates empty directory" '
359 reset_work_tree_to replace_sub1_with_file &&
361 cd submodule_update &&
362 git branch -t replace_file_with_sub1 origin/replace_file_with_sub1 &&
363 $command replace_file_with_sub1 &&
364 test_superproject_content origin/replace_file_with_sub1 &&
365 test_dir_is_empty sub1 &&
366 git submodule update --init --recursive &&
367 test_submodule_content sub1 origin/replace_file_with_sub1
370 # ... as does removing a directory with tracked files with a
372 if test "$KNOWN_FAILURE_NOFF_MERGE_DOESNT_CREATE_EMPTY_SUBMODULE_DIR" = 1
374 # Non fast-forward merges fail with "Directory sub1 doesn't
375 # exist. sub1" because the empty submodule directory is not
381 test_expect_
$RESULT "$command: replace directory with submodule" '
383 reset_work_tree_to replace_sub1_with_directory &&
385 cd submodule_update &&
386 git branch -t replace_directory_with_sub1 origin/replace_directory_with_sub1 &&
387 $command replace_directory_with_sub1 &&
388 test_superproject_content origin/replace_directory_with_sub1 &&
389 test_dir_is_empty sub1 &&
390 git submodule update --init --recursive &&
391 test_submodule_content sub1 origin/replace_directory_with_sub1
395 ######################## Disappearing submodule #######################
396 # Removing a submodule doesn't remove its work tree ...
397 if test "$KNOWN_FAILURE_STASH_DOES_IGNORE_SUBMODULE_CHANGES" = 1
403 test_expect_
$RESULT "$command: removed submodule leaves submodule directory and its contents in place" '
405 reset_work_tree_to add_sub1 &&
407 cd submodule_update &&
408 git branch -t remove_sub1 origin/remove_sub1 &&
409 $command remove_sub1 &&
410 test_superproject_content origin/remove_sub1 &&
411 test_submodule_content sub1 origin/add_sub1
414 # ... especially when it contains a .git directory.
415 test_expect_
$RESULT "$command: removed submodule leaves submodule containing a .git directory alone" '
417 reset_work_tree_to add_sub1 &&
419 cd submodule_update &&
420 git branch -t remove_sub1 origin/remove_sub1 &&
421 replace_gitfile_with_git_dir sub1 &&
422 $command remove_sub1 &&
423 test_superproject_content origin/remove_sub1 &&
424 test_git_directory_is_unchanged sub1 &&
425 test_submodule_content sub1 origin/add_sub1
428 # Replacing a submodule with files in a directory must fail as the
429 # submodule work tree isn't removed ...
430 if test "$KNOWN_FAILURE_NOFF_MERGE_ATTEMPTS_TO_MERGE_REMOVED_SUBMODULE_FILES" = 1
432 # Non fast-forward merges attempt to merge the former
433 # submodule files with the newly checked out ones in the
434 # directory of the same name while it shouldn't.
436 elif test "$KNOWN_FAILURE_FORCED_SWITCH_TESTS" = 1
438 # All existing tests that use test_submodule_forced_switch()
444 test_expect_
$RESULT "$command: replace submodule with a directory must fail" '
446 reset_work_tree_to add_sub1 &&
448 cd submodule_update &&
449 git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
450 $command replace_sub1_with_directory test_must_fail &&
451 test_superproject_content origin/add_sub1 &&
452 test_submodule_content sub1 origin/add_sub1
455 # ... especially when it contains a .git directory.
456 test_expect_
$RESULT "$command: replace submodule containing a .git directory with a directory must fail" '
458 reset_work_tree_to add_sub1 &&
460 cd submodule_update &&
461 git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
462 replace_gitfile_with_git_dir sub1 &&
463 $command replace_sub1_with_directory test_must_fail &&
464 test_superproject_content origin/add_sub1 &&
465 test_git_directory_is_unchanged sub1 &&
466 test_submodule_content sub1 origin/add_sub1
469 # Replacing it with a file must fail as it could throw away any local
470 # work tree changes ...
471 test_expect_failure
"$command: replace submodule with a file must fail" '
473 reset_work_tree_to add_sub1 &&
475 cd submodule_update &&
476 git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
477 $command replace_sub1_with_file test_must_fail &&
478 test_superproject_content origin/add_sub1 &&
479 test_submodule_content sub1 origin/add_sub1
482 # ... or even destroy unpushed parts of submodule history if that
483 # still uses a .git directory.
484 test_expect_failure
"$command: replace submodule containing a .git directory with a file must fail" '
486 reset_work_tree_to add_sub1 &&
488 cd submodule_update &&
489 git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
490 replace_gitfile_with_git_dir sub1 &&
491 $command replace_sub1_with_file test_must_fail &&
492 test_superproject_content origin/add_sub1 &&
493 test_git_directory_is_unchanged sub1 &&
494 test_submodule_content sub1 origin/add_sub1
498 ########################## Modified submodule #########################
499 # Updating a submodule sha1 doesn't update the submodule's work tree
500 if test "$KNOWN_FAILURE_CHERRY_PICK_SEES_EMPTY_COMMIT" = 1
502 # When cherry picking a SHA-1 update for an ignored submodule
503 # the commit incorrectly fails with "The previous cherry-pick
504 # is now empty, possibly due to conflict resolution."
509 test_expect_
$RESULT "$command: modified submodule does not update submodule work tree" '
511 reset_work_tree_to add_sub1 &&
513 cd submodule_update &&
514 git branch -t modify_sub1 origin/modify_sub1 &&
515 $command modify_sub1 &&
516 test_superproject_content origin/modify_sub1 &&
517 test_submodule_content sub1 origin/add_sub1 &&
518 git submodule update &&
519 test_submodule_content sub1 origin/modify_sub1
522 # Updating a submodule to an invalid sha1 doesn't update the
523 # submodule's work tree, subsequent update will fail
524 test_expect_
$RESULT "$command: modified submodule does not update submodule work tree to invalid commit" '
526 reset_work_tree_to add_sub1 &&
528 cd submodule_update &&
529 git branch -t invalid_sub1 origin/invalid_sub1 &&
530 $command invalid_sub1 &&
531 test_superproject_content origin/invalid_sub1 &&
532 test_submodule_content sub1 origin/add_sub1 &&
533 test_must_fail git submodule update &&
534 test_submodule_content sub1 origin/add_sub1
537 # Updating a submodule from an invalid sha1 doesn't update the
538 # submodule's work tree, subsequent update will succeed
539 test_expect_
$RESULT "$command: modified submodule does not update submodule work tree from invalid commit" '
541 reset_work_tree_to invalid_sub1 &&
543 cd submodule_update &&
544 git branch -t valid_sub1 origin/valid_sub1 &&
545 $command valid_sub1 &&
546 test_superproject_content origin/valid_sub1 &&
547 test_dir_is_empty sub1 &&
548 git submodule update --init --recursive &&
549 test_submodule_content sub1 origin/valid_sub1
554 # Declares and invokes several tests that, in various situations, checks that
555 # the provided transition function:
556 # - succeeds in updating the worktree and index of a superproject to a target
557 # commit, or fails atomically (depending on the test situation)
558 # - if succeeds, the contents of submodule directories are unchanged
559 # - if succeeds, once "git submodule update" is invoked, the contents of
560 # submodule directories are updated
562 # If the command under test is known to not work with submodules in certain
563 # conditions, set the appropriate KNOWN_FAILURE_* variable used in the tests
566 # The first argument of the callback function will be the name of the submodule.
568 # Removing a submodule containing a .git directory must fail even when forced
569 # to protect the history! If we are testing this case, the second argument of
570 # the callback function will be 'test_must_fail', else it will be the empty
573 # The following example uses `git some-command` as an example command to be
574 # tested. It updates the worktree and index to match a target, but not any
575 # submodule directories.
578 # ...prepare for `git some-command` to be run...
579 # $2 git some-command "$1" &&
584 # ...check the state after git some-command is run...
586 # test_submodule_switch_func "my_func"
587 test_submodule_switch_func
() {
589 test_submodule_switch_common
"$command"
591 # An empty directory does not prevent the creation of a submodule of
592 # the same name, but a file does.
593 test_expect_success
"$command: added submodule doesn't remove untracked unignored file with same name" '
595 reset_work_tree_to no_submodule &&
597 cd submodule_update &&
598 git branch -t add_sub1 origin/add_sub1 &&
600 $command add_sub1 test_must_fail &&
601 test_superproject_content origin/no_submodule &&
602 test_must_be_empty sub1
607 # Ensures that the that the arg either contains "test_must_fail" or is empty.
608 may_only_be_test_must_fail
() {
609 test -z "$1" ||
test "$1" = test_must_fail || die
613 may_only_be_test_must_fail
"$2" &&
617 test_submodule_switch
() {
619 test_submodule_switch_func
"git_test_func"
622 # Same as test_submodule_switch(), except that throwing away local changes in
623 # the superproject is allowed.
624 test_submodule_forced_switch
() {
626 command="git_test_func"
627 KNOWN_FAILURE_FORCED_SWITCH_TESTS
=1
628 test_submodule_switch_common
"$command"
630 # When forced, a file in the superproject does not prevent creating a
631 # submodule of the same name.
632 test_expect_success
"$command: added submodule does remove untracked unignored file with same name when forced" '
634 reset_work_tree_to no_submodule &&
636 cd submodule_update &&
637 git branch -t add_sub1 origin/add_sub1 &&
640 test_superproject_content origin/add_sub1 &&
641 test_dir_is_empty sub1
646 # Test that submodule contents are correctly updated when switching
647 # between commits that change a submodule.
648 # Test that the following transitions are correctly handled:
649 # (These tests are also above in the case where we expect no change
651 # - Updated submodule
653 # - Removed submodule
654 # - Directory containing tracked files replaced by submodule
655 # - Submodule replaced by tracked files in directory
656 # - Submodule replaced by tracked file with the same name
657 # - Tracked file replaced by submodule
660 # - Removing a submodule with a git directory absorbs the submodules
661 # git directory first into the superproject.
662 # - Switching from no submodule to nested submodules
663 # - Switching from nested submodules to no submodule
665 # Internal function; use test_submodule_switch_recursing_with_args() or
666 # test_submodule_forced_switch_recursing_with_args() instead.
667 test_submodule_recursing_with_args_common
() {
668 command="$1 --recurse-submodules"
670 ######################### Appearing submodule #########################
671 # Switching to a commit letting a submodule appear checks it out ...
672 test_expect_success
"$command: added submodule is checked out" '
674 reset_work_tree_to_interested no_submodule &&
676 cd submodule_update &&
677 git branch -t add_sub1 origin/add_sub1 &&
679 test_superproject_content origin/add_sub1 &&
680 test_submodule_content sub1 origin/add_sub1
683 # ... ignoring an empty existing directory.
684 test_expect_success
"$command: added submodule is checked out in empty dir" '
686 reset_work_tree_to_interested no_submodule &&
688 cd submodule_update &&
690 git branch -t add_sub1 origin/add_sub1 &&
692 test_superproject_content origin/add_sub1 &&
693 test_submodule_content sub1 origin/add_sub1
697 # Replacing a tracked file with a submodule produces a checked out submodule
698 test_expect_success
"$command: replace tracked file with submodule checks out submodule" '
700 reset_work_tree_to_interested replace_sub1_with_file &&
702 cd submodule_update &&
703 git branch -t replace_file_with_sub1 origin/replace_file_with_sub1 &&
704 $command replace_file_with_sub1 &&
705 test_superproject_content origin/replace_file_with_sub1 &&
706 test_submodule_content sub1 origin/replace_file_with_sub1
709 # ... as does removing a directory with tracked files with a submodule.
710 test_expect_success
"$command: replace directory with submodule" '
712 reset_work_tree_to_interested replace_sub1_with_directory &&
714 cd submodule_update &&
715 git branch -t replace_directory_with_sub1 origin/replace_directory_with_sub1 &&
716 $command replace_directory_with_sub1 &&
717 test_superproject_content origin/replace_directory_with_sub1 &&
718 test_submodule_content sub1 origin/replace_directory_with_sub1
721 # Switching to a commit with nested submodules recursively checks them out
722 test_expect_success
"$command: nested submodules are checked out" '
724 reset_work_tree_to_interested no_submodule &&
726 cd submodule_update &&
727 git branch -t modify_sub1_recursively origin/modify_sub1_recursively &&
728 $command modify_sub1_recursively &&
729 test_superproject_content origin/modify_sub1_recursively &&
730 test_submodule_content sub1 origin/modify_sub1_recursively &&
731 test_submodule_content -C sub1 sub2 origin/modify_sub1_recursively
735 ######################## Disappearing submodule #######################
736 # Removing a submodule removes its work tree ...
737 test_expect_success
"$command: removed submodule removes submodules working tree" '
739 reset_work_tree_to_interested add_sub1 &&
741 cd submodule_update &&
742 git branch -t remove_sub1 origin/remove_sub1 &&
743 $command remove_sub1 &&
744 test_superproject_content origin/remove_sub1 &&
746 test_must_fail git config -f .git/modules/sub1/config core.worktree
749 # ... absorbing a .git directory along the way.
750 test_expect_success
"$command: removed submodule absorbs submodules .git directory" '
752 reset_work_tree_to_interested add_sub1 &&
754 cd submodule_update &&
755 git branch -t remove_sub1 origin/remove_sub1 &&
756 replace_gitfile_with_git_dir sub1 &&
757 rm -rf .git/modules &&
758 $command remove_sub1 &&
759 test_superproject_content origin/remove_sub1 &&
761 test_git_directory_exists sub1
765 # Replacing it with a file ...
766 test_expect_success
"$command: replace submodule with a file" '
768 reset_work_tree_to_interested add_sub1 &&
770 cd submodule_update &&
771 git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
772 $command replace_sub1_with_file &&
773 test_superproject_content origin/replace_sub1_with_file &&
778 if test "$KNOWN_FAILURE_DIRECTORY_SUBMODULE_CONFLICTS" = 1
782 # ... must check its local work tree for untracked files
783 test_expect_
$RESULTDS "$command: replace submodule with a file must fail with untracked files" '
785 reset_work_tree_to_interested add_sub1 &&
787 cd submodule_update &&
788 git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
789 : >sub1/untrackedfile &&
790 test_must_fail $command replace_sub1_with_file &&
791 test_superproject_content origin/add_sub1 &&
792 test_submodule_content sub1 origin/add_sub1 &&
793 test -f sub1/untracked_file
797 # Switching to a commit without nested submodules removes their worktrees
798 test_expect_success
"$command: worktrees of nested submodules are removed" '
800 reset_work_tree_to_interested add_nested_sub &&
802 cd submodule_update &&
803 git branch -t no_submodule origin/no_submodule &&
804 $command no_submodule &&
805 test_superproject_content origin/no_submodule &&
806 ! test_path_is_dir sub1 &&
807 test_must_fail git config -f .git/modules/sub1/config core.worktree &&
808 test_must_fail git config -f .git/modules/sub1/modules/sub2/config core.worktree
812 ########################## Modified submodule #########################
813 # Updating a submodule sha1 updates the submodule's work tree
814 test_expect_success
"$command: modified submodule updates submodule work tree" '
816 reset_work_tree_to_interested add_sub1 &&
818 cd submodule_update &&
819 git branch -t modify_sub1 origin/modify_sub1 &&
820 $command modify_sub1 &&
821 test_superproject_content origin/modify_sub1 &&
822 test_submodule_content sub1 origin/modify_sub1
825 # Updating a submodule to an invalid sha1 doesn't update the
826 # superproject nor the submodule's work tree.
827 test_expect_success
"$command: updating to a missing submodule commit fails" '
829 reset_work_tree_to_interested add_sub1 &&
831 cd submodule_update &&
832 git branch -t invalid_sub1 origin/invalid_sub1 &&
833 test_must_fail $command invalid_sub1 2>err &&
834 test_i18ngrep sub1 err &&
835 test_superproject_content origin/add_sub1 &&
836 test_submodule_content sub1 origin/add_sub1
839 # Updating a submodule does not touch the currently checked out branch in the submodule
840 test_expect_success
"$command: submodule branch is not changed, detach HEAD instead" '
842 reset_work_tree_to_interested add_sub1 &&
844 cd submodule_update &&
845 git -C sub1 checkout -b keep_branch &&
846 git -C sub1 rev-parse HEAD >expect &&
847 git branch -t modify_sub1 origin/modify_sub1 &&
848 $command modify_sub1 &&
849 test_superproject_content origin/modify_sub1 &&
850 test_submodule_content sub1 origin/modify_sub1 &&
851 git -C sub1 rev-parse keep_branch >actual &&
852 test_cmp expect actual &&
853 test_must_fail git -C sub1 symbolic-ref HEAD
858 # Declares and invokes several tests that, in various situations, checks that
859 # the provided Git command, when invoked with --recurse-submodules:
860 # - succeeds in updating the worktree and index of a superproject to a target
861 # commit, or fails atomically (depending on the test situation)
862 # - if succeeds, the contents of submodule directories are updated
864 # Specify the Git command so that "git $GIT_COMMAND --recurse-submodules"
867 # If the command under test is known to not work with submodules in certain
868 # conditions, set the appropriate KNOWN_FAILURE_* variable used in the tests
873 # test_submodule_switch_recursing_with_args "$GIT_COMMAND"
874 test_submodule_switch_recursing_with_args
() {
876 command="git $cmd_args"
877 test_submodule_recursing_with_args_common
"$command"
880 if test "$KNOWN_FAILURE_DIRECTORY_SUBMODULE_CONFLICTS" = 1
885 if test "$KNOWN_FAILURE_SUBMODULE_OVERWRITE_IGNORED_UNTRACKED" = 1
889 # Switching to a commit letting a submodule appear cannot override an
891 test_expect_success
"$command: added submodule doesn't remove untracked file with same name" '
893 reset_work_tree_to_interested no_submodule &&
895 cd submodule_update &&
896 git branch -t add_sub1 origin/add_sub1 &&
898 test_must_fail $command add_sub1 &&
899 test_superproject_content origin/no_submodule &&
900 test_must_be_empty sub1
903 # ... but an ignored file is fine.
904 test_expect_
$RESULTOI "$command: added submodule removes an untracked ignored file" '
905 test_when_finished "rm -rf submodule_update/.git/info" &&
907 reset_work_tree_to_interested no_submodule &&
909 cd submodule_update &&
910 git branch -t add_sub1 origin/add_sub1 &&
913 echo sub1 >.git/info/exclude &&
915 test_superproject_content origin/add_sub1 &&
916 test_submodule_content sub1 origin/add_sub1
920 # Replacing a submodule with files in a directory must succeeds
921 # when the submodule is clean
922 test_expect_
$RESULTDS "$command: replace submodule with a directory" '
924 reset_work_tree_to_interested add_sub1 &&
926 cd submodule_update &&
927 git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
928 $command replace_sub1_with_directory &&
929 test_superproject_content origin/replace_sub1_with_directory &&
930 test_submodule_content sub1 origin/replace_sub1_with_directory
933 # ... absorbing a .git directory.
934 test_expect_
$RESULTDS "$command: replace submodule containing a .git directory with a directory must absorb the git dir" '
936 reset_work_tree_to_interested add_sub1 &&
938 cd submodule_update &&
939 git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
940 replace_gitfile_with_git_dir sub1 &&
941 rm -rf .git/modules &&
942 $command replace_sub1_with_directory &&
943 test_superproject_content origin/replace_sub1_with_directory &&
944 test_git_directory_exists sub1
948 # ... and ignored files are ignored
949 test_expect_success
"$command: replace submodule with a file works ignores ignored files in submodule" '
950 test_when_finished "rm submodule_update/.git/modules/sub1/info/exclude" &&
952 reset_work_tree_to_interested add_sub1 &&
954 cd submodule_update &&
955 rm -rf .git/modules/sub1/info &&
956 git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
957 mkdir .git/modules/sub1/info &&
958 echo ignored >.git/modules/sub1/info/exclude &&
960 $command replace_sub1_with_file &&
961 test_superproject_content origin/replace_sub1_with_file &&
966 test_expect_success
"git -c submodule.recurse=true $cmd_args: modified submodule updates submodule work tree" '
968 reset_work_tree_to_interested add_sub1 &&
970 cd submodule_update &&
971 git branch -t modify_sub1 origin/modify_sub1 &&
972 git -c submodule.recurse=true $cmd_args modify_sub1 &&
973 test_superproject_content origin/modify_sub1 &&
974 test_submodule_content sub1 origin/modify_sub1
978 test_expect_success
"$command: modified submodule updates submodule recursively" '
980 reset_work_tree_to_interested add_nested_sub &&
982 cd submodule_update &&
983 git branch -t modify_sub1_recursively origin/modify_sub1_recursively &&
984 $command modify_sub1_recursively &&
985 test_superproject_content origin/modify_sub1_recursively &&
986 test_submodule_content sub1 origin/modify_sub1_recursively &&
987 test_submodule_content -C sub1 sub2 origin/modify_sub1_recursively
992 # Same as test_submodule_switch_recursing_with_args(), except that throwing
993 # away local changes in the superproject is allowed.
994 test_submodule_forced_switch_recursing_with_args
() {
996 command="git $cmd_args"
997 test_submodule_recursing_with_args_common
"$command"
1000 if test "$KNOWN_FAILURE_DIRECTORY_SUBMODULE_CONFLICTS" = 1
1004 # Switching to a commit letting a submodule appear does not care about
1005 # an untracked file.
1006 test_expect_success
"$command: added submodule does remove untracked unignored file with same name when forced" '
1008 reset_work_tree_to_interested no_submodule &&
1010 cd submodule_update &&
1011 git branch -t add_sub1 origin/add_sub1 &&
1013 $command add_sub1 &&
1014 test_superproject_content origin/add_sub1 &&
1015 test_submodule_content sub1 origin/add_sub1
1019 # Replacing a submodule with files in a directory ...
1020 test_expect_success
"$command: replace submodule with a directory" '
1022 reset_work_tree_to_interested add_sub1 &&
1024 cd submodule_update &&
1025 git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
1026 $command replace_sub1_with_directory &&
1027 test_superproject_content origin/replace_sub1_with_directory
1030 # ... absorbing a .git directory.
1031 test_expect_success
"$command: replace submodule containing a .git directory with a directory must fail" '
1033 reset_work_tree_to_interested add_sub1 &&
1035 cd submodule_update &&
1036 git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
1037 replace_gitfile_with_git_dir sub1 &&
1038 rm -rf .git/modules/sub1 &&
1039 $command replace_sub1_with_directory &&
1040 test_superproject_content origin/replace_sub1_with_directory &&
1041 test_git_directory_exists sub1
1045 # ... even if the submodule contains ignored files
1046 test_expect_success
"$command: replace submodule with a file ignoring ignored files" '
1048 reset_work_tree_to_interested add_sub1 &&
1050 cd submodule_update &&
1051 git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
1053 $command replace_sub1_with_file &&
1054 test_superproject_content origin/replace_sub1_with_file
1058 # Updating a submodule from an invalid sha1 updates
1059 test_expect_success
"$command: modified submodule does update submodule work tree from invalid commit" '
1061 reset_work_tree_to_interested invalid_sub1 &&
1063 cd submodule_update &&
1064 git branch -t valid_sub1 origin/valid_sub1 &&
1065 $command valid_sub1 &&
1066 test_superproject_content origin/valid_sub1 &&
1067 test_submodule_content sub1 origin/valid_sub1
1071 # Old versions of Git were buggy writing the .git link file
1072 # (e.g. before f8eaa0ba98b and then moving the superproject repo
1073 # whose submodules contained absolute paths)
1074 test_expect_success
"$command: updating submodules fixes .git links" '
1076 reset_work_tree_to_interested add_sub1 &&
1078 cd submodule_update &&
1079 git branch -t modify_sub1 origin/modify_sub1 &&
1080 echo "gitdir: bogus/path" >sub1/.git &&
1081 $command modify_sub1 &&
1082 test_superproject_content origin/modify_sub1 &&
1083 test_submodule_content sub1 origin/modify_sub1
1087 test_expect_success
"$command: changed submodule worktree is reset" '
1089 reset_work_tree_to_interested add_sub1 &&
1091 cd submodule_update &&
1094 git -C sub1 add new_file &&
1096 test_path_is_file sub1/file1 &&
1097 test_path_is_missing sub1/new_file