Merge branch 'jl/submodule-tests'
authorJunio C Hamano <gitster@pobox.com>
Mon, 21 Jul 2014 18:18:30 +0000 (11:18 -0700)
committerJunio C Hamano <gitster@pobox.com>
Mon, 21 Jul 2014 18:18:31 +0000 (11:18 -0700)
* jl/submodule-tests:
revert: add t3513 for submodule updates
stash: add t3906 for submodule updates
am: add t4255 for submodule updates
cherry-pick: add t3512 for submodule updates
pull: add t5572 for submodule updates
rebase: add t3426 for submodule updates
merge: add t7613 for submodule updates
bisect: add t6041 for submodule updates
reset: add t7112 for submodule updates
read-tree: add t1013 for submodule updates
apply: add t4137 for submodule updates
checkout: call the new submodule update test framework
submodules: add the lib-submodule-update.sh test library
test-lib: add test_dir_is_empty()

14 files changed:
t/lib-submodule-update.sh [new file with mode: 0755]
t/t1013-read-tree-submodule.sh [new file with mode: 0755]
t/t2013-checkout-submodule.sh
t/t3426-rebase-submodule.sh [new file with mode: 0755]
t/t3512-cherry-pick-submodule.sh [new file with mode: 0755]
t/t3513-revert-submodule.sh [new file with mode: 0755]
t/t3906-stash-submodule.sh [new file with mode: 0755]
t/t4137-apply-submodule.sh [new file with mode: 0755]
t/t4255-am-submodule.sh [new file with mode: 0755]
t/t5572-pull-submodule.sh [new file with mode: 0755]
t/t6041-bisect-submodule.sh [new file with mode: 0755]
t/t7112-reset-submodule.sh [new file with mode: 0755]
t/t7613-merge-submodule.sh [new file with mode: 0755]
t/test-lib-functions.sh
diff --git a/t/lib-submodule-update.sh b/t/lib-submodule-update.sh
new file mode 100755 (executable)
index 0000000..79cdd34
--- /dev/null
@@ -0,0 +1,680 @@
+# Create a submodule layout used for all tests below.
+#
+# The following use cases are covered:
+# - New submodule (no_submodule => add_sub1)
+# - Removed submodule (add_sub1 => remove_sub1)
+# - Updated submodule (add_sub1 => modify_sub1)
+# - Submodule updated to invalid commit (add_sub1 => invalid_sub1)
+# - Submodule updated from invalid commit (invalid_sub1 => valid_sub1)
+# - Submodule replaced by tracked files in directory (add_sub1 =>
+#   replace_sub1_with_directory)
+# - Directory containing tracked files replaced by submodule
+#   (replace_sub1_with_directory => replace_directory_with_sub1)
+# - Submodule replaced by tracked file with the same name (add_sub1 =>
+#   replace_sub1_with_file)
+# - Tracked file replaced by submodule (replace_sub1_with_file =>
+#   replace_file_with_sub1)
+#
+#                   --O-----O
+#                  /  ^     replace_directory_with_sub1
+#                 /   replace_sub1_with_directory
+#                /----O
+#               /     ^
+#              /      modify_sub1
+#      O------O-------O
+#      ^      ^\      ^
+#      |      | \     remove_sub1
+#      |      |  -----O-----O
+#      |      |   \   ^     replace_file_with_sub1
+#      |      |    \  replace_sub1_with_file
+#      |   add_sub1 --O-----O
+# no_submodule        ^     valid_sub1
+#                     invalid_sub1
+#
+create_lib_submodule_repo () {
+       git init submodule_update_repo &&
+       (
+               cd submodule_update_repo &&
+               echo "expect" >>.gitignore &&
+               echo "actual" >>.gitignore &&
+               echo "x" >file1 &&
+               echo "y" >file2 &&
+               git add .gitignore file1 file2 &&
+               git commit -m "Base" &&
+               git branch "no_submodule" &&
+
+               git checkout -b "add_sub1" &&
+               git submodule add ./. sub1 &&
+               git config -f .gitmodules submodule.sub1.ignore all &&
+               git config submodule.sub1.ignore all &&
+               git add .gitmodules &&
+               git commit -m "Add sub1" &&
+               git checkout -b remove_sub1 &&
+               git revert HEAD &&
+
+               git checkout -b "modify_sub1" "add_sub1" &&
+               git submodule update &&
+               (
+                       cd sub1 &&
+                       git fetch &&
+                       git checkout -b "modifications" &&
+                       echo "z" >file2 &&
+                       echo "x" >file3 &&
+                       git add file2 file3 &&
+                       git commit -m "modified file2 and added file3" &&
+                       git push origin modifications
+               ) &&
+               git add sub1 &&
+               git commit -m "Modify sub1" &&
+
+               git checkout -b "replace_sub1_with_directory" "add_sub1" &&
+               git submodule update &&
+               (
+                       cd sub1 &&
+                       git checkout modifications
+               ) &&
+               git rm --cached sub1 &&
+               rm sub1/.git* &&
+               git config -f .gitmodules --remove-section "submodule.sub1" &&
+               git add .gitmodules sub1/* &&
+               git commit -m "Replace sub1 with directory" &&
+               git checkout -b replace_directory_with_sub1 &&
+               git revert HEAD &&
+
+               git checkout -b "replace_sub1_with_file" "add_sub1" &&
+               git rm sub1 &&
+               echo "content" >sub1 &&
+               git add sub1 &&
+               git commit -m "Replace sub1 with file" &&
+               git checkout -b replace_file_with_sub1 &&
+               git revert HEAD &&
+
+               git checkout -b "invalid_sub1" "add_sub1" &&
+               git update-index --cacheinfo 160000 0123456789012345678901234567890123456789 sub1 &&
+               git commit -m "Invalid sub1 commit" &&
+               git checkout -b valid_sub1 &&
+               git revert HEAD &&
+               git checkout master
+       )
+}
+
+# Helper function to replace gitfile with .git directory
+replace_gitfile_with_git_dir () {
+       (
+               cd "$1" &&
+               git_dir="$(git rev-parse --git-dir)" &&
+               rm -f .git &&
+               cp -R "$git_dir" .git &&
+               GIT_WORK_TREE=. git config --unset core.worktree
+       )
+}
+
+# Test that the .git directory in the submodule is unchanged (except for the
+# core.worktree setting, which appears only in $GIT_DIR/modules/$1/config).
+# Call this function before test_submodule_content as the latter might
+# write the index file leading to false positive index differences.
+#
+# Note that this only supports submodules at the root level of the
+# superproject, with the default name, i.e. same as its path.
+test_git_directory_is_unchanged () {
+       (
+               cd ".git/modules/$1" &&
+               # does core.worktree point at the right place?
+               test "$(git config core.worktree)" = "../../../$1" &&
+               # remove it temporarily before comparing, as
+               # "$1/.git/config" lacks it...
+               git config --unset core.worktree
+       ) &&
+       diff -r ".git/modules/$1" "$1/.git" &&
+       (
+               # ... and then restore.
+               cd ".git/modules/$1" &&
+               git config core.worktree "../../../$1"
+       )
+}
+
+# Helper function to be executed at the start of every test below, it sets up
+# the submodule repo if it doesn't exist and configures the most problematic
+# settings for diff.ignoreSubmodules.
+prolog () {
+       (test -d submodule_update_repo || create_lib_submodule_repo) &&
+       test_config_global diff.ignoreSubmodules all &&
+       test_config diff.ignoreSubmodules all
+}
+
+# Helper function to bring work tree back into the state given by the
+# commit. This includes trying to populate sub1 accordingly if it exists and
+# should be updated to an existing commit.
+reset_work_tree_to () {
+       rm -rf submodule_update &&
+       git clone submodule_update_repo submodule_update &&
+       (
+               cd submodule_update &&
+               rm -rf sub1 &&
+               git checkout -f "$1" &&
+               git status -u -s >actual &&
+               test_must_be_empty actual &&
+               sha1=$(git rev-parse --revs-only HEAD:sub1) &&
+               if test -n "$sha1" &&
+                  test $(cd "sub1" && git rev-parse --verify "$sha1^{commit}")
+               then
+                       git submodule update --init --recursive "sub1"
+               fi
+       )
+}
+
+# Test that the superproject contains the content according to commit "$1"
+# (the work tree must match the index for everything but submodules but the
+# index must exactly match the given commit including any submodule SHA-1s).
+test_superproject_content () {
+       git diff-index --cached "$1" >actual &&
+       test_must_be_empty actual &&
+       git diff-files --ignore-submodules >actual &&
+       test_must_be_empty actual
+}
+
+# Test that the given submodule at path "$1" contains the content according
+# to the submodule commit recorded in the superproject's commit "$2"
+test_submodule_content () {
+       if test $# != 2
+       then
+               echo "test_submodule_content needs two arguments"
+               return 1
+       fi &&
+       submodule="$1" &&
+       commit="$2" &&
+       test -d "$submodule"/ &&
+       if ! test -f "$submodule"/.git && ! test -d "$submodule"/.git
+       then
+               echo "Submodule $submodule is not populated"
+               return 1
+       fi &&
+       sha1=$(git rev-parse --verify "$commit:$submodule") &&
+       if test -z "$sha1"
+       then
+               echo "Couldn't retrieve SHA-1 of $submodule for $commit"
+               return 1
+       fi &&
+       (
+               cd "$submodule" &&
+               git status -u -s >actual &&
+               test_must_be_empty actual &&
+               git diff "$sha1" >actual &&
+               test_must_be_empty actual
+       )
+}
+
+# Test that the following transitions are correctly handled:
+# - Updated submodule
+# - New submodule
+# - Removed submodule
+# - Directory containing tracked files replaced by submodule
+# - Submodule replaced by tracked files in directory
+# - Submodule replaced by tracked file with the same name
+# - tracked file replaced by submodule
+#
+# The default is that submodule contents aren't changed until "git submodule
+# update" is run. And even then that command doesn't delete the work tree of
+# a removed submodule.
+#
+# Removing a submodule containing a .git directory must fail even when forced
+# to protect the history!
+#
+
+# Test that submodule contents are currently not updated when switching
+# between commits that change a submodule.
+test_submodule_switch () {
+       command="$1"
+       ######################### Appearing submodule #########################
+       # Switching to a commit letting a submodule appear creates empty dir ...
+       if test "$KNOWN_FAILURE_STASH_DOES_IGNORE_SUBMODULE_CHANGES" = 1
+       then
+               # Restoring stash fails to restore submodule index entry
+               RESULT="failure"
+       else
+               RESULT="success"
+       fi
+       test_expect_$RESULT "$command: added submodule creates empty directory" '
+               prolog &&
+               reset_work_tree_to no_submodule &&
+               (
+                       cd submodule_update &&
+                       git branch -t add_sub1 origin/add_sub1 &&
+                       $command add_sub1 &&
+                       test_superproject_content origin/add_sub1 &&
+                       test_dir_is_empty sub1 &&
+                       git submodule update --init --recursive &&
+                       test_submodule_content sub1 origin/add_sub1
+               )
+       '
+       # ... and doesn't care if it already exists ...
+       test_expect_$RESULT "$command: added submodule leaves existing empty directory alone" '
+               prolog &&
+               reset_work_tree_to no_submodule &&
+               (
+                       cd submodule_update &&
+                       mkdir sub1 &&
+                       git branch -t add_sub1 origin/add_sub1 &&
+                       $command add_sub1 &&
+                       test_superproject_content origin/add_sub1 &&
+                       test_dir_is_empty sub1 &&
+                       git submodule update --init --recursive &&
+                       test_submodule_content sub1 origin/add_sub1
+               )
+       '
+       # ... unless there is an untracked file in its place.
+       test_expect_success "$command: added submodule doesn't remove untracked unignored file with same name" '
+               prolog &&
+               reset_work_tree_to no_submodule &&
+               (
+                       cd submodule_update &&
+                       git branch -t add_sub1 origin/add_sub1 &&
+                       >sub1 &&
+                       test_must_fail $command add_sub1 &&
+                       test_superproject_content origin/no_submodule &&
+                       test_must_be_empty sub1
+               )
+       '
+       # Replacing a tracked file with a submodule produces an empty
+       # directory ...
+       test_expect_$RESULT "$command: replace tracked file with submodule creates empty directory" '
+               prolog &&
+               reset_work_tree_to replace_sub1_with_file &&
+               (
+                       cd submodule_update &&
+                       git branch -t replace_file_with_sub1 origin/replace_file_with_sub1 &&
+                       $command replace_file_with_sub1 &&
+                       test_superproject_content origin/replace_file_with_sub1 &&
+                       test_dir_is_empty sub1 &&
+                       git submodule update --init --recursive &&
+                       test_submodule_content sub1 origin/replace_file_with_sub1
+               )
+       '
+       # ... as does removing a directory with tracked files with a
+       # submodule.
+       if test "$KNOWN_FAILURE_NOFF_MERGE_DOESNT_CREATE_EMPTY_SUBMODULE_DIR" = 1
+       then
+               # Non fast-forward merges fail with "Directory sub1 doesn't
+               # exist. sub1" because the empty submodule directory is not
+               # created
+               RESULT="failure"
+       else
+               RESULT="success"
+       fi
+       test_expect_$RESULT "$command: replace directory with submodule" '
+               prolog &&
+               reset_work_tree_to replace_sub1_with_directory &&
+               (
+                       cd submodule_update &&
+                       git branch -t replace_directory_with_sub1 origin/replace_directory_with_sub1 &&
+                       $command replace_directory_with_sub1 &&
+                       test_superproject_content origin/replace_directory_with_sub1 &&
+                       test_dir_is_empty sub1 &&
+                       git submodule update --init --recursive &&
+                       test_submodule_content sub1 origin/replace_directory_with_sub1
+               )
+       '
+
+       ######################## Disappearing submodule #######################
+       # Removing a submodule doesn't remove its work tree ...
+       if test "$KNOWN_FAILURE_STASH_DOES_IGNORE_SUBMODULE_CHANGES" = 1
+       then
+               RESULT="failure"
+       else
+               RESULT="success"
+       fi
+       test_expect_$RESULT "$command: removed submodule leaves submodule directory and its contents in place" '
+               prolog &&
+               reset_work_tree_to add_sub1 &&
+               (
+                       cd submodule_update &&
+                       git branch -t remove_sub1 origin/remove_sub1 &&
+                       $command remove_sub1 &&
+                       test_superproject_content origin/remove_sub1 &&
+                       test_submodule_content sub1 origin/add_sub1
+               )
+       '
+       # ... especially when it contains a .git directory.
+       test_expect_$RESULT "$command: removed submodule leaves submodule containing a .git directory alone" '
+               prolog &&
+               reset_work_tree_to add_sub1 &&
+               (
+                       cd submodule_update &&
+                       git branch -t remove_sub1 origin/remove_sub1 &&
+                       replace_gitfile_with_git_dir sub1 &&
+                       $command remove_sub1 &&
+                       test_superproject_content origin/remove_sub1 &&
+                       test_git_directory_is_unchanged sub1 &&
+                       test_submodule_content sub1 origin/add_sub1
+               )
+       '
+       # Replacing a submodule with files in a directory must fail as the
+       # submodule work tree isn't removed ...
+       if test "$KNOWN_FAILURE_NOFF_MERGE_ATTEMPTS_TO_MERGE_REMOVED_SUBMODULE_FILES" = 1
+       then
+               # Non fast-forward merges attempt to merge the former
+               # submodule files with the newly checked out ones in the
+               # directory of the same name while it shouldn't.
+               RESULT="failure"
+       else
+               RESULT="success"
+       fi
+       test_expect_$RESULT "$command: replace submodule with a directory must fail" '
+               prolog &&
+               reset_work_tree_to add_sub1 &&
+               (
+                       cd submodule_update &&
+                       git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
+                       test_must_fail $command replace_sub1_with_directory &&
+                       test_superproject_content origin/add_sub1 &&
+                       test_submodule_content sub1 origin/add_sub1
+               )
+       '
+       # ... especially when it contains a .git directory.
+       test_expect_$RESULT "$command: replace submodule containing a .git directory with a directory must fail" '
+               prolog &&
+               reset_work_tree_to add_sub1 &&
+               (
+                       cd submodule_update &&
+                       git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
+                       replace_gitfile_with_git_dir sub1 &&
+                       test_must_fail $command replace_sub1_with_directory &&
+                       test_superproject_content origin/add_sub1 &&
+                       test_git_directory_is_unchanged sub1 &&
+                       test_submodule_content sub1 origin/add_sub1
+               )
+       '
+       # Replacing it with a file must fail as it could throw away any local
+       # work tree changes ...
+       test_expect_failure "$command: replace submodule with a file must fail" '
+               prolog &&
+               reset_work_tree_to add_sub1 &&
+               (
+                       cd submodule_update &&
+                       git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
+                       test_must_fail $command replace_sub1_with_file &&
+                       test_superproject_content origin/add_sub1 &&
+                       test_submodule_content sub1 origin/add_sub1
+               )
+       '
+       # ... or even destroy unpushed parts of submodule history if that
+       # still uses a .git directory.
+       test_expect_failure "$command: replace submodule containing a .git directory with a file must fail" '
+               prolog &&
+               reset_work_tree_to add_sub1 &&
+               (
+                       cd submodule_update &&
+                       git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
+                       replace_gitfile_with_git_dir sub1 &&
+                       test_must_fail $command replace_sub1_with_file &&
+                       test_superproject_content origin/add_sub1 &&
+                       test_git_directory_is_unchanged sub1 &&
+                       test_submodule_content sub1 origin/add_sub1
+               )
+       '
+
+       ########################## Modified submodule #########################
+       # Updating a submodule sha1 doesn't update the submodule's work tree
+       if test "$KNOWN_FAILURE_CHERRY_PICK_SEES_EMPTY_COMMIT" = 1
+       then
+               # When cherry picking a SHA-1 update for an ignored submodule
+               # the commit incorrectly fails with "The previous cherry-pick
+               # is now empty, possibly due to conflict resolution."
+               RESULT="failure"
+       else
+               RESULT="success"
+       fi
+       test_expect_$RESULT "$command: modified submodule does not update submodule work tree" '
+               prolog &&
+               reset_work_tree_to add_sub1 &&
+               (
+                       cd submodule_update &&
+                       git branch -t modify_sub1 origin/modify_sub1 &&
+                       $command modify_sub1 &&
+                       test_superproject_content origin/modify_sub1 &&
+                       test_submodule_content sub1 origin/add_sub1 &&
+                       git submodule update &&
+                       test_submodule_content sub1 origin/modify_sub1
+               )
+       '
+
+       # Updating a submodule to an invalid sha1 doesn't update the
+       # submodule's work tree, subsequent update will fail
+       test_expect_$RESULT "$command: modified submodule does not update submodule work tree to invalid commit" '
+               prolog &&
+               reset_work_tree_to add_sub1 &&
+               (
+                       cd submodule_update &&
+                       git branch -t invalid_sub1 origin/invalid_sub1 &&
+                       $command invalid_sub1 &&
+                       test_superproject_content origin/invalid_sub1 &&
+                       test_submodule_content sub1 origin/add_sub1 &&
+                       test_must_fail git submodule update &&
+                       test_submodule_content sub1 origin/add_sub1
+               )
+       '
+       # Updating a submodule from an invalid sha1 doesn't update the
+       # submodule's work tree, subsequent update will succeed
+       test_expect_$RESULT "$command: modified submodule does not update submodule work tree from invalid commit" '
+               prolog &&
+               reset_work_tree_to invalid_sub1 &&
+               (
+                       cd submodule_update &&
+                       git branch -t valid_sub1 origin/valid_sub1 &&
+                       $command valid_sub1 &&
+                       test_superproject_content origin/valid_sub1 &&
+                       test_dir_is_empty sub1 &&
+                       git submodule update --init --recursive &&
+                       test_submodule_content sub1 origin/valid_sub1
+               )
+       '
+}
+
+# Test that submodule contents are currently not updated when switching
+# between commits that change a submodule, but throwing away local changes in
+# the superproject is allowed.
+test_submodule_forced_switch () {
+       command="$1"
+       ######################### Appearing submodule #########################
+       # Switching to a commit letting a submodule appear creates empty dir ...
+       test_expect_success "$command: added submodule creates empty directory" '
+               prolog &&
+               reset_work_tree_to no_submodule &&
+               (
+                       cd submodule_update &&
+                       git branch -t add_sub1 origin/add_sub1 &&
+                       $command add_sub1 &&
+                       test_superproject_content origin/add_sub1 &&
+                       test_dir_is_empty sub1 &&
+                       git submodule update --init --recursive &&
+                       test_submodule_content sub1 origin/add_sub1
+               )
+       '
+       # ... and doesn't care if it already exists ...
+       test_expect_success "$command: added submodule leaves existing empty directory alone" '
+               prolog &&
+               reset_work_tree_to no_submodule &&
+               (
+                       cd submodule_update &&
+                       git branch -t add_sub1 origin/add_sub1 &&
+                       mkdir sub1 &&
+                       $command add_sub1 &&
+                       test_superproject_content origin/add_sub1 &&
+                       test_dir_is_empty sub1 &&
+                       git submodule update --init --recursive &&
+                       test_submodule_content sub1 origin/add_sub1
+               )
+       '
+       # ... unless there is an untracked file in its place.
+       test_expect_success "$command: added submodule does remove untracked unignored file with same name when forced" '
+               prolog &&
+               reset_work_tree_to no_submodule &&
+               (
+                       cd submodule_update &&
+                       git branch -t add_sub1 origin/add_sub1 &&
+                       >sub1 &&
+                       $command add_sub1 &&
+                       test_superproject_content origin/add_sub1 &&
+                       test_dir_is_empty sub1
+               )
+       '
+       # Replacing a tracked file with a submodule produces an empty
+       # directory ...
+       test_expect_success "$command: replace tracked file with submodule creates empty directory" '
+               prolog &&
+               reset_work_tree_to replace_sub1_with_file &&
+               (
+                       cd submodule_update &&
+                       git branch -t replace_file_with_sub1 origin/replace_file_with_sub1 &&
+                       $command replace_file_with_sub1 &&
+                       test_superproject_content origin/replace_file_with_sub1 &&
+                       test_dir_is_empty sub1 &&
+                       git submodule update --init --recursive &&
+                       test_submodule_content sub1 origin/replace_file_with_sub1
+               )
+       '
+       # ... as does removing a directory with tracked files with a
+       # submodule.
+       test_expect_success "$command: replace directory with submodule" '
+               prolog &&
+               reset_work_tree_to replace_sub1_with_directory &&
+               (
+                       cd submodule_update &&
+                       git branch -t replace_directory_with_sub1 origin/replace_directory_with_sub1 &&
+                       $command replace_directory_with_sub1 &&
+                       test_superproject_content origin/replace_directory_with_sub1 &&
+                       test_dir_is_empty sub1 &&
+                       git submodule update --init --recursive &&
+                       test_submodule_content sub1 origin/replace_directory_with_sub1
+               )
+       '
+
+       ######################## Disappearing submodule #######################
+       # Removing a submodule doesn't remove its work tree ...
+       test_expect_success "$command: removed submodule leaves submodule directory and its contents in place" '
+               prolog &&
+               reset_work_tree_to add_sub1 &&
+               (
+                       cd submodule_update &&
+                       git branch -t remove_sub1 origin/remove_sub1 &&
+                       $command remove_sub1 &&
+                       test_superproject_content origin/remove_sub1 &&
+                       test_submodule_content sub1 origin/add_sub1
+               )
+       '
+       # ... especially when it contains a .git directory.
+       test_expect_success "$command: removed submodule leaves submodule containing a .git directory alone" '
+               prolog &&
+               reset_work_tree_to add_sub1 &&
+               (
+                       cd submodule_update &&
+                       git branch -t remove_sub1 origin/remove_sub1 &&
+                       replace_gitfile_with_git_dir sub1 &&
+                       $command remove_sub1 &&
+                       test_superproject_content origin/remove_sub1 &&
+                       test_git_directory_is_unchanged sub1 &&
+                       test_submodule_content sub1 origin/add_sub1
+               )
+       '
+       # Replacing a submodule with files in a directory must fail as the
+       # submodule work tree isn't removed ...
+       test_expect_failure "$command: replace submodule with a directory must fail" '
+               prolog &&
+               reset_work_tree_to add_sub1 &&
+               (
+                       cd submodule_update &&
+                       git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
+                       test_must_fail $command replace_sub1_with_directory &&
+                       test_superproject_content origin/add_sub1 &&
+                       test_submodule_content sub1 origin/add_sub1
+               )
+       '
+       # ... especially when it contains a .git directory.
+       test_expect_failure "$command: replace submodule containing a .git directory with a directory must fail" '
+               prolog &&
+               reset_work_tree_to add_sub1 &&
+               (
+                       cd submodule_update &&
+                       git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
+                       replace_gitfile_with_git_dir sub1 &&
+                       test_must_fail $command replace_sub1_with_directory &&
+                       test_superproject_content origin/add_sub1 &&
+                       test_git_directory_is_unchanged sub1 &&
+                       test_submodule_content sub1 origin/add_sub1
+               )
+       '
+       # Replacing it with a file must fail as it could throw away any local
+       # work tree changes ...
+       test_expect_failure "$command: replace submodule with a file must fail" '
+               prolog &&
+               reset_work_tree_to add_sub1 &&
+               (
+                       cd submodule_update &&
+                       git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
+                       test_must_fail $command replace_sub1_with_file &&
+                       test_superproject_content origin/add_sub1 &&
+                       test_submodule_content sub1 origin/add_sub1
+               )
+       '
+       # ... or even destroy unpushed parts of submodule history if that
+       # still uses a .git directory.
+       test_expect_failure "$command: replace submodule containing a .git directory with a file must fail" '
+               prolog &&
+               reset_work_tree_to add_sub1 &&
+               (
+                       cd submodule_update &&
+                       git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
+                       replace_gitfile_with_git_dir sub1 &&
+                       test_must_fail $command replace_sub1_with_file &&
+                       test_superproject_content origin/add_sub1 &&
+                       test_git_directory_is_unchanged sub1 &&
+                       test_submodule_content sub1 origin/add_sub1
+               )
+       '
+
+       ########################## Modified submodule #########################
+       # Updating a submodule sha1 doesn't update the submodule's work tree
+       test_expect_success "$command: modified submodule does not update submodule work tree" '
+               prolog &&
+               reset_work_tree_to add_sub1 &&
+               (
+                       cd submodule_update &&
+                       git branch -t modify_sub1 origin/modify_sub1 &&
+                       $command modify_sub1 &&
+                       test_superproject_content origin/modify_sub1 &&
+                       test_submodule_content sub1 origin/add_sub1 &&
+                       git submodule update &&
+                       test_submodule_content sub1 origin/modify_sub1
+               )
+       '
+       # Updating a submodule to an invalid sha1 doesn't update the
+       # submodule's work tree, subsequent update will fail
+       test_expect_success "$command: modified submodule does not update submodule work tree to invalid commit" '
+               prolog &&
+               reset_work_tree_to add_sub1 &&
+               (
+                       cd submodule_update &&
+                       git branch -t invalid_sub1 origin/invalid_sub1 &&
+                       $command invalid_sub1 &&
+                       test_superproject_content origin/invalid_sub1 &&
+                       test_submodule_content sub1 origin/add_sub1 &&
+                       test_must_fail git submodule update &&
+                       test_submodule_content sub1 origin/add_sub1
+               )
+       '
+       # Updating a submodule from an invalid sha1 doesn't update the
+       # submodule's work tree, subsequent update will succeed
+       test_expect_success "$command: modified submodule does not update submodule work tree from invalid commit" '
+               prolog &&
+               reset_work_tree_to invalid_sub1 &&
+               (
+                       cd submodule_update &&
+                       git branch -t valid_sub1 origin/valid_sub1 &&
+                       $command valid_sub1 &&
+                       test_superproject_content origin/valid_sub1 &&
+                       test_dir_is_empty sub1 &&
+                       git submodule update --init --recursive &&
+                       test_submodule_content sub1 origin/valid_sub1
+               )
+       '
+}
diff --git a/t/t1013-read-tree-submodule.sh b/t/t1013-read-tree-submodule.sh
new file mode 100755 (executable)
index 0000000..20526ae
--- /dev/null
@@ -0,0 +1,12 @@
+#!/bin/sh
+
+test_description='read-tree can handle submodules'
+
+. ./test-lib.sh
+. "$TEST_DIRECTORY"/lib-submodule-update.sh
+
+test_submodule_switch "git read-tree -u -m"
+
+test_submodule_forced_switch "git read-tree -u --reset"
+
+test_done
index 06b18f8bc1e2991170736254bf3c558ab4673d13..6847f7582234d656563f867976a64142a3a01621 100755 (executable)
@@ -3,6 +3,7 @@
 test_description='checkout can handle submodules'
 
 . ./test-lib.sh
+. "$TEST_DIRECTORY"/lib-submodule-update.sh
 
 test_expect_success 'setup' '
        mkdir submodule &&
@@ -62,4 +63,8 @@ test_expect_success '"checkout <submodule>" honors submodule.*.ignore from .git/
        ! test -s actual
 '
 
+test_submodule_switch "git checkout"
+
+test_submodule_forced_switch "git checkout -f"
+
 test_done
diff --git a/t/t3426-rebase-submodule.sh b/t/t3426-rebase-submodule.sh
new file mode 100755 (executable)
index 0000000..d5b896d
--- /dev/null
@@ -0,0 +1,46 @@
+#!/bin/sh
+
+test_description='rebase can handle submodules'
+
+. ./test-lib.sh
+. "$TEST_DIRECTORY"/lib-submodule-update.sh
+. "$TEST_DIRECTORY"/lib-rebase.sh
+
+git_rebase () {
+       git status -su >expect &&
+       ls -1pR * >>expect &&
+       git checkout -b ours HEAD &&
+       echo x >>file1 &&
+       git add file1 &&
+       git commit -m add_x &&
+       git revert HEAD &&
+       git status -su >actual &&
+       ls -1pR * >>actual &&
+       test_cmp expect actual &&
+       git rebase "$1"
+}
+
+test_submodule_switch "git_rebase"
+
+git_rebase_interactive () {
+       git status -su >expect &&
+       ls -1pR * >>expect &&
+       git checkout -b ours HEAD &&
+       echo x >>file1 &&
+       git add file1 &&
+       git commit -m add_x &&
+       git revert HEAD &&
+       git status -su >actual &&
+       ls -1pR * >>actual &&
+       test_cmp expect actual &&
+       set_fake_editor &&
+       echo "fake-editor.sh" >.git/info/exclude &&
+       git rebase -i "$1"
+}
+
+KNOWN_FAILURE_NOFF_MERGE_DOESNT_CREATE_EMPTY_SUBMODULE_DIR=1
+# The real reason "replace directory with submodule" fails is because a
+# directory "sub1" exists, but we reuse the suppression added for merge here
+test_submodule_switch "git_rebase_interactive"
+
+test_done
diff --git a/t/t3512-cherry-pick-submodule.sh b/t/t3512-cherry-pick-submodule.sh
new file mode 100755 (executable)
index 0000000..6863b7b
--- /dev/null
@@ -0,0 +1,13 @@
+#!/bin/sh
+
+test_description='cherry-pick can handle submodules'
+
+. ./test-lib.sh
+. "$TEST_DIRECTORY"/lib-submodule-update.sh
+
+KNOWN_FAILURE_CHERRY_PICK_SEES_EMPTY_COMMIT=1
+KNOWN_FAILURE_NOFF_MERGE_DOESNT_CREATE_EMPTY_SUBMODULE_DIR=1
+KNOWN_FAILURE_NOFF_MERGE_ATTEMPTS_TO_MERGE_REMOVED_SUBMODULE_FILES=1
+test_submodule_switch "git cherry-pick"
+
+test_done
diff --git a/t/t3513-revert-submodule.sh b/t/t3513-revert-submodule.sh
new file mode 100755 (executable)
index 0000000..a1c4e02
--- /dev/null
@@ -0,0 +1,32 @@
+#!/bin/sh
+
+test_description='revert can handle submodules'
+
+. ./test-lib.sh
+. "$TEST_DIRECTORY"/lib-submodule-update.sh
+
+# Create a revert that moves from HEAD (including any test modifications to
+# the work tree) to $1 by first checking out $1 and reverting it. Reverting
+# the revert is the transition we test for. We tar the current work tree
+# first so we can restore the work tree test setup after doing the checkout
+# and revert.  We test here that the restored work tree content is identical
+# to that at the beginning. The last revert is then tested by the framework.
+git_revert () {
+       git status -su >expect &&
+       ls -1pR * >>expect &&
+       tar czf "$TRASH_DIRECTORY/tmp.tgz" * &&
+       git checkout "$1" &&
+       git revert HEAD &&
+       rm -rf * &&
+       tar xzf "$TRASH_DIRECTORY/tmp.tgz" &&
+       git status -su >actual &&
+       ls -1pR * >>actual &&
+       test_cmp expect actual &&
+       git revert HEAD
+}
+
+KNOWN_FAILURE_CHERRY_PICK_SEES_EMPTY_COMMIT=1
+KNOWN_FAILURE_NOFF_MERGE_DOESNT_CREATE_EMPTY_SUBMODULE_DIR=1
+test_submodule_switch "git_revert"
+
+test_done
diff --git a/t/t3906-stash-submodule.sh b/t/t3906-stash-submodule.sh
new file mode 100755 (executable)
index 0000000..d7219d6
--- /dev/null
@@ -0,0 +1,24 @@
+#!/bin/sh
+
+test_description='stash apply can handle submodules'
+
+. ./test-lib.sh
+. "$TEST_DIRECTORY"/lib-submodule-update.sh
+
+git_stash () {
+       git status -su >expect &&
+       ls -1pR * >>expect &&
+       git read-tree -u -m "$1" &&
+       git stash &&
+       git status -su >actual &&
+       ls -1pR * >>actual &&
+       test_cmp expect actual &&
+       git stash apply
+}
+
+KNOWN_FAILURE_STASH_DOES_IGNORE_SUBMODULE_CHANGES=1
+KNOWN_FAILURE_CHERRY_PICK_SEES_EMPTY_COMMIT=1
+KNOWN_FAILURE_NOFF_MERGE_DOESNT_CREATE_EMPTY_SUBMODULE_DIR=1
+test_submodule_switch "git_stash"
+
+test_done
diff --git a/t/t4137-apply-submodule.sh b/t/t4137-apply-submodule.sh
new file mode 100755 (executable)
index 0000000..a9bd40a
--- /dev/null
@@ -0,0 +1,20 @@
+#!/bin/sh
+
+test_description='git apply handling submodules'
+
+. ./test-lib.sh
+. "$TEST_DIRECTORY"/lib-submodule-update.sh
+
+apply_index () {
+       git diff --ignore-submodules=dirty "..$1" | git apply --index -
+}
+
+test_submodule_switch "apply_index"
+
+apply_3way () {
+       git diff --ignore-submodules=dirty "..$1" | git apply --3way -
+}
+
+test_submodule_switch "apply_3way"
+
+test_done
diff --git a/t/t4255-am-submodule.sh b/t/t4255-am-submodule.sh
new file mode 100755 (executable)
index 0000000..8bde7db
--- /dev/null
@@ -0,0 +1,21 @@
+#!/bin/sh
+
+test_description='git am handling submodules'
+
+. ./test-lib.sh
+. "$TEST_DIRECTORY"/lib-submodule-update.sh
+
+am () {
+       git format-patch --stdout --ignore-submodules=dirty "..$1" | git am -
+}
+
+test_submodule_switch "am"
+
+am_3way () {
+       git format-patch --stdout --ignore-submodules=dirty "..$1" | git am --3way -
+}
+
+KNOWN_FAILURE_NOFF_MERGE_ATTEMPTS_TO_MERGE_REMOVED_SUBMODULE_FILES=1
+test_submodule_switch "am_3way"
+
+test_done
diff --git a/t/t5572-pull-submodule.sh b/t/t5572-pull-submodule.sh
new file mode 100755 (executable)
index 0000000..accfa5c
--- /dev/null
@@ -0,0 +1,45 @@
+#!/bin/sh
+
+test_description='pull can handle submodules'
+
+. ./test-lib.sh
+. "$TEST_DIRECTORY"/lib-submodule-update.sh
+
+reset_branch_to_HEAD () {
+       git branch -D "$1" &&
+       git checkout -b "$1" HEAD &&
+       git branch --set-upstream-to="origin/$1" "$1"
+}
+
+git_pull () {
+       reset_branch_to_HEAD "$1" &&
+       git pull
+}
+
+# pulls without conflicts
+test_submodule_switch "git_pull"
+
+git_pull_ff () {
+       reset_branch_to_HEAD "$1" &&
+       git pull --ff
+}
+
+test_submodule_switch "git_pull_ff"
+
+git_pull_ff_only () {
+       reset_branch_to_HEAD "$1" &&
+       git pull --ff-only
+}
+
+test_submodule_switch "git_pull_ff_only"
+
+git_pull_noff () {
+       reset_branch_to_HEAD "$1" &&
+       git pull --no-ff
+}
+
+KNOWN_FAILURE_NOFF_MERGE_DOESNT_CREATE_EMPTY_SUBMODULE_DIR=1
+KNOWN_FAILURE_NOFF_MERGE_ATTEMPTS_TO_MERGE_REMOVED_SUBMODULE_FILES=1
+test_submodule_switch "git_pull_noff"
+
+test_done
diff --git a/t/t6041-bisect-submodule.sh b/t/t6041-bisect-submodule.sh
new file mode 100755 (executable)
index 0000000..c6b7aa6
--- /dev/null
@@ -0,0 +1,32 @@
+#!/bin/sh
+
+test_description='bisect can handle submodules'
+
+. ./test-lib.sh
+. "$TEST_DIRECTORY"/lib-submodule-update.sh
+
+git_bisect () {
+       git status -su >expect &&
+       ls -1pR * >>expect &&
+       tar czf "$TRASH_DIRECTORY/tmp.tgz" * &&
+       GOOD=$(git rev-parse --verify HEAD) &&
+       git checkout "$1" &&
+       echo "foo" >bar &&
+       git add bar &&
+       git commit -m "bisect bad" &&
+       BAD=$(git rev-parse --verify HEAD) &&
+       git reset --hard HEAD^^ &&
+       git submodule update &&
+       git bisect start &&
+       git bisect good $GOOD &&
+       rm -rf * &&
+       tar xzf "$TRASH_DIRECTORY/tmp.tgz" &&
+       git status -su >actual &&
+       ls -1pR * >>actual &&
+       test_cmp expect actual &&
+       git bisect bad $BAD
+}
+
+test_submodule_switch "git_bisect"
+
+test_done
diff --git a/t/t7112-reset-submodule.sh b/t/t7112-reset-submodule.sh
new file mode 100755 (executable)
index 0000000..2eda6ad
--- /dev/null
@@ -0,0 +1,14 @@
+#!/bin/sh
+
+test_description='reset can handle submodules'
+
+. ./test-lib.sh
+. "$TEST_DIRECTORY"/lib-submodule-update.sh
+
+test_submodule_switch "git reset --keep"
+
+test_submodule_switch "git reset --merge"
+
+test_submodule_forced_switch "git reset --hard"
+
+test_done
diff --git a/t/t7613-merge-submodule.sh b/t/t7613-merge-submodule.sh
new file mode 100755 (executable)
index 0000000..d1e9fcc
--- /dev/null
@@ -0,0 +1,19 @@
+#!/bin/sh
+
+test_description='merge can handle submodules'
+
+. ./test-lib.sh
+. "$TEST_DIRECTORY"/lib-submodule-update.sh
+
+# merges without conflicts
+test_submodule_switch "git merge"
+
+test_submodule_switch "git merge --ff"
+
+test_submodule_switch "git merge --ff-only"
+
+KNOWN_FAILURE_NOFF_MERGE_DOESNT_CREATE_EMPTY_SUBMODULE_DIR=1
+KNOWN_FAILURE_NOFF_MERGE_ATTEMPTS_TO_MERGE_REMOVED_SUBMODULE_FILES=1
+test_submodule_switch "git merge --no-ff"
+
+test_done
index 0377d3e2960cc282ce1a2c7cb629245728c82092..dafd6ad21a92bac48155af39ebb9a4baaf3c4970 100644 (file)
@@ -489,6 +489,17 @@ test_path_is_dir () {
        fi
 }
 
+# Check if the directory exists and is empty as expected, barf otherwise.
+test_dir_is_empty () {
+       test_path_is_dir "$1" &&
+       if test -n "$(ls -a1 "$1" | egrep -v '^\.\.?$')"
+       then
+               echo "Directory '$1' is not empty, it contains:"
+               ls -la "$1"
+               return 1
+       fi
+}
+
 test_path_is_missing () {
        if [ -e "$1" ]
        then