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 echo "expect" >>.gitignore
&&
67 echo "actual" >>.gitignore
&&
70 git add .gitignore file1 file2
&&
71 git commit
-m "Base" &&
72 git branch
"no_submodule" &&
74 git checkout
-b "add_sub1" &&
75 git submodule add ..
/submodule_update_sub1 sub1
&&
76 git submodule add ..
/submodule_update_sub1 uninitialized_sub
&&
77 git config
-f .gitmodules submodule.sub1.ignore all
&&
78 git config submodule.sub1.ignore all
&&
79 git add .gitmodules
&&
80 git commit
-m "Add sub1" &&
82 git checkout
-b remove_sub1 add_sub1
&&
85 git checkout
-b modify_sub1 add_sub1
&&
86 git submodule update
&&
90 git checkout
-b "modifications" &&
93 git add file2 file3
&&
94 git commit
-m "modified file2 and added file3" &&
95 git push origin modifications
98 git commit
-m "Modify sub1" &&
100 git checkout
-b add_nested_sub modify_sub1
&&
101 git
-C sub1 checkout
-b "add_nested_sub" &&
102 git
-C sub1 submodule add
--branch no_submodule ..
/submodule_update_sub2 sub2
&&
103 git
-C sub1 commit
-a -m "add a nested submodule" &&
105 git commit
-a -m "update submodule, that updates a nested submodule" &&
106 git checkout
-b modify_sub1_recursively
&&
107 git
-C sub1 checkout
-b modify_sub1_recursively
&&
108 git
-C sub
1/sub2 checkout
-b modify_sub1_recursively
&&
109 echo change
>sub
1/sub
2/file3
&&
110 git
-C sub
1/sub2 add file3
&&
111 git
-C sub
1/sub2 commit
-m "make a change in nested sub" &&
112 git
-C sub1 add sub2
&&
113 git
-C sub1 commit
-m "update nested sub" &&
115 git commit
-m "update sub1, that updates nested sub" &&
116 git
-C sub1 push origin modify_sub1_recursively
&&
117 git
-C sub
1/sub2 push origin modify_sub1_recursively
&&
118 git
-C sub1 submodule deinit
-f --all &&
120 git checkout
-b replace_sub1_with_directory add_sub1
&&
121 git submodule update
&&
122 git
-C sub1 checkout modifications
&&
123 git
rm --cached sub1
&&
125 git config
-f .gitmodules
--remove-section "submodule.sub1" &&
126 git add .gitmodules sub
1/* &&
127 git commit
-m "Replace sub1 with directory" &&
129 git checkout
-b replace_directory_with_sub1
&&
132 git checkout
-b replace_sub1_with_file add_sub1
&&
134 echo "content" >sub1
&&
136 git commit
-m "Replace sub1 with file" &&
138 git checkout
-b replace_file_with_sub1
&&
141 git checkout
-b invalid_sub1 add_sub1
&&
142 git update-index
--cacheinfo 160000 $
(test_oid numeric
) sub1
&&
143 git commit
-m "Invalid sub1 commit" &&
144 git checkout
-b valid_sub1
&&
151 # Helper function to replace gitfile with .git directory
152 replace_gitfile_with_git_dir
() {
155 git_dir
="$(git rev-parse --git-dir)" &&
157 cp -R "$git_dir" .git
&&
158 GIT_WORK_TREE
=. git config
--unset core.worktree
162 # Test that the .git directory in the submodule is unchanged (except for the
163 # core.worktree setting, which appears only in $GIT_DIR/modules/$1/config).
164 # Call this function before test_submodule_content as the latter might
165 # write the index file leading to false positive index differences.
167 # Note that this only supports submodules at the root level of the
168 # superproject, with the default name, i.e. same as its path.
169 test_git_directory_is_unchanged
() {
171 cd ".git/modules/$1" &&
172 # does core.worktree point at the right place?
173 test "$(git config core.worktree)" = "../../../$1" &&
174 # remove it temporarily before comparing, as
175 # "$1/.git/config" lacks it...
176 git config
--unset core.worktree
178 diff -r ".git/modules/$1" "$1/.git" &&
180 # ... and then restore.
181 cd ".git/modules/$1" &&
182 git config core.worktree
"../../../$1"
186 test_git_directory_exists
() {
187 test -e ".git/modules/$1" &&
190 # does core.worktree point at the right place?
191 test "$(git -C .git/modules/$1 config core.worktree)" = "../../../$1"
195 # Helper function to be executed at the start of every test below, it sets up
196 # the submodule repo if it doesn't exist and configures the most problematic
197 # 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 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 if test "$KNOWN_FAILURE_STASH_DOES_IGNORE_SUBMODULE_CHANGES" = 1
322 # Restoring stash fails to restore submodule index entry
327 test_expect_
$RESULT "$command: added submodule creates empty directory" '
329 reset_work_tree_to no_submodule &&
331 cd submodule_update &&
332 git branch -t add_sub1 origin/add_sub1 &&
334 test_superproject_content origin/add_sub1 &&
335 test_dir_is_empty sub1 &&
336 git submodule update --init --recursive &&
337 test_submodule_content sub1 origin/add_sub1
340 # ... and doesn't care if it already exists.
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.
663 # Internal function; use test_submodule_switch_recursing_with_args() or
664 # test_submodule_forced_switch_recursing_with_args() instead.
665 test_submodule_recursing_with_args_common
() {
666 command="$1 --recurse-submodules"
668 ######################### Appearing submodule #########################
669 # Switching to a commit letting a submodule appear checks it out ...
670 test_expect_success
"$command: added submodule is checked out" '
672 reset_work_tree_to_interested no_submodule &&
674 cd submodule_update &&
675 git branch -t add_sub1 origin/add_sub1 &&
677 test_superproject_content origin/add_sub1 &&
678 test_submodule_content sub1 origin/add_sub1
681 # ... ignoring an empty existing directory.
682 test_expect_success
"$command: added submodule is checked out in empty dir" '
684 reset_work_tree_to_interested no_submodule &&
686 cd submodule_update &&
688 git branch -t add_sub1 origin/add_sub1 &&
690 test_superproject_content origin/add_sub1 &&
691 test_submodule_content sub1 origin/add_sub1
694 test_expect_success
"$command: submodule branch is not changed, detach HEAD instead" '
696 reset_work_tree_to_interested add_sub1 &&
698 cd submodule_update &&
699 git -C sub1 checkout -b keep_branch &&
700 git -C sub1 rev-parse HEAD >expect &&
701 git branch -t modify_sub1 origin/modify_sub1 &&
702 $command modify_sub1 &&
703 test_superproject_content origin/modify_sub1 &&
704 test_submodule_content sub1 origin/modify_sub1 &&
705 git -C sub1 rev-parse keep_branch >actual &&
706 test_cmp expect actual &&
707 test_must_fail git -C sub1 symbolic-ref HEAD
711 # Replacing a tracked file with a submodule produces a checked out submodule
712 test_expect_success
"$command: replace tracked file with submodule checks out submodule" '
714 reset_work_tree_to_interested replace_sub1_with_file &&
716 cd submodule_update &&
717 git branch -t replace_file_with_sub1 origin/replace_file_with_sub1 &&
718 $command replace_file_with_sub1 &&
719 test_superproject_content origin/replace_file_with_sub1 &&
720 test_submodule_content sub1 origin/replace_file_with_sub1
723 # ... as does removing a directory with tracked files with a submodule.
724 test_expect_success
"$command: replace directory with submodule" '
726 reset_work_tree_to_interested replace_sub1_with_directory &&
728 cd submodule_update &&
729 git branch -t replace_directory_with_sub1 origin/replace_directory_with_sub1 &&
730 $command replace_directory_with_sub1 &&
731 test_superproject_content origin/replace_directory_with_sub1 &&
732 test_submodule_content sub1 origin/replace_directory_with_sub1
736 ######################## Disappearing submodule #######################
737 # Removing a submodule removes its work tree ...
738 test_expect_success
"$command: removed submodule removes submodules working tree" '
740 reset_work_tree_to_interested add_sub1 &&
742 cd submodule_update &&
743 git branch -t remove_sub1 origin/remove_sub1 &&
744 $command remove_sub1 &&
745 test_superproject_content origin/remove_sub1 &&
747 test_must_fail git config -f .git/modules/sub1/config core.worktree
750 # ... absorbing a .git directory along the way.
751 test_expect_success
"$command: removed submodule absorbs submodules .git directory" '
753 reset_work_tree_to_interested add_sub1 &&
755 cd submodule_update &&
756 git branch -t remove_sub1 origin/remove_sub1 &&
757 replace_gitfile_with_git_dir sub1 &&
758 rm -rf .git/modules &&
759 $command remove_sub1 &&
760 test_superproject_content origin/remove_sub1 &&
762 test_git_directory_exists sub1
766 # Replacing it with a file ...
767 test_expect_success
"$command: replace submodule with a file" '
769 reset_work_tree_to_interested add_sub1 &&
771 cd submodule_update &&
772 git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
773 $command replace_sub1_with_file &&
774 test_superproject_content origin/replace_sub1_with_file &&
779 if test "$KNOWN_FAILURE_DIRECTORY_SUBMODULE_CONFLICTS" = 1
783 # ... must check its local work tree for untracked files
784 test_expect_
$RESULTDS "$command: replace submodule with a file must fail with untracked files" '
786 reset_work_tree_to_interested add_sub1 &&
788 cd submodule_update &&
789 git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
790 : >sub1/untrackedfile &&
791 test_must_fail $command replace_sub1_with_file &&
792 test_superproject_content origin/add_sub1 &&
793 test_submodule_content sub1 origin/add_sub1 &&
794 test -f sub1/untracked_file
798 ########################## Modified submodule #########################
799 # Updating a submodule sha1 updates the submodule's work tree
800 test_expect_success
"$command: modified submodule updates submodule work tree" '
802 reset_work_tree_to_interested add_sub1 &&
804 cd submodule_update &&
805 git branch -t modify_sub1 origin/modify_sub1 &&
806 $command modify_sub1 &&
807 test_superproject_content origin/modify_sub1 &&
808 test_submodule_content sub1 origin/modify_sub1
811 # Updating a submodule to an invalid sha1 doesn't update the
812 # superproject nor the submodule's work tree.
813 test_expect_success
"$command: updating to a missing submodule commit fails" '
815 reset_work_tree_to_interested add_sub1 &&
817 cd submodule_update &&
818 git branch -t invalid_sub1 origin/invalid_sub1 &&
819 test_must_fail $command invalid_sub1 2>err &&
820 test_i18ngrep sub1 err &&
821 test_superproject_content origin/add_sub1 &&
822 test_submodule_content sub1 origin/add_sub1
827 # Declares and invokes several tests that, in various situations, checks that
828 # the provided Git command, when invoked with --recurse-submodules:
829 # - succeeds in updating the worktree and index of a superproject to a target
830 # commit, or fails atomically (depending on the test situation)
831 # - if succeeds, the contents of submodule directories are updated
833 # Specify the Git command so that "git $GIT_COMMAND --recurse-submodules"
836 # If the command under test is known to not work with submodules in certain
837 # conditions, set the appropriate KNOWN_FAILURE_* variable used in the tests
842 # test_submodule_switch_recursing_with_args "$GIT_COMMAND"
843 test_submodule_switch_recursing_with_args
() {
845 command="git $cmd_args"
846 test_submodule_recursing_with_args_common
"$command"
849 if test "$KNOWN_FAILURE_DIRECTORY_SUBMODULE_CONFLICTS" = 1
854 if test "$KNOWN_FAILURE_SUBMODULE_OVERWRITE_IGNORED_UNTRACKED" = 1
858 # Switching to a commit letting a submodule appear cannot override an
860 test_expect_success
"$command: added submodule doesn't remove untracked file with same name" '
862 reset_work_tree_to_interested no_submodule &&
864 cd submodule_update &&
865 git branch -t add_sub1 origin/add_sub1 &&
867 test_must_fail $command add_sub1 &&
868 test_superproject_content origin/no_submodule &&
869 test_must_be_empty sub1
872 # ... but an ignored file is fine.
873 test_expect_
$RESULTOI "$command: added submodule removes an untracked ignored file" '
874 test_when_finished "rm submodule_update/.git/info/exclude" &&
876 reset_work_tree_to_interested no_submodule &&
878 cd submodule_update &&
879 git branch -t add_sub1 origin/add_sub1 &&
881 echo sub1 >.git/info/exclude &&
883 test_superproject_content origin/add_sub1 &&
884 test_submodule_content sub1 origin/add_sub1
888 # Replacing a submodule with files in a directory must succeeds
889 # when the submodule is clean
890 test_expect_
$RESULTDS "$command: replace submodule with a directory" '
892 reset_work_tree_to_interested add_sub1 &&
894 cd submodule_update &&
895 git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
896 $command replace_sub1_with_directory &&
897 test_superproject_content origin/replace_sub1_with_directory &&
898 test_submodule_content sub1 origin/replace_sub1_with_directory
901 # ... absorbing a .git directory.
902 test_expect_
$RESULTDS "$command: replace submodule containing a .git directory with a directory must absorb the git dir" '
904 reset_work_tree_to_interested add_sub1 &&
906 cd submodule_update &&
907 git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
908 replace_gitfile_with_git_dir sub1 &&
909 rm -rf .git/modules &&
910 $command replace_sub1_with_directory &&
911 test_superproject_content origin/replace_sub1_with_directory &&
912 test_git_directory_exists sub1
916 # ... and ignored files are ignored
917 test_expect_success
"$command: replace submodule with a file works ignores ignored files in submodule" '
918 test_when_finished "rm submodule_update/.git/modules/sub1/info/exclude" &&
920 reset_work_tree_to_interested add_sub1 &&
922 cd submodule_update &&
923 git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
924 echo ignored >.git/modules/sub1/info/exclude &&
926 $command replace_sub1_with_file &&
927 test_superproject_content origin/replace_sub1_with_file &&
932 test_expect_success
"git -c submodule.recurse=true $cmd_args: modified submodule updates submodule work tree" '
934 reset_work_tree_to_interested add_sub1 &&
936 cd submodule_update &&
937 git branch -t modify_sub1 origin/modify_sub1 &&
938 git -c submodule.recurse=true $cmd_args modify_sub1 &&
939 test_superproject_content origin/modify_sub1 &&
940 test_submodule_content sub1 origin/modify_sub1
944 # recursing deeper than one level doesn't work yet.
945 test_expect_success
"$command: modified submodule updates submodule recursively" '
947 reset_work_tree_to_interested add_nested_sub &&
949 cd submodule_update &&
950 git branch -t modify_sub1_recursively origin/modify_sub1_recursively &&
951 $command modify_sub1_recursively &&
952 test_superproject_content origin/modify_sub1_recursively &&
953 test_submodule_content sub1 origin/modify_sub1_recursively &&
954 test_submodule_content -C sub1 sub2 origin/modify_sub1_recursively
959 # Same as test_submodule_switch_recursing_with_args(), except that throwing
960 # away local changes in the superproject is allowed.
961 test_submodule_forced_switch_recursing_with_args
() {
963 command="git $cmd_args"
964 test_submodule_recursing_with_args_common
"$command"
967 if test "$KNOWN_FAILURE_DIRECTORY_SUBMODULE_CONFLICTS" = 1
971 # Switching to a commit letting a submodule appear does not care about
973 test_expect_success
"$command: added submodule does remove untracked unignored file with same name when forced" '
975 reset_work_tree_to_interested no_submodule &&
977 cd submodule_update &&
978 git branch -t add_sub1 origin/add_sub1 &&
981 test_superproject_content origin/add_sub1 &&
982 test_submodule_content sub1 origin/add_sub1
986 # Replacing a submodule with files in a directory ...
987 test_expect_success
"$command: replace submodule with a directory" '
989 reset_work_tree_to_interested add_sub1 &&
991 cd submodule_update &&
992 git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
993 $command replace_sub1_with_directory &&
994 test_superproject_content origin/replace_sub1_with_directory
997 # ... absorbing a .git directory.
998 test_expect_success
"$command: replace submodule containing a .git directory with a directory must fail" '
1000 reset_work_tree_to_interested add_sub1 &&
1002 cd submodule_update &&
1003 git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
1004 replace_gitfile_with_git_dir sub1 &&
1005 rm -rf .git/modules/sub1 &&
1006 $command replace_sub1_with_directory &&
1007 test_superproject_content origin/replace_sub1_with_directory &&
1008 test_git_directory_exists sub1
1012 # ... even if the submodule contains ignored files
1013 test_expect_success
"$command: replace submodule with a file ignoring ignored files" '
1015 reset_work_tree_to_interested add_sub1 &&
1017 cd submodule_update &&
1018 git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
1020 $command replace_sub1_with_file &&
1021 test_superproject_content origin/replace_sub1_with_file
1025 # Updating a submodule from an invalid sha1 updates
1026 test_expect_success
"$command: modified submodule does update submodule work tree from invalid commit" '
1028 reset_work_tree_to_interested invalid_sub1 &&
1030 cd submodule_update &&
1031 git branch -t valid_sub1 origin/valid_sub1 &&
1032 $command valid_sub1 &&
1033 test_superproject_content origin/valid_sub1 &&
1034 test_submodule_content sub1 origin/valid_sub1
1038 # Old versions of Git were buggy writing the .git link file
1039 # (e.g. before f8eaa0ba98b and then moving the superproject repo
1040 # whose submodules contained absolute paths)
1041 test_expect_success
"$command: updating submodules fixes .git links" '
1043 reset_work_tree_to_interested add_sub1 &&
1045 cd submodule_update &&
1046 git branch -t modify_sub1 origin/modify_sub1 &&
1047 echo "gitdir: bogus/path" >sub1/.git &&
1048 $command modify_sub1 &&
1049 test_superproject_content origin/modify_sub1 &&
1050 test_submodule_content sub1 origin/modify_sub1
1054 test_expect_success
"$command: changed submodule worktree is reset" '
1056 reset_work_tree_to_interested add_sub1 &&
1058 cd submodule_update &&
1061 git -C sub1 add new_file &&
1063 test_path_is_file sub1/file1 &&
1064 test_path_is_missing sub1/new_file