t / lib-submodule-update.shon commit submodule deinit: unset core.worktree (984cd77)
   1# Create a submodule layout used for all tests below.
   2#
   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)
  18#
  19#                     ----O
  20#                    /    ^
  21#                   /     remove_sub1
  22#                  /
  23#       add_sub1  /-------O---------O--------O  modify_sub1_recursively
  24#             |  /        ^         add_nested_sub
  25#             | /         modify_sub1
  26#             v/
  27#      O------O-----------O---------O
  28#      ^       \          ^         replace_directory_with_sub1
  29#      |        \         replace_sub1_with_directory
  30# no_submodule   \
  31#                 --------O---------O
  32#                  \      ^         replace_file_with_sub1
  33#                   \     replace_sub1_with_file
  34#                    \
  35#                     ----O---------O
  36#                         ^         valid_sub1
  37#                         invalid_sub1
  38#
  39
  40create_lib_submodule_repo () {
  41        git init submodule_update_sub1 &&
  42        (
  43                cd submodule_update_sub1 &&
  44                echo "expect" >>.gitignore &&
  45                echo "actual" >>.gitignore &&
  46                echo "x" >file1 &&
  47                echo "y" >file2 &&
  48                git add .gitignore file1 file2 &&
  49                git commit -m "Base inside first submodule" &&
  50                git branch "no_submodule"
  51        ) &&
  52        git init submodule_update_sub2 &&
  53        (
  54                cd submodule_update_sub2
  55                echo "expect" >>.gitignore &&
  56                echo "actual" >>.gitignore &&
  57                echo "x" >file1 &&
  58                echo "y" >file2 &&
  59                git add .gitignore file1 file2 &&
  60                git commit -m "nested submodule base" &&
  61                git branch "no_submodule"
  62        ) &&
  63        git init submodule_update_repo &&
  64        (
  65                cd submodule_update_repo &&
  66                echo "expect" >>.gitignore &&
  67                echo "actual" >>.gitignore &&
  68                echo "x" >file1 &&
  69                echo "y" >file2 &&
  70                git add .gitignore file1 file2 &&
  71                git commit -m "Base" &&
  72                git branch "no_submodule" &&
  73
  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" &&
  81
  82                git checkout -b remove_sub1 add_sub1 &&
  83                git revert HEAD &&
  84
  85                git checkout -b modify_sub1 add_sub1 &&
  86                git submodule update &&
  87                (
  88                        cd sub1 &&
  89                        git fetch &&
  90                        git checkout -b "modifications" &&
  91                        echo "z" >file2 &&
  92                        echo "x" >file3 &&
  93                        git add file2 file3 &&
  94                        git commit -m "modified file2 and added file3" &&
  95                        git push origin modifications
  96                ) &&
  97                git add sub1 &&
  98                git commit -m "Modify sub1" &&
  99
 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" &&
 104                git add sub1 &&
 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 sub1/sub2 checkout -b modify_sub1_recursively &&
 109                echo change >sub1/sub2/file3 &&
 110                git -C sub1/sub2 add file3 &&
 111                git -C sub1/sub2 commit -m "make a change in nested sub" &&
 112                git -C sub1 add sub2 &&
 113                git -C sub1 commit -m "update nested sub" &&
 114                git add sub1 &&
 115                git commit -m "update sub1, that updates nested sub" &&
 116                git -C sub1 push origin modify_sub1_recursively &&
 117                git -C sub1/sub2 push origin modify_sub1_recursively &&
 118                git -C sub1 submodule deinit -f --all &&
 119
 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 &&
 124                rm sub1/.git* &&
 125                git config -f .gitmodules --remove-section "submodule.sub1" &&
 126                git add .gitmodules sub1/* &&
 127                git commit -m "Replace sub1 with directory" &&
 128
 129                git checkout -b replace_directory_with_sub1 &&
 130                git revert HEAD &&
 131
 132                git checkout -b replace_sub1_with_file add_sub1 &&
 133                git rm sub1 &&
 134                echo "content" >sub1 &&
 135                git add sub1 &&
 136                git commit -m "Replace sub1 with file" &&
 137
 138                git checkout -b replace_file_with_sub1 &&
 139                git revert HEAD &&
 140
 141                git checkout -b invalid_sub1 add_sub1 &&
 142                git update-index --cacheinfo 160000 0123456789012345678901234567890123456789 sub1 &&
 143                git commit -m "Invalid sub1 commit" &&
 144                git checkout -b valid_sub1 &&
 145                git revert HEAD &&
 146
 147                git checkout master
 148        )
 149}
 150
 151# Helper function to replace gitfile with .git directory
 152replace_gitfile_with_git_dir () {
 153        (
 154                cd "$1" &&
 155                git_dir="$(git rev-parse --git-dir)" &&
 156                rm -f .git &&
 157                cp -R "$git_dir" .git &&
 158                GIT_WORK_TREE=. git config --unset core.worktree
 159        )
 160}
 161
 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.
 166#
 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.
 169test_git_directory_is_unchanged () {
 170        (
 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
 177        ) &&
 178        diff -r ".git/modules/$1" "$1/.git" &&
 179        (
 180                # ... and then restore.
 181                cd ".git/modules/$1" &&
 182                git config core.worktree "../../../$1"
 183        )
 184}
 185
 186test_git_directory_exists() {
 187        test -e ".git/modules/$1" &&
 188        if test -f sub1/.git
 189        then
 190                # does core.worktree point at the right place?
 191                test "$(git -C .git/modules/$1 config core.worktree)" = "../../../$1"
 192        fi
 193}
 194
 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.
 198prolog () {
 199        (test -d submodule_update_repo || create_lib_submodule_repo) &&
 200        test_config_global diff.ignoreSubmodules all &&
 201        test_config diff.ignoreSubmodules all
 202}
 203
 204# Helper function to bring work tree back into the state given by the
 205# commit. This includes trying to populate sub1 accordingly if it exists and
 206# should be updated to an existing commit.
 207reset_work_tree_to () {
 208        rm -rf submodule_update &&
 209        git clone submodule_update_repo submodule_update &&
 210        (
 211                cd submodule_update &&
 212                rm -rf sub1 &&
 213                git checkout -f "$1" &&
 214                git status -u -s >actual &&
 215                test_must_be_empty actual &&
 216                hash=$(git rev-parse --revs-only HEAD:sub1) &&
 217                if test -n "$hash" &&
 218                   test $(cd "../submodule_update_sub1" && git rev-parse --verify "$hash^{commit}")
 219                then
 220                        git submodule update --init --recursive "sub1"
 221                fi
 222        )
 223}
 224
 225reset_work_tree_to_interested () {
 226        reset_work_tree_to $1 &&
 227        # make the submodule git dirs available
 228        if ! test -d submodule_update/.git/modules/sub1
 229        then
 230                mkdir -p submodule_update/.git/modules &&
 231                cp -r submodule_update_repo/.git/modules/sub1 submodule_update/.git/modules/sub1
 232                GIT_WORK_TREE=. git -C submodule_update/.git/modules/sub1 config --unset core.worktree
 233        fi &&
 234        if ! test -d submodule_update/.git/modules/sub1/modules/sub2
 235        then
 236                mkdir -p submodule_update/.git/modules/sub1/modules &&
 237                cp -r submodule_update_repo/.git/modules/sub1/modules/sub2 submodule_update/.git/modules/sub1/modules/sub2
 238                # core.worktree is unset for sub2 as it is not checked out
 239        fi &&
 240        # indicate we are interested in the submodule:
 241        git -C submodule_update config submodule.sub1.url "bogus" &&
 242        # sub1 might not be checked out, so use the git dir
 243        git -C submodule_update/.git/modules/sub1 config submodule.sub2.url "bogus"
 244}
 245
 246# Test that the superproject contains the content according to commit "$1"
 247# (the work tree must match the index for everything but submodules but the
 248# index must exactly match the given commit including any submodule SHA-1s).
 249test_superproject_content () {
 250        git diff-index --cached "$1" >actual &&
 251        test_must_be_empty actual &&
 252        git diff-files --ignore-submodules >actual &&
 253        test_must_be_empty actual
 254}
 255
 256# Test that the given submodule at path "$1" contains the content according
 257# to the submodule commit recorded in the superproject's commit "$2"
 258test_submodule_content () {
 259        if test x"$1" = "x-C"
 260        then
 261                cd "$2"
 262                shift; shift;
 263        fi
 264        if test $# != 2
 265        then
 266                echo "test_submodule_content needs two arguments"
 267                return 1
 268        fi &&
 269        submodule="$1" &&
 270        commit="$2" &&
 271        test -d "$submodule"/ &&
 272        if ! test -f "$submodule"/.git && ! test -d "$submodule"/.git
 273        then
 274                echo "Submodule $submodule is not populated"
 275                return 1
 276        fi &&
 277        sha1=$(git rev-parse --verify "$commit:$submodule") &&
 278        if test -z "$sha1"
 279        then
 280                echo "Couldn't retrieve SHA-1 of $submodule for $commit"
 281                return 1
 282        fi &&
 283        (
 284                cd "$submodule" &&
 285                git status -u -s >actual &&
 286                test_must_be_empty actual &&
 287                git diff "$sha1" >actual &&
 288                test_must_be_empty actual
 289        )
 290}
 291
 292# Test that the following transitions are correctly handled:
 293# - Updated submodule
 294# - New submodule
 295# - Removed submodule
 296# - Directory containing tracked files replaced by submodule
 297# - Submodule replaced by tracked files in directory
 298# - Submodule replaced by tracked file with the same name
 299# - tracked file replaced by submodule
 300#
 301# The default is that submodule contents aren't changed until "git submodule
 302# update" is run. And even then that command doesn't delete the work tree of
 303# a removed submodule.
 304#
 305# Removing a submodule containing a .git directory must fail even when forced
 306# to protect the history!
 307#
 308
 309# Internal function; use test_submodule_switch() or
 310# test_submodule_forced_switch() instead.
 311test_submodule_switch_common() {
 312        command="$1"
 313        ######################### Appearing submodule #########################
 314        # Switching to a commit letting a submodule appear creates empty dir ...
 315        if test "$KNOWN_FAILURE_STASH_DOES_IGNORE_SUBMODULE_CHANGES" = 1
 316        then
 317                # Restoring stash fails to restore submodule index entry
 318                RESULT="failure"
 319        else
 320                RESULT="success"
 321        fi
 322        test_expect_$RESULT "$command: added submodule creates empty directory" '
 323                prolog &&
 324                reset_work_tree_to no_submodule &&
 325                (
 326                        cd submodule_update &&
 327                        git branch -t add_sub1 origin/add_sub1 &&
 328                        $command add_sub1 &&
 329                        test_superproject_content origin/add_sub1 &&
 330                        test_dir_is_empty sub1 &&
 331                        git submodule update --init --recursive &&
 332                        test_submodule_content sub1 origin/add_sub1
 333                )
 334        '
 335        # ... and doesn't care if it already exists.
 336        test_expect_$RESULT "$command: added submodule leaves existing empty directory alone" '
 337                prolog &&
 338                reset_work_tree_to no_submodule &&
 339                (
 340                        cd submodule_update &&
 341                        mkdir sub1 &&
 342                        git branch -t add_sub1 origin/add_sub1 &&
 343                        $command add_sub1 &&
 344                        test_superproject_content origin/add_sub1 &&
 345                        test_dir_is_empty sub1 &&
 346                        git submodule update --init --recursive &&
 347                        test_submodule_content sub1 origin/add_sub1
 348                )
 349        '
 350        # Replacing a tracked file with a submodule produces an empty
 351        # directory ...
 352        test_expect_$RESULT "$command: replace tracked file with submodule creates empty directory" '
 353                prolog &&
 354                reset_work_tree_to replace_sub1_with_file &&
 355                (
 356                        cd submodule_update &&
 357                        git branch -t replace_file_with_sub1 origin/replace_file_with_sub1 &&
 358                        $command replace_file_with_sub1 &&
 359                        test_superproject_content origin/replace_file_with_sub1 &&
 360                        test_dir_is_empty sub1 &&
 361                        git submodule update --init --recursive &&
 362                        test_submodule_content sub1 origin/replace_file_with_sub1
 363                )
 364        '
 365        # ... as does removing a directory with tracked files with a
 366        # submodule.
 367        if test "$KNOWN_FAILURE_NOFF_MERGE_DOESNT_CREATE_EMPTY_SUBMODULE_DIR" = 1
 368        then
 369                # Non fast-forward merges fail with "Directory sub1 doesn't
 370                # exist. sub1" because the empty submodule directory is not
 371                # created
 372                RESULT="failure"
 373        else
 374                RESULT="success"
 375        fi
 376        test_expect_$RESULT "$command: replace directory with submodule" '
 377                prolog &&
 378                reset_work_tree_to replace_sub1_with_directory &&
 379                (
 380                        cd submodule_update &&
 381                        git branch -t replace_directory_with_sub1 origin/replace_directory_with_sub1 &&
 382                        $command replace_directory_with_sub1 &&
 383                        test_superproject_content origin/replace_directory_with_sub1 &&
 384                        test_dir_is_empty sub1 &&
 385                        git submodule update --init --recursive &&
 386                        test_submodule_content sub1 origin/replace_directory_with_sub1
 387                )
 388        '
 389
 390        ######################## Disappearing submodule #######################
 391        # Removing a submodule doesn't remove its work tree ...
 392        if test "$KNOWN_FAILURE_STASH_DOES_IGNORE_SUBMODULE_CHANGES" = 1
 393        then
 394                RESULT="failure"
 395        else
 396                RESULT="success"
 397        fi
 398        test_expect_$RESULT "$command: removed submodule leaves submodule directory and its contents in place" '
 399                prolog &&
 400                reset_work_tree_to add_sub1 &&
 401                (
 402                        cd submodule_update &&
 403                        git branch -t remove_sub1 origin/remove_sub1 &&
 404                        $command remove_sub1 &&
 405                        test_superproject_content origin/remove_sub1 &&
 406                        test_submodule_content sub1 origin/add_sub1
 407                )
 408        '
 409        # ... especially when it contains a .git directory.
 410        test_expect_$RESULT "$command: removed submodule leaves submodule containing a .git directory alone" '
 411                prolog &&
 412                reset_work_tree_to add_sub1 &&
 413                (
 414                        cd submodule_update &&
 415                        git branch -t remove_sub1 origin/remove_sub1 &&
 416                        replace_gitfile_with_git_dir sub1 &&
 417                        $command remove_sub1 &&
 418                        test_superproject_content origin/remove_sub1 &&
 419                        test_git_directory_is_unchanged sub1 &&
 420                        test_submodule_content sub1 origin/add_sub1
 421                )
 422        '
 423        # Replacing a submodule with files in a directory must fail as the
 424        # submodule work tree isn't removed ...
 425        if test "$KNOWN_FAILURE_NOFF_MERGE_ATTEMPTS_TO_MERGE_REMOVED_SUBMODULE_FILES" = 1
 426        then
 427                # Non fast-forward merges attempt to merge the former
 428                # submodule files with the newly checked out ones in the
 429                # directory of the same name while it shouldn't.
 430                RESULT="failure"
 431        elif test "$KNOWN_FAILURE_FORCED_SWITCH_TESTS" = 1
 432        then
 433                # All existing tests that use test_submodule_forced_switch()
 434                # require this.
 435                RESULT="failure"
 436        else
 437                RESULT="success"
 438        fi
 439        test_expect_$RESULT "$command: replace submodule with a directory must fail" '
 440                prolog &&
 441                reset_work_tree_to add_sub1 &&
 442                (
 443                        cd submodule_update &&
 444                        git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
 445                        test_must_fail $command replace_sub1_with_directory &&
 446                        test_superproject_content origin/add_sub1 &&
 447                        test_submodule_content sub1 origin/add_sub1
 448                )
 449        '
 450        # ... especially when it contains a .git directory.
 451        test_expect_$RESULT "$command: replace submodule containing a .git directory with a directory must fail" '
 452                prolog &&
 453                reset_work_tree_to add_sub1 &&
 454                (
 455                        cd submodule_update &&
 456                        git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
 457                        replace_gitfile_with_git_dir sub1 &&
 458                        test_must_fail $command replace_sub1_with_directory &&
 459                        test_superproject_content origin/add_sub1 &&
 460                        test_git_directory_is_unchanged sub1 &&
 461                        test_submodule_content sub1 origin/add_sub1
 462                )
 463        '
 464        # Replacing it with a file must fail as it could throw away any local
 465        # work tree changes ...
 466        test_expect_failure "$command: replace submodule with a file must fail" '
 467                prolog &&
 468                reset_work_tree_to add_sub1 &&
 469                (
 470                        cd submodule_update &&
 471                        git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
 472                        test_must_fail $command replace_sub1_with_file &&
 473                        test_superproject_content origin/add_sub1 &&
 474                        test_submodule_content sub1 origin/add_sub1
 475                )
 476        '
 477        # ... or even destroy unpushed parts of submodule history if that
 478        # still uses a .git directory.
 479        test_expect_failure "$command: replace submodule containing a .git directory with a file must fail" '
 480                prolog &&
 481                reset_work_tree_to add_sub1 &&
 482                (
 483                        cd submodule_update &&
 484                        git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
 485                        replace_gitfile_with_git_dir sub1 &&
 486                        test_must_fail $command replace_sub1_with_file &&
 487                        test_superproject_content origin/add_sub1 &&
 488                        test_git_directory_is_unchanged sub1 &&
 489                        test_submodule_content sub1 origin/add_sub1
 490                )
 491        '
 492
 493        ########################## Modified submodule #########################
 494        # Updating a submodule sha1 doesn't update the submodule's work tree
 495        if test "$KNOWN_FAILURE_CHERRY_PICK_SEES_EMPTY_COMMIT" = 1
 496        then
 497                # When cherry picking a SHA-1 update for an ignored submodule
 498                # the commit incorrectly fails with "The previous cherry-pick
 499                # is now empty, possibly due to conflict resolution."
 500                RESULT="failure"
 501        else
 502                RESULT="success"
 503        fi
 504        test_expect_$RESULT "$command: modified submodule does not update submodule work tree" '
 505                prolog &&
 506                reset_work_tree_to add_sub1 &&
 507                (
 508                        cd submodule_update &&
 509                        git branch -t modify_sub1 origin/modify_sub1 &&
 510                        $command modify_sub1 &&
 511                        test_superproject_content origin/modify_sub1 &&
 512                        test_submodule_content sub1 origin/add_sub1 &&
 513                        git submodule update &&
 514                        test_submodule_content sub1 origin/modify_sub1
 515                )
 516        '
 517        # Updating a submodule to an invalid sha1 doesn't update the
 518        # submodule's work tree, subsequent update will fail
 519        test_expect_$RESULT "$command: modified submodule does not update submodule work tree to invalid commit" '
 520                prolog &&
 521                reset_work_tree_to add_sub1 &&
 522                (
 523                        cd submodule_update &&
 524                        git branch -t invalid_sub1 origin/invalid_sub1 &&
 525                        $command invalid_sub1 &&
 526                        test_superproject_content origin/invalid_sub1 &&
 527                        test_submodule_content sub1 origin/add_sub1 &&
 528                        test_must_fail git submodule update &&
 529                        test_submodule_content sub1 origin/add_sub1
 530                )
 531        '
 532        # Updating a submodule from an invalid sha1 doesn't update the
 533        # submodule's work tree, subsequent update will succeed
 534        test_expect_$RESULT "$command: modified submodule does not update submodule work tree from invalid commit" '
 535                prolog &&
 536                reset_work_tree_to invalid_sub1 &&
 537                (
 538                        cd submodule_update &&
 539                        git branch -t valid_sub1 origin/valid_sub1 &&
 540                        $command valid_sub1 &&
 541                        test_superproject_content origin/valid_sub1 &&
 542                        test_dir_is_empty sub1 &&
 543                        git submodule update --init --recursive &&
 544                        test_submodule_content sub1 origin/valid_sub1
 545                )
 546        '
 547}
 548
 549# Declares and invokes several tests that, in various situations, checks that
 550# the provided transition function:
 551#  - succeeds in updating the worktree and index of a superproject to a target
 552#    commit, or fails atomically (depending on the test situation)
 553#  - if succeeds, the contents of submodule directories are unchanged
 554#  - if succeeds, once "git submodule update" is invoked, the contents of
 555#    submodule directories are updated
 556#
 557# If the command under test is known to not work with submodules in certain
 558# conditions, set the appropriate KNOWN_FAILURE_* variable used in the tests
 559# below to 1.
 560#
 561# Use as follows:
 562#
 563# my_func () {
 564#   target=$1
 565#   # Do something here that updates the worktree and index to match target,
 566#   # but not any submodule directories.
 567# }
 568# test_submodule_switch "my_func"
 569test_submodule_switch () {
 570        command="$1"
 571        test_submodule_switch_common "$command"
 572
 573        # An empty directory does not prevent the creation of a submodule of
 574        # the same name, but a file does.
 575        test_expect_success "$command: added submodule doesn't remove untracked unignored file with same name" '
 576                prolog &&
 577                reset_work_tree_to no_submodule &&
 578                (
 579                        cd submodule_update &&
 580                        git branch -t add_sub1 origin/add_sub1 &&
 581                        >sub1 &&
 582                        test_must_fail $command add_sub1 &&
 583                        test_superproject_content origin/no_submodule &&
 584                        test_must_be_empty sub1
 585                )
 586        '
 587}
 588
 589# Same as test_submodule_switch(), except that throwing away local changes in
 590# the superproject is allowed.
 591test_submodule_forced_switch () {
 592        command="$1"
 593        KNOWN_FAILURE_FORCED_SWITCH_TESTS=1
 594        test_submodule_switch_common "$command"
 595
 596        # When forced, a file in the superproject does not prevent creating a
 597        # submodule of the same name.
 598        test_expect_success "$command: added submodule does remove untracked unignored file with same name when forced" '
 599                prolog &&
 600                reset_work_tree_to no_submodule &&
 601                (
 602                        cd submodule_update &&
 603                        git branch -t add_sub1 origin/add_sub1 &&
 604                        >sub1 &&
 605                        $command add_sub1 &&
 606                        test_superproject_content origin/add_sub1 &&
 607                        test_dir_is_empty sub1
 608                )
 609        '
 610}
 611
 612# Test that submodule contents are correctly updated when switching
 613# between commits that change a submodule.
 614# Test that the following transitions are correctly handled:
 615# (These tests are also above in the case where we expect no change
 616#  in the submodule)
 617# - Updated submodule
 618# - New submodule
 619# - Removed submodule
 620# - Directory containing tracked files replaced by submodule
 621# - Submodule replaced by tracked files in directory
 622# - Submodule replaced by tracked file with the same name
 623# - tracked file replaced by submodule
 624#
 625# New test cases
 626# - Removing a submodule with a git directory absorbs the submodules
 627#   git directory first into the superproject.
 628
 629# Internal function; use test_submodule_switch_recursing_with_args() or
 630# test_submodule_forced_switch_recursing_with_args() instead.
 631test_submodule_recursing_with_args_common() {
 632        command="$1"
 633
 634        ######################### Appearing submodule #########################
 635        # Switching to a commit letting a submodule appear checks it out ...
 636        test_expect_success "$command: added submodule is checked out" '
 637                prolog &&
 638                reset_work_tree_to_interested no_submodule &&
 639                (
 640                        cd submodule_update &&
 641                        git branch -t add_sub1 origin/add_sub1 &&
 642                        $command add_sub1 &&
 643                        test_superproject_content origin/add_sub1 &&
 644                        test_submodule_content sub1 origin/add_sub1
 645                )
 646        '
 647        # ... ignoring an empty existing directory.
 648        test_expect_success "$command: added submodule is checked out in empty dir" '
 649                prolog &&
 650                reset_work_tree_to_interested no_submodule &&
 651                (
 652                        cd submodule_update &&
 653                        mkdir sub1 &&
 654                        git branch -t add_sub1 origin/add_sub1 &&
 655                        $command add_sub1 &&
 656                        test_superproject_content origin/add_sub1 &&
 657                        test_submodule_content sub1 origin/add_sub1
 658                )
 659        '
 660        test_expect_success "$command: submodule branch is not changed, detach HEAD instead" '
 661                prolog &&
 662                reset_work_tree_to_interested add_sub1 &&
 663                (
 664                        cd submodule_update &&
 665                        git -C sub1 checkout -b keep_branch &&
 666                        git -C sub1 rev-parse HEAD >expect &&
 667                        git branch -t modify_sub1 origin/modify_sub1 &&
 668                        $command modify_sub1 &&
 669                        test_superproject_content origin/modify_sub1 &&
 670                        test_submodule_content sub1 origin/modify_sub1 &&
 671                        git -C sub1 rev-parse keep_branch >actual &&
 672                        test_cmp expect actual &&
 673                        test_must_fail git -C sub1 symbolic-ref HEAD
 674                )
 675        '
 676
 677        # Replacing a tracked file with a submodule produces a checked out submodule
 678        test_expect_success "$command: replace tracked file with submodule checks out submodule" '
 679                prolog &&
 680                reset_work_tree_to_interested replace_sub1_with_file &&
 681                (
 682                        cd submodule_update &&
 683                        git branch -t replace_file_with_sub1 origin/replace_file_with_sub1 &&
 684                        $command replace_file_with_sub1 &&
 685                        test_superproject_content origin/replace_file_with_sub1 &&
 686                        test_submodule_content sub1 origin/replace_file_with_sub1
 687                )
 688        '
 689        # ... as does removing a directory with tracked files with a submodule.
 690        test_expect_success "$command: replace directory with submodule" '
 691                prolog &&
 692                reset_work_tree_to_interested replace_sub1_with_directory &&
 693                (
 694                        cd submodule_update &&
 695                        git branch -t replace_directory_with_sub1 origin/replace_directory_with_sub1 &&
 696                        $command replace_directory_with_sub1 &&
 697                        test_superproject_content origin/replace_directory_with_sub1 &&
 698                        test_submodule_content sub1 origin/replace_directory_with_sub1
 699                )
 700        '
 701
 702        ######################## Disappearing submodule #######################
 703        # Removing a submodule removes its work tree ...
 704        test_expect_success "$command: removed submodule removes submodules working tree" '
 705                prolog &&
 706                reset_work_tree_to_interested add_sub1 &&
 707                (
 708                        cd submodule_update &&
 709                        git branch -t remove_sub1 origin/remove_sub1 &&
 710                        $command remove_sub1 &&
 711                        test_superproject_content origin/remove_sub1 &&
 712                        ! test -e sub1 &&
 713                        test_must_fail git config -f .git/modules/sub1/config core.worktree
 714                )
 715        '
 716        # ... absorbing a .git directory along the way.
 717        test_expect_success "$command: removed submodule absorbs submodules .git directory" '
 718                prolog &&
 719                reset_work_tree_to_interested add_sub1 &&
 720                (
 721                        cd submodule_update &&
 722                        git branch -t remove_sub1 origin/remove_sub1 &&
 723                        replace_gitfile_with_git_dir sub1 &&
 724                        rm -rf .git/modules &&
 725                        $command remove_sub1 &&
 726                        test_superproject_content origin/remove_sub1 &&
 727                        ! test -e sub1 &&
 728                        test_git_directory_exists sub1
 729                )
 730        '
 731
 732        # Replacing it with a file ...
 733        test_expect_success "$command: replace submodule with a file" '
 734                prolog &&
 735                reset_work_tree_to_interested add_sub1 &&
 736                (
 737                        cd submodule_update &&
 738                        git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
 739                        $command replace_sub1_with_file &&
 740                        test_superproject_content origin/replace_sub1_with_file &&
 741                        test -f sub1
 742                )
 743        '
 744        RESULTDS=success
 745        if test "$KNOWN_FAILURE_DIRECTORY_SUBMODULE_CONFLICTS" = 1
 746        then
 747                RESULTDS=failure
 748        fi
 749        # ... must check its local work tree for untracked files
 750        test_expect_$RESULTDS "$command: replace submodule with a file must fail with untracked files" '
 751                prolog &&
 752                reset_work_tree_to_interested add_sub1 &&
 753                (
 754                        cd submodule_update &&
 755                        git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
 756                        : >sub1/untrackedfile &&
 757                        test_must_fail $command replace_sub1_with_file &&
 758                        test_superproject_content origin/add_sub1 &&
 759                        test_submodule_content sub1 origin/add_sub1
 760                        test -f sub1/untracked_file
 761                )
 762        '
 763
 764        ########################## Modified submodule #########################
 765        # Updating a submodule sha1 updates the submodule's work tree
 766        test_expect_success "$command: modified submodule updates submodule work tree" '
 767                prolog &&
 768                reset_work_tree_to_interested add_sub1 &&
 769                (
 770                        cd submodule_update &&
 771                        git branch -t modify_sub1 origin/modify_sub1 &&
 772                        $command modify_sub1 &&
 773                        test_superproject_content origin/modify_sub1 &&
 774                        test_submodule_content sub1 origin/modify_sub1
 775                )
 776        '
 777        # Updating a submodule to an invalid sha1 doesn't update the
 778        # superproject nor the submodule's work tree.
 779        test_expect_success "$command: updating to a missing submodule commit fails" '
 780                prolog &&
 781                reset_work_tree_to_interested add_sub1 &&
 782                (
 783                        cd submodule_update &&
 784                        git branch -t invalid_sub1 origin/invalid_sub1 &&
 785                        test_must_fail $command invalid_sub1 &&
 786                        test_superproject_content origin/add_sub1 &&
 787                        test_submodule_content sub1 origin/add_sub1
 788                )
 789        '
 790}
 791
 792# Declares and invokes several tests that, in various situations, checks that
 793# the provided Git command, when invoked with --recurse-submodules:
 794#  - succeeds in updating the worktree and index of a superproject to a target
 795#    commit, or fails atomically (depending on the test situation)
 796#  - if succeeds, the contents of submodule directories are updated
 797#
 798# Specify the Git command so that "git $GIT_COMMAND --recurse-submodules"
 799# works.
 800#
 801# If the command under test is known to not work with submodules in certain
 802# conditions, set the appropriate KNOWN_FAILURE_* variable used in the tests
 803# below to 1.
 804#
 805# Use as follows:
 806#
 807# test_submodule_switch_recursing_with_args "$GIT_COMMAND"
 808test_submodule_switch_recursing_with_args () {
 809        cmd_args="$1"
 810        command="git $cmd_args --recurse-submodules"
 811        test_submodule_recursing_with_args_common "$command"
 812
 813        RESULTDS=success
 814        if test "$KNOWN_FAILURE_DIRECTORY_SUBMODULE_CONFLICTS" = 1
 815        then
 816                RESULTDS=failure
 817        fi
 818        RESULTOI=success
 819        if test "$KNOWN_FAILURE_SUBMODULE_OVERWRITE_IGNORED_UNTRACKED" = 1
 820        then
 821                RESULTOI=failure
 822        fi
 823        # Switching to a commit letting a submodule appear cannot override an
 824        # untracked file.
 825        test_expect_success "$command: added submodule doesn't remove untracked file with same name" '
 826                prolog &&
 827                reset_work_tree_to_interested no_submodule &&
 828                (
 829                        cd submodule_update &&
 830                        git branch -t add_sub1 origin/add_sub1 &&
 831                        : >sub1 &&
 832                        test_must_fail $command add_sub1 &&
 833                        test_superproject_content origin/no_submodule &&
 834                        test_must_be_empty sub1
 835                )
 836        '
 837        # ... but an ignored file is fine.
 838        test_expect_$RESULTOI "$command: added submodule removes an untracked ignored file" '
 839                test_when_finished "rm submodule_update/.git/info/exclude" &&
 840                prolog &&
 841                reset_work_tree_to_interested no_submodule &&
 842                (
 843                        cd submodule_update &&
 844                        git branch -t add_sub1 origin/add_sub1 &&
 845                        : >sub1 &&
 846                        echo sub1 >.git/info/exclude
 847                        $command add_sub1 &&
 848                        test_superproject_content origin/add_sub1 &&
 849                        test_submodule_content sub1 origin/add_sub1
 850                )
 851        '
 852
 853        # Replacing a submodule with files in a directory must succeeds
 854        # when the submodule is clean
 855        test_expect_$RESULTDS "$command: replace submodule with a directory" '
 856                prolog &&
 857                reset_work_tree_to_interested add_sub1 &&
 858                (
 859                        cd submodule_update &&
 860                        git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
 861                        $command replace_sub1_with_directory &&
 862                        test_superproject_content origin/replace_sub1_with_directory &&
 863                        test_submodule_content sub1 origin/replace_sub1_with_directory
 864                )
 865        '
 866        # ... absorbing a .git directory.
 867        test_expect_$RESULTDS "$command: replace submodule containing a .git directory with a directory must absorb the git dir" '
 868                prolog &&
 869                reset_work_tree_to_interested add_sub1 &&
 870                (
 871                        cd submodule_update &&
 872                        git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
 873                        replace_gitfile_with_git_dir sub1 &&
 874                        rm -rf .git/modules &&
 875                        $command replace_sub1_with_directory &&
 876                        test_superproject_content origin/replace_sub1_with_directory &&
 877                        test_git_directory_exists sub1
 878                )
 879        '
 880
 881        # ... and ignored files are ignored
 882        test_expect_success "$command: replace submodule with a file works ignores ignored files in submodule" '
 883                test_when_finished "rm submodule_update/.git/modules/sub1/info/exclude" &&
 884                prolog &&
 885                reset_work_tree_to_interested add_sub1 &&
 886                (
 887                        cd submodule_update &&
 888                        git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
 889                        echo ignored >.git/modules/sub1/info/exclude &&
 890                        : >sub1/ignored &&
 891                        $command replace_sub1_with_file &&
 892                        test_superproject_content origin/replace_sub1_with_file &&
 893                        test -f sub1
 894                )
 895        '
 896
 897        test_expect_success "git -c submodule.recurse=true $cmd_args: modified submodule updates submodule work tree" '
 898                prolog &&
 899                reset_work_tree_to_interested add_sub1 &&
 900                (
 901                        cd submodule_update &&
 902                        git branch -t modify_sub1 origin/modify_sub1 &&
 903                        git -c submodule.recurse=true $cmd_args modify_sub1 &&
 904                        test_superproject_content origin/modify_sub1 &&
 905                        test_submodule_content sub1 origin/modify_sub1
 906                )
 907        '
 908
 909        # recursing deeper than one level doesn't work yet.
 910        test_expect_success "$command: modified submodule updates submodule recursively" '
 911                prolog &&
 912                reset_work_tree_to_interested add_nested_sub &&
 913                (
 914                        cd submodule_update &&
 915                        git branch -t modify_sub1_recursively origin/modify_sub1_recursively &&
 916                        $command modify_sub1_recursively &&
 917                        test_superproject_content origin/modify_sub1_recursively &&
 918                        test_submodule_content sub1 origin/modify_sub1_recursively &&
 919                        test_submodule_content -C sub1 sub2 origin/modify_sub1_recursively
 920                )
 921        '
 922}
 923
 924# Same as test_submodule_switch_recursing_with_args(), except that throwing
 925# away local changes in the superproject is allowed.
 926test_submodule_forced_switch_recursing_with_args () {
 927        cmd_args="$1"
 928        command="git $cmd_args --recurse-submodules"
 929        test_submodule_recursing_with_args_common "$command"
 930
 931        RESULT=success
 932        if test "$KNOWN_FAILURE_DIRECTORY_SUBMODULE_CONFLICTS" = 1
 933        then
 934                RESULT=failure
 935        fi
 936        # Switching to a commit letting a submodule appear does not care about
 937        # an untracked file.
 938        test_expect_success "$command: added submodule does remove untracked unignored file with same name when forced" '
 939                prolog &&
 940                reset_work_tree_to_interested no_submodule &&
 941                (
 942                        cd submodule_update &&
 943                        git branch -t add_sub1 origin/add_sub1 &&
 944                        >sub1 &&
 945                        $command add_sub1 &&
 946                        test_superproject_content origin/add_sub1 &&
 947                        test_submodule_content sub1 origin/add_sub1
 948                )
 949        '
 950
 951        # Replacing a submodule with files in a directory ...
 952        test_expect_success "$command: replace submodule with a directory" '
 953                prolog &&
 954                reset_work_tree_to_interested add_sub1 &&
 955                (
 956                        cd submodule_update &&
 957                        git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
 958                        $command replace_sub1_with_directory &&
 959                        test_superproject_content origin/replace_sub1_with_directory
 960                )
 961        '
 962        # ... absorbing a .git directory.
 963        test_expect_success "$command: replace submodule containing a .git directory with a directory must fail" '
 964                prolog &&
 965                reset_work_tree_to_interested add_sub1 &&
 966                (
 967                        cd submodule_update &&
 968                        git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
 969                        replace_gitfile_with_git_dir sub1 &&
 970                        rm -rf .git/modules/sub1 &&
 971                        $command replace_sub1_with_directory &&
 972                        test_superproject_content origin/replace_sub1_with_directory &&
 973                        test_submodule_content sub1 origin/modify_sub1
 974                        test_git_directory_exists sub1
 975                )
 976        '
 977
 978        # ... even if the submodule contains ignored files
 979        test_expect_success "$command: replace submodule with a file ignoring ignored files" '
 980                prolog &&
 981                reset_work_tree_to_interested add_sub1 &&
 982                (
 983                        cd submodule_update &&
 984                        git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
 985                        : >sub1/expect &&
 986                        $command replace_sub1_with_file &&
 987                        test_superproject_content origin/replace_sub1_with_file
 988                )
 989        '
 990
 991        # Updating a submodule from an invalid sha1 updates
 992        test_expect_success "$command: modified submodule does update submodule work tree from invalid commit" '
 993                prolog &&
 994                reset_work_tree_to_interested invalid_sub1 &&
 995                (
 996                        cd submodule_update &&
 997                        git branch -t valid_sub1 origin/valid_sub1 &&
 998                        $command valid_sub1 &&
 999                        test_superproject_content origin/valid_sub1 &&
1000                        test_submodule_content sub1 origin/valid_sub1
1001                )
1002        '
1003
1004        # Old versions of Git were buggy writing the .git link file
1005        # (e.g. before f8eaa0ba98b and then moving the superproject repo
1006        # whose submodules contained absolute paths)
1007        test_expect_success "$command: updating submodules fixes .git links" '
1008                prolog &&
1009                reset_work_tree_to_interested add_sub1 &&
1010                (
1011                        cd submodule_update &&
1012                        git branch -t modify_sub1 origin/modify_sub1 &&
1013                        echo "gitdir: bogus/path" >sub1/.git &&
1014                        $command modify_sub1 &&
1015                        test_superproject_content origin/modify_sub1 &&
1016                        test_submodule_content sub1 origin/modify_sub1
1017                )
1018        '
1019
1020        test_expect_success "$command: changed submodule worktree is reset" '
1021                prolog &&
1022                reset_work_tree_to_interested add_sub1 &&
1023                (
1024                        cd submodule_update &&
1025                        rm sub1/file1 &&
1026                        : >sub1/new_file &&
1027                        git -C sub1 add new_file &&
1028                        $command HEAD &&
1029                        test_path_is_file sub1/file1 &&
1030                        test_path_is_missing sub1/new_file
1031                )
1032        '
1033}