t/lib-submodule-update.sh

   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 # - Submodule updated to invalid commit (add_sub1 => invalid_sub1)
   8 # - Submodule updated from invalid commit (invalid_sub1 => valid_sub1)
   9 # - Submodule replaced by tracked files in directory (add_sub1 =>
  10 #   replace_sub1_with_directory)
  11 # - Directory containing tracked files replaced by submodule
  12 #   (replace_sub1_with_directory => replace_directory_with_sub1)
  13 # - Submodule replaced by tracked file with the same name (add_sub1 =>
  14 #   replace_sub1_with_file)
  15 # - Tracked file replaced by submodule (replace_sub1_with_file =>
  16 #   replace_file_with_sub1)
  17 #
  18 #                   --O-----O
  19 #                  /  ^     replace_directory_with_sub1
  20 #                 /   replace_sub1_with_directory
  21 #                /----O
  22 #               /     ^
  23 #              /      modify_sub1
  24 #      O------O-------O
  25 #      ^      ^\      ^
  26 #      |      | \     remove_sub1
  27 #      |      |  -----O-----O
  28 #      |      |   \   ^     replace_file_with_sub1
  29 #      |      |    \  replace_sub1_with_file
  30 #      |   add_sub1 --O-----O
  31 # no_submodule        ^     valid_sub1
  32 #                     invalid_sub1
  33 #
  34 create_lib_submodule_repo () {
  35         git init submodule_update_repo &&
  36         (
  37                 cd submodule_update_repo &&
  38                 echo "expect" >>.gitignore &&
  39                 echo "actual" >>.gitignore &&
  40                 echo "x" >file1 &&
  41                 echo "y" >file2 &&
  42                 git add .gitignore file1 file2 &&
  43                 git commit -m "Base" &&
  44                 git branch "no_submodule" &&
  45
  46                 git checkout -b "add_sub1" &&
  47                 git submodule add ./. sub1 &&
  48                 git config -f .gitmodules submodule.sub1.ignore all &&
  49                 git config submodule.sub1.ignore all &&
  50                 git add .gitmodules &&
  51                 git commit -m "Add sub1" &&
  52                 git checkout -b remove_sub1 &&
  53                 git revert HEAD &&
  54
  55                 git checkout -b "modify_sub1" "add_sub1" &&
  56                 git submodule update &&
  57                 (
  58                         cd sub1 &&
  59                         git fetch &&
  60                         git checkout -b "modifications" &&
  61                         echo "z" >file2 &&
  62                         echo "x" >file3 &&
  63                         git add file2 file3 &&
  64                         git commit -m "modified file2 and added file3" &&
  65                         git push origin modifications
  66                 ) &&
  67                 git add sub1 &&
  68                 git commit -m "Modify sub1" &&
  69
  70                 git checkout -b "replace_sub1_with_directory" "add_sub1" &&
  71                 git submodule update &&
  72                 (
  73                         cd sub1 &&
  74                         git checkout modifications
  75                 ) &&
  76                 git rm --cached sub1 &&
  77                 rm sub1/.git* &&
  78                 git config -f .gitmodules --remove-section "submodule.sub1" &&
  79                 git add .gitmodules sub1/* &&
  80                 git commit -m "Replace sub1 with directory" &&
  81                 git checkout -b replace_directory_with_sub1 &&
  82                 git revert HEAD &&
  83
  84                 git checkout -b "replace_sub1_with_file" "add_sub1" &&
  85                 git rm sub1 &&
  86                 echo "content" >sub1 &&
  87                 git add sub1 &&
  88                 git commit -m "Replace sub1 with file" &&
  89                 git checkout -b replace_file_with_sub1 &&
  90                 git revert HEAD &&
  91
  92                 git checkout -b "invalid_sub1" "add_sub1" &&
  93                 git update-index --cacheinfo 160000 0123456789012345678901234567890123456789 sub1 &&
  94                 git commit -m "Invalid sub1 commit" &&
  95                 git checkout -b valid_sub1 &&
  96                 git revert HEAD &&
  97                 git checkout master
  98         )
  99 }
 100
 101 # Helper function to replace gitfile with .git directory
 102 replace_gitfile_with_git_dir () {
 103         (
 104                 cd "$1" &&
 105                 git_dir="$(git rev-parse --git-dir)" &&
 106                 rm -f .git &&
 107                 cp -R "$git_dir" .git &&
 108                 GIT_WORK_TREE=. git config --unset core.worktree
 109         )
 110 }
 111
 112 # Test that the .git directory in the submodule is unchanged (except for the
 113 # core.worktree setting, which appears only in $GIT_DIR/modules/$1/config).
 114 # Call this function before test_submodule_content as the latter might
 115 # write the index file leading to false positive index differences.
 116 #
 117 # Note that this only supports submodules at the root level of the
 118 # superproject, with the default name, i.e. same as its path.
 119 test_git_directory_is_unchanged () {
 120         (
 121                 cd ".git/modules/$1" &&
 122                 # does core.worktree point at the right place?
 123                 test "$(git config core.worktree)" = "../../../$1" &&
 124                 # remove it temporarily before comparing, as
 125                 # "$1/.git/config" lacks it...
 126                 git config --unset core.worktree
 127         ) &&
 128         diff -r ".git/modules/$1" "$1/.git" &&
 129         (
 130                 # ... and then restore.
 131                 cd ".git/modules/$1" &&
 132                 git config core.worktree "../../../$1"
 133         )
 134 }
 135
 136 # Helper function to be executed at the start of every test below, it sets up
 137 # the submodule repo if it doesn't exist and configures the most problematic
 138 # settings for diff.ignoreSubmodules.
 139 prolog () {
 140         (test -d submodule_update_repo || create_lib_submodule_repo) &&
 141         test_config_global diff.ignoreSubmodules all &&
 142         test_config diff.ignoreSubmodules all
 143 }
 144
 145 # Helper function to bring work tree back into the state given by the
 146 # commit. This includes trying to populate sub1 accordingly if it exists and
 147 # should be updated to an existing commit.
 148 reset_work_tree_to () {
 149         rm -rf submodule_update &&
 150         git clone submodule_update_repo submodule_update &&
 151         (
 152                 cd submodule_update &&
 153                 rm -rf sub1 &&
 154                 git checkout -f "$1" &&
 155                 git status -u -s >actual &&
 156                 test_must_be_empty actual &&
 157                 sha1=$(git rev-parse --revs-only HEAD:sub1) &&
 158                 if test -n "$sha1" &&
 159                    test $(cd "sub1" && git rev-parse --verify "$sha1^{commit}")
 160                 then
 161                         git submodule update --init --recursive "sub1"
 162                 fi
 163         )
 164 }
 165
 166 # Test that the superproject contains the content according to commit "$1"
 167 # (the work tree must match the index for everything but submodules but the
 168 # index must exactly match the given commit including any submodule SHA-1s).
 169 test_superproject_content () {
 170         git diff-index --cached "$1" >actual &&
 171         test_must_be_empty actual &&
 172         git diff-files --ignore-submodules >actual &&
 173         test_must_be_empty actual
 174 }
 175
 176 # Test that the given submodule at path "$1" contains the content according
 177 # to the submodule commit recorded in the superproject's commit "$2"
 178 test_submodule_content () {
 179         if test $# != 2
 180         then
 181                 echo "test_submodule_content needs two arguments"
 182                 return 1
 183         fi &&
 184         submodule="$1" &&
 185         commit="$2" &&
 186         test -d "$submodule"/ &&
 187         if ! test -f "$submodule"/.git && ! test -d "$submodule"/.git
 188         then
 189                 echo "Submodule $submodule is not populated"
 190                 return 1
 191         fi &&
 192         sha1=$(git rev-parse --verify "$commit:$submodule") &&
 193         if test -z "$sha1"
 194         then
 195                 echo "Couldn't retrieve SHA-1 of $submodule for $commit"
 196                 return 1
 197         fi &&
 198         (
 199                 cd "$submodule" &&
 200                 git status -u -s >actual &&
 201                 test_must_be_empty actual &&
 202                 git diff "$sha1" >actual &&
 203                 test_must_be_empty actual
 204         )
 205 }
 206
 207 # Test that the following transitions are correctly handled:
 208 # - Updated submodule
 209 # - New submodule
 210 # - Removed submodule
 211 # - Directory containing tracked files replaced by submodule
 212 # - Submodule replaced by tracked files in directory
 213 # - Submodule replaced by tracked file with the same name
 214 # - tracked file replaced by submodule
 215 #
 216 # The default is that submodule contents aren't changed until "git submodule
 217 # update" is run. And even then that command doesn't delete the work tree of
 218 # a removed submodule.
 219 #
 220 # Removing a submodule containing a .git directory must fail even when forced
 221 # to protect the history!
 222 #
 223
 224 # Test that submodule contents are currently not updated when switching
 225 # between commits that change a submodule.
 226 test_submodule_switch () {
 227         command="$1"
 228         ######################### Appearing submodule #########################
 229         # Switching to a commit letting a submodule appear creates empty dir ...
 230         if test "$KNOWN_FAILURE_STASH_DOES_IGNORE_SUBMODULE_CHANGES" = 1
 231         then
 232                 # Restoring stash fails to restore submodule index entry
 233                 RESULT="failure"
 234         else
 235                 RESULT="success"
 236         fi
 237         test_expect_$RESULT "$command: added submodule creates empty directory" '
 238                 prolog &&
 239                 reset_work_tree_to no_submodule &&
 240                 (
 241                         cd submodule_update &&
 242                         git branch -t add_sub1 origin/add_sub1 &&
 243                         $command add_sub1 &&
 244                         test_superproject_content origin/add_sub1 &&
 245                         test_dir_is_empty sub1 &&
 246                         git submodule update --init --recursive &&
 247                         test_submodule_content sub1 origin/add_sub1
 248                 )
 249         '
 250         # ... and doesn't care if it already exists ...
 251         test_expect_$RESULT "$command: added submodule leaves existing empty directory alone" '
 252                 prolog &&
 253                 reset_work_tree_to no_submodule &&
 254                 (
 255                         cd submodule_update &&
 256                         mkdir sub1 &&
 257                         git branch -t add_sub1 origin/add_sub1 &&
 258                         $command add_sub1 &&
 259                         test_superproject_content origin/add_sub1 &&
 260                         test_dir_is_empty sub1 &&
 261                         git submodule update --init --recursive &&
 262                         test_submodule_content sub1 origin/add_sub1
 263                 )
 264         '
 265         # ... unless there is an untracked file in its place.
 266         test_expect_success "$command: added submodule doesn't remove untracked unignored file with same name" '
 267                 prolog &&
 268                 reset_work_tree_to no_submodule &&
 269                 (
 270                         cd submodule_update &&
 271                         git branch -t add_sub1 origin/add_sub1 &&
 272                         >sub1 &&
 273                         test_must_fail $command add_sub1 &&
 274                         test_superproject_content origin/no_submodule &&
 275                         test_must_be_empty sub1
 276                 )
 277         '
 278         # Replacing a tracked file with a submodule produces an empty
 279         # directory ...
 280         test_expect_$RESULT "$command: replace tracked file with submodule creates empty directory" '
 281                 prolog &&
 282                 reset_work_tree_to replace_sub1_with_file &&
 283                 (
 284                         cd submodule_update &&
 285                         git branch -t replace_file_with_sub1 origin/replace_file_with_sub1 &&
 286                         $command replace_file_with_sub1 &&
 287                         test_superproject_content origin/replace_file_with_sub1 &&
 288                         test_dir_is_empty sub1 &&
 289                         git submodule update --init --recursive &&
 290                         test_submodule_content sub1 origin/replace_file_with_sub1
 291                 )
 292         '
 293         # ... as does removing a directory with tracked files with a
 294         # submodule.
 295         if test "$KNOWN_FAILURE_NOFF_MERGE_DOESNT_CREATE_EMPTY_SUBMODULE_DIR" = 1
 296         then
 297                 # Non fast-forward merges fail with "Directory sub1 doesn't
 298                 # exist. sub1" because the empty submodule directory is not
 299                 # created
 300                 RESULT="failure"
 301         else
 302                 RESULT="success"
 303         fi
 304         test_expect_$RESULT "$command: replace directory with submodule" '
 305                 prolog &&
 306                 reset_work_tree_to replace_sub1_with_directory &&
 307                 (
 308                         cd submodule_update &&
 309                         git branch -t replace_directory_with_sub1 origin/replace_directory_with_sub1 &&
 310                         $command replace_directory_with_sub1 &&
 311                         test_superproject_content origin/replace_directory_with_sub1 &&
 312                         test_dir_is_empty sub1 &&
 313                         git submodule update --init --recursive &&
 314                         test_submodule_content sub1 origin/replace_directory_with_sub1
 315                 )
 316         '
 317
 318         ######################## Disappearing submodule #######################
 319         # Removing a submodule doesn't remove its work tree ...
 320         if test "$KNOWN_FAILURE_STASH_DOES_IGNORE_SUBMODULE_CHANGES" = 1
 321         then
 322                 RESULT="failure"
 323         else
 324                 RESULT="success"
 325         fi
 326         test_expect_$RESULT "$command: removed submodule leaves submodule directory and its contents in place" '
 327                 prolog &&
 328                 reset_work_tree_to add_sub1 &&
 329                 (
 330                         cd submodule_update &&
 331                         git branch -t remove_sub1 origin/remove_sub1 &&
 332                         $command remove_sub1 &&
 333                         test_superproject_content origin/remove_sub1 &&
 334                         test_submodule_content sub1 origin/add_sub1
 335                 )
 336         '
 337         # ... especially when it contains a .git directory.
 338         test_expect_$RESULT "$command: removed submodule leaves submodule containing a .git directory alone" '
 339                 prolog &&
 340                 reset_work_tree_to add_sub1 &&
 341                 (
 342                         cd submodule_update &&
 343                         git branch -t remove_sub1 origin/remove_sub1 &&
 344                         replace_gitfile_with_git_dir sub1 &&
 345                         $command remove_sub1 &&
 346                         test_superproject_content origin/remove_sub1 &&
 347                         test_git_directory_is_unchanged sub1 &&
 348                         test_submodule_content sub1 origin/add_sub1
 349                 )
 350         '
 351         # Replacing a submodule with files in a directory must fail as the
 352         # submodule work tree isn't removed ...
 353         if test "$KNOWN_FAILURE_NOFF_MERGE_ATTEMPTS_TO_MERGE_REMOVED_SUBMODULE_FILES" = 1
 354         then
 355                 # Non fast-forward merges attempt to merge the former
 356                 # submodule files with the newly checked out ones in the
 357                 # directory of the same name while it shouldn't.
 358                 RESULT="failure"
 359         else
 360                 RESULT="success"
 361         fi
 362         test_expect_$RESULT "$command: replace submodule with a directory must fail" '
 363                 prolog &&
 364                 reset_work_tree_to add_sub1 &&
 365                 (
 366                         cd submodule_update &&
 367                         git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
 368                         test_must_fail $command replace_sub1_with_directory &&
 369                         test_superproject_content origin/add_sub1 &&
 370                         test_submodule_content sub1 origin/add_sub1
 371                 )
 372         '
 373         # ... especially when it contains a .git directory.
 374         test_expect_$RESULT "$command: replace submodule containing a .git directory with a directory must fail" '
 375                 prolog &&
 376                 reset_work_tree_to add_sub1 &&
 377                 (
 378                         cd submodule_update &&
 379                         git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
 380                         replace_gitfile_with_git_dir sub1 &&
 381                         test_must_fail $command replace_sub1_with_directory &&
 382                         test_superproject_content origin/add_sub1 &&
 383                         test_git_directory_is_unchanged sub1 &&
 384                         test_submodule_content sub1 origin/add_sub1
 385                 )
 386         '
 387         # Replacing it with a file must fail as it could throw away any local
 388         # work tree changes ...
 389         test_expect_failure "$command: replace submodule with a file must fail" '
 390                 prolog &&
 391                 reset_work_tree_to add_sub1 &&
 392                 (
 393                         cd submodule_update &&
 394                         git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
 395                         test_must_fail $command replace_sub1_with_file &&
 396                         test_superproject_content origin/add_sub1 &&
 397                         test_submodule_content sub1 origin/add_sub1
 398                 )
 399         '
 400         # ... or even destroy unpushed parts of submodule history if that
 401         # still uses a .git directory.
 402         test_expect_failure "$command: replace submodule containing a .git directory with a file must fail" '
 403                 prolog &&
 404                 reset_work_tree_to add_sub1 &&
 405                 (
 406                         cd submodule_update &&
 407                         git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
 408                         replace_gitfile_with_git_dir sub1 &&
 409                         test_must_fail $command replace_sub1_with_file &&
 410                         test_superproject_content origin/add_sub1 &&
 411                         test_git_directory_is_unchanged sub1 &&
 412                         test_submodule_content sub1 origin/add_sub1
 413                 )
 414         '
 415
 416         ########################## Modified submodule #########################
 417         # Updating a submodule sha1 doesn't update the submodule's work tree
 418         if test "$KNOWN_FAILURE_CHERRY_PICK_SEES_EMPTY_COMMIT" = 1
 419         then
 420                 # When cherry picking a SHA-1 update for an ignored submodule
 421                 # the commit incorrectly fails with "The previous cherry-pick
 422                 # is now empty, possibly due to conflict resolution."
 423                 RESULT="failure"
 424         else
 425                 RESULT="success"
 426         fi
 427         test_expect_$RESULT "$command: modified submodule does not update submodule work tree" '
 428                 prolog &&
 429                 reset_work_tree_to add_sub1 &&
 430                 (
 431                         cd submodule_update &&
 432                         git branch -t modify_sub1 origin/modify_sub1 &&
 433                         $command modify_sub1 &&
 434                         test_superproject_content origin/modify_sub1 &&
 435                         test_submodule_content sub1 origin/add_sub1 &&
 436                         git submodule update &&
 437                         test_submodule_content sub1 origin/modify_sub1
 438                 )
 439         '
 440
 441         # Updating a submodule to an invalid sha1 doesn't update the
 442         # submodule's work tree, subsequent update will fail
 443         test_expect_$RESULT "$command: modified submodule does not update submodule work tree to invalid commit" '
 444                 prolog &&
 445                 reset_work_tree_to add_sub1 &&
 446                 (
 447                         cd submodule_update &&
 448                         git branch -t invalid_sub1 origin/invalid_sub1 &&
 449                         $command invalid_sub1 &&
 450                         test_superproject_content origin/invalid_sub1 &&
 451                         test_submodule_content sub1 origin/add_sub1 &&
 452                         test_must_fail git submodule update &&
 453                         test_submodule_content sub1 origin/add_sub1
 454                 )
 455         '
 456         # Updating a submodule from an invalid sha1 doesn't update the
 457         # submodule's work tree, subsequent update will succeed
 458         test_expect_$RESULT "$command: modified submodule does not update submodule work tree from invalid commit" '
 459                 prolog &&
 460                 reset_work_tree_to invalid_sub1 &&
 461                 (
 462                         cd submodule_update &&
 463                         git branch -t valid_sub1 origin/valid_sub1 &&
 464                         $command valid_sub1 &&
 465                         test_superproject_content origin/valid_sub1 &&
 466                         test_dir_is_empty sub1 &&
 467                         git submodule update --init --recursive &&
 468                         test_submodule_content sub1 origin/valid_sub1
 469                 )
 470         '
 471 }
 472
 473 # Test that submodule contents are currently not updated when switching
 474 # between commits that change a submodule, but throwing away local changes in
 475 # the superproject is allowed.
 476 test_submodule_forced_switch () {
 477         command="$1"
 478         ######################### Appearing submodule #########################
 479         # Switching to a commit letting a submodule appear creates empty dir ...
 480         test_expect_success "$command: added submodule creates empty directory" '
 481                 prolog &&
 482                 reset_work_tree_to no_submodule &&
 483                 (
 484                         cd submodule_update &&
 485                         git branch -t add_sub1 origin/add_sub1 &&
 486                         $command add_sub1 &&
 487                         test_superproject_content origin/add_sub1 &&
 488                         test_dir_is_empty sub1 &&
 489                         git submodule update --init --recursive &&
 490                         test_submodule_content sub1 origin/add_sub1
 491                 )
 492         '
 493         # ... and doesn't care if it already exists ...
 494         test_expect_success "$command: added submodule leaves existing empty directory alone" '
 495                 prolog &&
 496                 reset_work_tree_to no_submodule &&
 497                 (
 498                         cd submodule_update &&
 499                         git branch -t add_sub1 origin/add_sub1 &&
 500                         mkdir sub1 &&
 501                         $command add_sub1 &&
 502                         test_superproject_content origin/add_sub1 &&
 503                         test_dir_is_empty sub1 &&
 504                         git submodule update --init --recursive &&
 505                         test_submodule_content sub1 origin/add_sub1
 506                 )
 507         '
 508         # ... unless there is an untracked file in its place.
 509         test_expect_success "$command: added submodule does remove untracked unignored file with same name when forced" '
 510                 prolog &&
 511                 reset_work_tree_to no_submodule &&
 512                 (
 513                         cd submodule_update &&
 514                         git branch -t add_sub1 origin/add_sub1 &&
 515                         >sub1 &&
 516                         $command add_sub1 &&
 517                         test_superproject_content origin/add_sub1 &&
 518                         test_dir_is_empty sub1
 519                 )
 520         '
 521         # Replacing a tracked file with a submodule produces an empty
 522         # directory ...
 523         test_expect_success "$command: replace tracked file with submodule creates empty directory" '
 524                 prolog &&
 525                 reset_work_tree_to replace_sub1_with_file &&
 526                 (
 527                         cd submodule_update &&
 528                         git branch -t replace_file_with_sub1 origin/replace_file_with_sub1 &&
 529                         $command replace_file_with_sub1 &&
 530                         test_superproject_content origin/replace_file_with_sub1 &&
 531                         test_dir_is_empty sub1 &&
 532                         git submodule update --init --recursive &&
 533                         test_submodule_content sub1 origin/replace_file_with_sub1
 534                 )
 535         '
 536         # ... as does removing a directory with tracked files with a
 537         # submodule.
 538         test_expect_success "$command: replace directory with submodule" '
 539                 prolog &&
 540                 reset_work_tree_to replace_sub1_with_directory &&
 541                 (
 542                         cd submodule_update &&
 543                         git branch -t replace_directory_with_sub1 origin/replace_directory_with_sub1 &&
 544                         $command replace_directory_with_sub1 &&
 545                         test_superproject_content origin/replace_directory_with_sub1 &&
 546                         test_dir_is_empty sub1 &&
 547                         git submodule update --init --recursive &&
 548                         test_submodule_content sub1 origin/replace_directory_with_sub1
 549                 )
 550         '
 551
 552         ######################## Disappearing submodule #######################
 553         # Removing a submodule doesn't remove its work tree ...
 554         test_expect_success "$command: removed submodule leaves submodule directory and its contents in place" '
 555                 prolog &&
 556                 reset_work_tree_to add_sub1 &&
 557                 (
 558                         cd submodule_update &&
 559                         git branch -t remove_sub1 origin/remove_sub1 &&
 560                         $command remove_sub1 &&
 561                         test_superproject_content origin/remove_sub1 &&
 562                         test_submodule_content sub1 origin/add_sub1
 563                 )
 564         '
 565         # ... especially when it contains a .git directory.
 566         test_expect_success "$command: removed submodule leaves submodule containing a .git directory alone" '
 567                 prolog &&
 568                 reset_work_tree_to add_sub1 &&
 569                 (
 570                         cd submodule_update &&
 571                         git branch -t remove_sub1 origin/remove_sub1 &&
 572                         replace_gitfile_with_git_dir sub1 &&
 573                         $command remove_sub1 &&
 574                         test_superproject_content origin/remove_sub1 &&
 575                         test_git_directory_is_unchanged sub1 &&
 576                         test_submodule_content sub1 origin/add_sub1
 577                 )
 578         '
 579         # Replacing a submodule with files in a directory must fail as the
 580         # submodule work tree isn't removed ...
 581         test_expect_failure "$command: replace submodule with a directory must fail" '
 582                 prolog &&
 583                 reset_work_tree_to add_sub1 &&
 584                 (
 585                         cd submodule_update &&
 586                         git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
 587                         test_must_fail $command replace_sub1_with_directory &&
 588                         test_superproject_content origin/add_sub1 &&
 589                         test_submodule_content sub1 origin/add_sub1
 590                 )
 591         '
 592         # ... especially when it contains a .git directory.
 593         test_expect_failure "$command: replace submodule containing a .git directory with a directory must fail" '
 594                 prolog &&
 595                 reset_work_tree_to add_sub1 &&
 596                 (
 597                         cd submodule_update &&
 598                         git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
 599                         replace_gitfile_with_git_dir sub1 &&
 600                         test_must_fail $command replace_sub1_with_directory &&
 601                         test_superproject_content origin/add_sub1 &&
 602                         test_git_directory_is_unchanged sub1 &&
 603                         test_submodule_content sub1 origin/add_sub1
 604                 )
 605         '
 606         # Replacing it with a file must fail as it could throw away any local
 607         # work tree changes ...
 608         test_expect_failure "$command: replace submodule with a file must fail" '
 609                 prolog &&
 610                 reset_work_tree_to add_sub1 &&
 611                 (
 612                         cd submodule_update &&
 613                         git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
 614                         test_must_fail $command replace_sub1_with_file &&
 615                         test_superproject_content origin/add_sub1 &&
 616                         test_submodule_content sub1 origin/add_sub1
 617                 )
 618         '
 619         # ... or even destroy unpushed parts of submodule history if that
 620         # still uses a .git directory.
 621         test_expect_failure "$command: replace submodule containing a .git directory with a file must fail" '
 622                 prolog &&
 623                 reset_work_tree_to add_sub1 &&
 624                 (
 625                         cd submodule_update &&
 626                         git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
 627                         replace_gitfile_with_git_dir sub1 &&
 628                         test_must_fail $command replace_sub1_with_file &&
 629                         test_superproject_content origin/add_sub1 &&
 630                         test_git_directory_is_unchanged sub1 &&
 631                         test_submodule_content sub1 origin/add_sub1
 632                 )
 633         '
 634
 635         ########################## Modified submodule #########################
 636         # Updating a submodule sha1 doesn't update the submodule's work tree
 637         test_expect_success "$command: modified submodule does not update submodule work tree" '
 638                 prolog &&
 639                 reset_work_tree_to add_sub1 &&
 640                 (
 641                         cd submodule_update &&
 642                         git branch -t modify_sub1 origin/modify_sub1 &&
 643                         $command modify_sub1 &&
 644                         test_superproject_content origin/modify_sub1 &&
 645                         test_submodule_content sub1 origin/add_sub1 &&
 646                         git submodule update &&
 647                         test_submodule_content sub1 origin/modify_sub1
 648                 )
 649         '
 650         # Updating a submodule to an invalid sha1 doesn't update the
 651         # submodule's work tree, subsequent update will fail
 652         test_expect_success "$command: modified submodule does not update submodule work tree to invalid commit" '
 653                 prolog &&
 654                 reset_work_tree_to add_sub1 &&
 655                 (
 656                         cd submodule_update &&
 657                         git branch -t invalid_sub1 origin/invalid_sub1 &&
 658                         $command invalid_sub1 &&
 659                         test_superproject_content origin/invalid_sub1 &&
 660                         test_submodule_content sub1 origin/add_sub1 &&
 661                         test_must_fail git submodule update &&
 662                         test_submodule_content sub1 origin/add_sub1
 663                 )
 664         '
 665         # Updating a submodule from an invalid sha1 doesn't update the
 666         # submodule's work tree, subsequent update will succeed
 667         test_expect_success "$command: modified submodule does not update submodule work tree from invalid commit" '
 668                 prolog &&
 669                 reset_work_tree_to invalid_sub1 &&
 670                 (
 671                         cd submodule_update &&
 672                         git branch -t valid_sub1 origin/valid_sub1 &&
 673                         $command valid_sub1 &&
 674                         test_superproject_content origin/valid_sub1 &&
 675                         test_dir_is_empty sub1 &&
 676                         git submodule update --init --recursive &&
 677                         test_submodule_content sub1 origin/valid_sub1
 678                 )
 679         '
 680 }