t/t7400-submodule-basic.sh

   1 #!/bin/sh
   2 #
   3 # Copyright (c) 2007 Lars Hjemli
   4 #
   5
   6 test_description='Basic porcelain support for submodules
   7
   8 This test tries to verify basic sanity of the init, update and status
   9 subcommands of git submodule.
  10 '
  11
  12 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main
  13 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME
  14
  15 . ./test-lib.sh
  16
  17 test_expect_success 'setup - enable local submodules' '
  18         git config --global protocol.file.allow always
  19 '
  20
  21 test_expect_success 'submodule usage: -h' '
  22         git submodule -h >out 2>err &&
  23         grep "^usage: git submodule" out &&
  24         test_must_be_empty err
  25 '
  26
  27 test_expect_success 'submodule usage: --recursive' '
  28         test_expect_code 1 git submodule --recursive >out 2>err &&
  29         grep "^usage: git submodule" err &&
  30         test_must_be_empty out
  31 '
  32
  33 test_expect_success 'submodule usage: status --' '
  34         test_expect_code 1 git submodule -- &&
  35         test_expect_code 1 git submodule --end-of-options
  36 '
  37
  38 for opt in '--quiet' '--cached'
  39 do
  40         test_expect_success "submodule usage: status $opt" '
  41                 git submodule $opt &&
  42                 git submodule status $opt &&
  43                 git submodule $opt status
  44         '
  45 done
  46
  47 test_expect_success 'submodule deinit works on empty repository' '
  48         git submodule deinit --all
  49 '
  50
  51 test_expect_success 'setup - initial commit' '
  52         >t &&
  53         git add t &&
  54         git commit -m "initial commit" &&
  55         git branch initial
  56 '
  57
  58 test_expect_success 'submodule init aborts on missing .gitmodules file' '
  59         test_when_finished "git update-index --remove sub" &&
  60         git update-index --add --cacheinfo 160000,$(git rev-parse HEAD),sub &&
  61         # missing the .gitmodules file here
  62         test_must_fail git submodule init 2>actual &&
  63         test_grep "No url found for submodule path" actual
  64 '
  65
  66 test_expect_success 'submodule update aborts on missing .gitmodules file' '
  67         test_when_finished "git update-index --remove sub" &&
  68         git update-index --add --cacheinfo 160000,$(git rev-parse HEAD),sub &&
  69         # missing the .gitmodules file here
  70         git submodule update sub 2>actual &&
  71         test_grep "Submodule path .sub. not initialized" actual
  72 '
  73
  74 test_expect_success 'submodule update aborts on missing gitmodules url' '
  75         test_when_finished "git update-index --remove sub" &&
  76         git update-index --add --cacheinfo 160000,$(git rev-parse HEAD),sub &&
  77         test_when_finished "rm -f .gitmodules" &&
  78         git config -f .gitmodules submodule.s.path sub &&
  79         test_must_fail git submodule init
  80 '
  81
  82 test_expect_success 'add aborts on repository with no commits' '
  83         cat >expect <<-\EOF &&
  84         fatal: '"'repo-no-commits'"' does not have a commit checked out
  85         EOF
  86         git init repo-no-commits &&
  87         test_must_fail git submodule add ../a ./repo-no-commits 2>actual &&
  88         test_cmp expect actual
  89 '
  90
  91 test_expect_success 'status should ignore inner git repo when not added' '
  92         rm -fr inner &&
  93         mkdir inner &&
  94         (
  95                 cd inner &&
  96                 git init &&
  97                 >t &&
  98                 git add t &&
  99                 git commit -m "initial"
 100         ) &&
 101         test_must_fail git submodule status inner 2>output.err &&
 102         rm -fr inner &&
 103         test_grep "^error: .*did not match any file(s) known to git" output.err
 104 '
 105
 106 test_expect_success 'setup - repository in init subdirectory' '
 107         mkdir init &&
 108         (
 109                 cd init &&
 110                 git init &&
 111                 echo a >a &&
 112                 git add a &&
 113                 git commit -m "submodule commit 1" &&
 114                 git tag -a -m "rev-1" rev-1
 115         )
 116 '
 117
 118 test_expect_success 'setup - commit with gitlink' '
 119         echo a >a &&
 120         echo z >z &&
 121         git add a init z &&
 122         git commit -m "super commit 1"
 123 '
 124
 125 test_expect_success 'setup - hide init subdirectory' '
 126         mv init .subrepo
 127 '
 128
 129 test_expect_success 'setup - repository to add submodules to' '
 130         git init addtest &&
 131         git init addtest-ignore
 132 '
 133
 134 # The 'submodule add' tests need some repository to add as a submodule.
 135 # The trash directory is a good one as any. We need to canonicalize
 136 # the name, though, as some tests compare it to the absolute path git
 137 # generates, which will expand symbolic links.
 138 submodurl=$(pwd -P)
 139
 140 listbranches() {
 141         git for-each-ref --format='%(refname)' 'refs/heads/*'
 142 }
 143
 144 inspect() {
 145         dir=$1 &&
 146         dotdot="${2:-..}" &&
 147
 148         (
 149                 cd "$dir" &&
 150                 listbranches >"$dotdot/heads" &&
 151                 { git symbolic-ref HEAD || :; } >"$dotdot/head" &&
 152                 git rev-parse HEAD >"$dotdot/head-sha1" &&
 153                 git update-index --refresh &&
 154                 git diff-files --exit-code &&
 155                 git clean -n -d -x >"$dotdot/untracked"
 156         )
 157 }
 158
 159 test_expect_success 'submodule add' '
 160         echo "refs/heads/main" >expect &&
 161
 162         (
 163                 cd addtest &&
 164                 git submodule add -q "$submodurl" submod >actual &&
 165                 test_must_be_empty actual &&
 166                 echo "gitdir: ../.git/modules/submod" >expect &&
 167                 test_cmp expect submod/.git &&
 168                 (
 169                         cd submod &&
 170                         git config core.worktree >actual &&
 171                         echo "../../../submod" >expect &&
 172                         test_cmp expect actual &&
 173                         rm -f actual expect
 174                 ) &&
 175                 git submodule init
 176         ) &&
 177
 178         rm -f heads head untracked &&
 179         inspect addtest/submod ../.. &&
 180         test_cmp expect heads &&
 181         test_cmp expect head &&
 182         test_must_be_empty untracked
 183 '
 184
 185 test_expect_success !WINDOWS 'submodule add (absolute path)' '
 186         test_when_finished "git reset --hard" &&
 187         git submodule add "$submodurl" "$submodurl/add-abs"
 188 '
 189
 190 test_expect_success 'setup parent and one repository' '
 191         test_create_repo parent &&
 192         test_commit -C parent one
 193 '
 194
 195 test_expect_success 'redirected submodule add does not show progress' '
 196         git -C addtest submodule add "file://$submodurl/parent" submod-redirected \
 197                 2>err &&
 198         ! grep % err &&
 199         test_grep ! "Checking connectivity" err
 200 '
 201
 202 test_expect_success 'redirected submodule add --progress does show progress' '
 203         git -C addtest submodule add --progress "file://$submodurl/parent" \
 204                 submod-redirected-progress 2>err && \
 205         grep % err
 206 '
 207
 208 test_expect_success 'submodule add to .gitignored path fails' '
 209         (
 210                 cd addtest-ignore &&
 211                 cat <<-\EOF >expect &&
 212                 The following paths are ignored by one of your .gitignore files:
 213                 submod
 214                 hint: Use -f if you really want to add them.
 215                 hint: Turn this message off by running
 216                 hint: "git config advice.addIgnoredFile false"
 217                 EOF
 218                 # Does not use test_commit due to the ignore
 219                 echo "*" > .gitignore &&
 220                 git add --force .gitignore &&
 221                 git commit -m"Ignore everything" &&
 222                 ! git submodule add "$submodurl" submod >actual 2>&1 &&
 223                 test_cmp expect actual
 224         )
 225 '
 226
 227 test_expect_success 'submodule add to .gitignored path with --force' '
 228         (
 229                 cd addtest-ignore &&
 230                 git submodule add --force "$submodurl" submod
 231         )
 232 '
 233
 234 test_expect_success 'submodule add to path with tracked content fails' '
 235         (
 236                 cd addtest &&
 237                 echo "fatal: '\''dir-tracked'\'' already exists in the index" >expect &&
 238                 mkdir dir-tracked &&
 239                 test_commit foo dir-tracked/bar &&
 240                 test_must_fail git submodule add "$submodurl" dir-tracked >actual 2>&1 &&
 241                 test_cmp expect actual
 242         )
 243 '
 244
 245 test_expect_success 'submodule add to reconfigure existing submodule with --force' '
 246         (
 247                 cd addtest-ignore &&
 248                 bogus_url="$(pwd)/bogus-url" &&
 249                 git submodule add --force "$bogus_url" submod &&
 250                 git submodule add --force -b initial "$submodurl" submod-branch &&
 251                 test "$bogus_url" = "$(git config -f .gitmodules submodule.submod.url)" &&
 252                 test "$bogus_url" = "$(git config submodule.submod.url)" &&
 253                 # Restore the url
 254                 git submodule add --force "$submodurl" submod &&
 255                 test "$submodurl" = "$(git config -f .gitmodules submodule.submod.url)" &&
 256                 test "$submodurl" = "$(git config submodule.submod.url)"
 257         )
 258 '
 259
 260 test_expect_success 'submodule add relays add --dry-run stderr' '
 261         test_when_finished "rm -rf addtest/.git/index.lock" &&
 262         (
 263                 cd addtest &&
 264                 : >.git/index.lock &&
 265                 ! git submodule add "$submodurl" sub-while-locked 2>output.err &&
 266                 test_grep "^fatal: .*index\.lock" output.err &&
 267                 test_path_is_missing sub-while-locked
 268         )
 269 '
 270
 271 test_expect_success 'submodule add --branch' '
 272         echo "refs/heads/initial" >expect-head &&
 273         cat <<-\EOF >expect-heads &&
 274         refs/heads/initial
 275         refs/heads/main
 276         EOF
 277
 278         (
 279                 cd addtest &&
 280                 git submodule add -b initial "$submodurl" submod-branch &&
 281                 test "initial" = "$(git config -f .gitmodules submodule.submod-branch.branch)" &&
 282                 git submodule init
 283         ) &&
 284
 285         rm -f heads head untracked &&
 286         inspect addtest/submod-branch ../.. &&
 287         test_cmp expect-heads heads &&
 288         test_cmp expect-head head &&
 289         test_must_be_empty untracked
 290 '
 291
 292 test_expect_success 'submodule add with ./ in path' '
 293         echo "refs/heads/main" >expect &&
 294
 295         (
 296                 cd addtest &&
 297                 git submodule add "$submodurl" ././dotsubmod/./frotz/./ &&
 298                 git submodule init
 299         ) &&
 300
 301         rm -f heads head untracked &&
 302         inspect addtest/dotsubmod/frotz ../../.. &&
 303         test_cmp expect heads &&
 304         test_cmp expect head &&
 305         test_must_be_empty untracked
 306 '
 307
 308 test_expect_success 'submodule add with /././ in path' '
 309         echo "refs/heads/main" >expect &&
 310
 311         (
 312                 cd addtest &&
 313                 git submodule add "$submodurl" dotslashdotsubmod/././frotz/./ &&
 314                 git submodule init
 315         ) &&
 316
 317         rm -f heads head untracked &&
 318         inspect addtest/dotslashdotsubmod/frotz ../../.. &&
 319         test_cmp expect heads &&
 320         test_cmp expect head &&
 321         test_must_be_empty untracked
 322 '
 323
 324 test_expect_success 'submodule add with // in path' '
 325         echo "refs/heads/main" >expect &&
 326
 327         (
 328                 cd addtest &&
 329                 git submodule add "$submodurl" slashslashsubmod///frotz// &&
 330                 git submodule init
 331         ) &&
 332
 333         rm -f heads head untracked &&
 334         inspect addtest/slashslashsubmod/frotz ../../.. &&
 335         test_cmp expect heads &&
 336         test_cmp expect head &&
 337         test_must_be_empty untracked
 338 '
 339
 340 test_expect_success 'submodule add with /.. in path' '
 341         echo "refs/heads/main" >expect &&
 342
 343         (
 344                 cd addtest &&
 345                 git submodule add "$submodurl" dotdotsubmod/../realsubmod/frotz/.. &&
 346                 git submodule init
 347         ) &&
 348
 349         rm -f heads head untracked &&
 350         inspect addtest/realsubmod ../.. &&
 351         test_cmp expect heads &&
 352         test_cmp expect head &&
 353         test_must_be_empty untracked
 354 '
 355
 356 test_expect_success 'submodule add with ./, /.. and // in path' '
 357         echo "refs/heads/main" >expect &&
 358
 359         (
 360                 cd addtest &&
 361                 git submodule add "$submodurl" dot/dotslashsubmod/./../..////realsubmod2/a/b/c/d/../../../../frotz//.. &&
 362                 git submodule init
 363         ) &&
 364
 365         rm -f heads head untracked &&
 366         inspect addtest/realsubmod2 ../.. &&
 367         test_cmp expect heads &&
 368         test_cmp expect head &&
 369         test_must_be_empty untracked
 370 '
 371
 372 test_expect_success !CYGWIN 'submodule add with \\ in path' '
 373         test_when_finished "rm -rf parent sub\\with\\backslash" &&
 374
 375         # Initialize a repo with a backslash in its name
 376         git init sub\\with\\backslash &&
 377         touch sub\\with\\backslash/empty.file &&
 378         git -C sub\\with\\backslash add empty.file &&
 379         git -C sub\\with\\backslash commit -m "Added empty.file" &&
 380
 381         # Add that repository as a submodule
 382         git init parent &&
 383         git -C parent submodule add ../sub\\with\\backslash
 384 '
 385
 386 test_expect_success 'submodule add in subdirectory' '
 387         echo "refs/heads/main" >expect &&
 388
 389         mkdir addtest/sub &&
 390         (
 391                 cd addtest/sub &&
 392                 git submodule add "$submodurl" ../realsubmod3 &&
 393                 git submodule init
 394         ) &&
 395
 396         rm -f heads head untracked &&
 397         inspect addtest/realsubmod3 ../.. &&
 398         test_cmp expect heads &&
 399         test_cmp expect head &&
 400         test_must_be_empty untracked
 401 '
 402
 403 test_expect_success 'submodule add in subdirectory with relative path should fail' '
 404         (
 405                 cd addtest/sub &&
 406                 test_must_fail git submodule add ../../ submod3 2>../../output.err
 407         ) &&
 408         test_grep toplevel output.err
 409 '
 410
 411 test_expect_success 'setup - add an example entry to .gitmodules' '
 412         git config --file=.gitmodules submodule.example.url git://example.com/init.git
 413 '
 414
 415 test_expect_success 'status should fail for unmapped paths' '
 416         test_must_fail git submodule status
 417 '
 418
 419 test_expect_success 'setup - map path in .gitmodules' '
 420         cat <<\EOF >expect &&
 421 [submodule "example"]
 422         url = git://example.com/init.git
 423         path = init
 424 EOF
 425
 426         git config --file=.gitmodules submodule.example.path init &&
 427
 428         test_cmp expect .gitmodules
 429 '
 430
 431 test_expect_success 'status should only print one line' '
 432         git submodule status >lines &&
 433         test_line_count = 1 lines
 434 '
 435
 436 test_expect_success 'status from subdirectory should have the same SHA1' '
 437         test_when_finished "rmdir addtest/subdir" &&
 438         (
 439                 cd addtest &&
 440                 mkdir subdir &&
 441                 git submodule status >output &&
 442                 awk "{print \$1}" <output >expect &&
 443                 cd subdir &&
 444                 git submodule status >../output &&
 445                 awk "{print \$1}" <../output >../actual &&
 446                 test_cmp ../expect ../actual &&
 447                 git -C ../submod checkout HEAD^ &&
 448                 git submodule status >../output &&
 449                 awk "{print \$1}" <../output >../actual2 &&
 450                 cd .. &&
 451                 git submodule status >output &&
 452                 awk "{print \$1}" <output >expect2 &&
 453                 test_cmp expect2 actual2 &&
 454                 ! test_cmp actual actual2
 455         )
 456 '
 457
 458 test_expect_success 'setup - fetch commit name from submodule' '
 459         rev1=$(cd .subrepo && git rev-parse HEAD) &&
 460         printf "rev1: %s\n" "$rev1" &&
 461         test -n "$rev1"
 462 '
 463
 464 test_expect_success 'status should initially be "missing"' '
 465         git submodule status >lines &&
 466         grep "^-$rev1" lines
 467 '
 468
 469 test_expect_success 'init should register submodule url in .git/config' '
 470         echo git://example.com/init.git >expect &&
 471
 472         git submodule init &&
 473         git config submodule.example.url >url &&
 474         git config submodule.example.url ./.subrepo &&
 475
 476         test_cmp expect url
 477 '
 478
 479 test_expect_success 'status should still be "missing" after initializing' '
 480         rm -fr init &&
 481         mkdir init &&
 482         git submodule status >lines &&
 483         rm -fr init &&
 484         grep "^-$rev1" lines
 485 '
 486
 487 test_failure_with_unknown_submodule () {
 488         test_must_fail git submodule $1 no-such-submodule 2>output.err &&
 489         test_grep "^error: .*no-such-submodule" output.err
 490 }
 491
 492 test_expect_success 'init should fail with unknown submodule' '
 493         test_failure_with_unknown_submodule init
 494 '
 495
 496 test_expect_success 'update should fail with unknown submodule' '
 497         test_failure_with_unknown_submodule update
 498 '
 499
 500 test_expect_success 'status should fail with unknown submodule' '
 501         test_failure_with_unknown_submodule status
 502 '
 503
 504 test_expect_success 'sync should fail with unknown submodule' '
 505         test_failure_with_unknown_submodule sync
 506 '
 507
 508 test_expect_success 'update should fail when path is used by a file' '
 509         echo hello >expect &&
 510
 511         echo "hello" >init &&
 512         test_must_fail git submodule update &&
 513
 514         test_cmp expect init
 515 '
 516
 517 test_expect_success 'update should fail when path is used by a nonempty directory' '
 518         echo hello >expect &&
 519
 520         rm -fr init &&
 521         mkdir init &&
 522         echo "hello" >init/a &&
 523
 524         test_must_fail git submodule update &&
 525
 526         test_cmp expect init/a
 527 '
 528
 529 test_expect_success 'update should work when path is an empty dir' '
 530         rm -fr init &&
 531         rm -f head-sha1 &&
 532         echo "$rev1" >expect &&
 533
 534         mkdir init &&
 535         git submodule update -q >update.out &&
 536         test_must_be_empty update.out &&
 537
 538         inspect init &&
 539         test_cmp expect head-sha1
 540 '
 541
 542 test_expect_success 'status should be "up-to-date" after update' '
 543         git submodule status >list &&
 544         grep "^ $rev1" list
 545 '
 546
 547 test_expect_success 'status "up-to-date" from subdirectory' '
 548         mkdir -p sub &&
 549         (
 550                 cd sub &&
 551                 git submodule status >../list
 552         ) &&
 553         grep "^ $rev1" list &&
 554         grep "\\.\\./init" list
 555 '
 556
 557 test_expect_success 'status "up-to-date" from subdirectory with path' '
 558         mkdir -p sub &&
 559         (
 560                 cd sub &&
 561                 git submodule status ../init >../list
 562         ) &&
 563         grep "^ $rev1" list &&
 564         grep "\\.\\./init" list
 565 '
 566
 567 test_expect_success 'status should be "modified" after submodule commit' '
 568         (
 569                 cd init &&
 570                 echo b >b &&
 571                 git add b &&
 572                 git commit -m "submodule commit 2"
 573         ) &&
 574
 575         rev2=$(cd init && git rev-parse HEAD) &&
 576         test -n "$rev2" &&
 577         git submodule status >list &&
 578
 579         grep "^+$rev2" list
 580 '
 581
 582 test_expect_success '"submodule --cached" command forms should be identical' '
 583         git submodule status --cached >expect &&
 584
 585         git submodule --cached >actual &&
 586         test_cmp expect actual &&
 587
 588         git submodule --cached status >actual &&
 589         test_cmp expect actual
 590 '
 591
 592 test_expect_success 'the --cached sha1 should be rev1' '
 593         git submodule --cached status >list &&
 594         grep "^+$rev1" list
 595 '
 596
 597 test_expect_success 'git diff should report the SHA1 of the new submodule commit' '
 598         git diff >diff &&
 599         grep "^+Subproject commit $rev2" diff
 600 '
 601
 602 test_expect_success 'update should checkout rev1' '
 603         rm -f head-sha1 &&
 604         echo "$rev1" >expect &&
 605
 606         git submodule update init &&
 607         inspect init &&
 608
 609         test_cmp expect head-sha1
 610 '
 611
 612 test_expect_success 'status should be "up-to-date" after update' '
 613         git submodule status >list &&
 614         grep "^ $rev1" list
 615 '
 616
 617 test_expect_success 'checkout superproject with subproject already present' '
 618         git checkout initial &&
 619         git checkout main
 620 '
 621
 622 test_expect_success 'apply submodule diff' '
 623         git branch second &&
 624         (
 625                 cd init &&
 626                 echo s >s &&
 627                 git add s &&
 628                 git commit -m "change subproject"
 629         ) &&
 630         git update-index --add init &&
 631         git commit -m "change init" &&
 632         git format-patch -1 --stdout >P.diff &&
 633         git checkout second &&
 634         git apply --index P.diff &&
 635
 636         git diff --cached main >staged &&
 637         test_must_be_empty staged
 638 '
 639
 640 test_expect_success 'update --init' '
 641         mv init init2 &&
 642         git config -f .gitmodules submodule.example.url "$(pwd)/init2" &&
 643         git config --remove-section submodule.example &&
 644         test_must_fail git config submodule.example.url &&
 645
 646         git submodule update init 2> update.out &&
 647         test_grep "not initialized" update.out &&
 648         test_must_fail git rev-parse --resolve-git-dir init/.git &&
 649
 650         git submodule update --init init &&
 651         git rev-parse --resolve-git-dir init/.git
 652 '
 653
 654 test_expect_success 'update --init from subdirectory' '
 655         mv init init2 &&
 656         git config -f .gitmodules submodule.example.url "$(pwd)/init2" &&
 657         git config --remove-section submodule.example &&
 658         test_must_fail git config submodule.example.url &&
 659
 660         mkdir -p sub &&
 661         (
 662                 cd sub &&
 663                 git submodule update ../init 2>update.out &&
 664                 test_grep "not initialized" update.out &&
 665                 test_must_fail git rev-parse --resolve-git-dir ../init/.git &&
 666
 667                 git submodule update --init ../init
 668         ) &&
 669         git rev-parse --resolve-git-dir init/.git
 670 '
 671
 672 test_expect_success 'do not add files from a submodule' '
 673
 674         git reset --hard &&
 675         test_must_fail git add init/a
 676
 677 '
 678
 679 test_expect_success 'gracefully add/reset submodule with a trailing slash' '
 680
 681         git reset --hard &&
 682         git commit -m "commit subproject" init &&
 683         (cd init &&
 684          echo b > a) &&
 685         git add init/ &&
 686         git diff --exit-code --cached init &&
 687         commit=$(cd init &&
 688          git commit -m update a >/dev/null &&
 689          git rev-parse HEAD) &&
 690         git add init/ &&
 691         test_must_fail git diff --exit-code --cached init &&
 692         test $commit = $(git ls-files --stage |
 693                 sed -n "s/^160000 \([^ ]*\).*/\1/p") &&
 694         git reset init/ &&
 695         git diff --exit-code --cached init
 696
 697 '
 698
 699 test_expect_success 'ls-files gracefully handles trailing slash' '
 700
 701         test "init" = "$(git ls-files init/)"
 702
 703 '
 704
 705 test_expect_success 'moving to a commit without submodule does not leave empty dir' '
 706         rm -rf init &&
 707         mkdir init &&
 708         git reset --hard &&
 709         git checkout initial &&
 710         test ! -d init &&
 711         git checkout second
 712 '
 713
 714 test_expect_success 'submodule <invalid-subcommand> fails' '
 715         test_must_fail git submodule no-such-subcommand
 716 '
 717
 718 test_expect_success 'add submodules without specifying an explicit path' '
 719         mkdir repo &&
 720         (
 721                 cd repo &&
 722                 git init &&
 723                 echo r >r &&
 724                 git add r &&
 725                 git commit -m "repo commit 1"
 726         ) &&
 727         git clone --bare repo/ bare.git &&
 728         (
 729                 cd addtest &&
 730                 git submodule add "$submodurl/repo" &&
 731                 git config -f .gitmodules submodule.repo.path repo &&
 732                 git submodule add "$submodurl/bare.git" &&
 733                 git config -f .gitmodules submodule.bare.path bare
 734         )
 735 '
 736
 737 test_expect_success 'add should fail when path is used by a file' '
 738         (
 739                 cd addtest &&
 740                 touch file &&
 741                 test_must_fail  git submodule add "$submodurl/repo" file
 742         )
 743 '
 744
 745 test_expect_success 'add should fail when path is used by an existing directory' '
 746         (
 747                 cd addtest &&
 748                 mkdir empty-dir &&
 749                 test_must_fail git submodule add "$submodurl/repo" empty-dir
 750         )
 751 '
 752
 753 test_expect_success 'use superproject as upstream when path is relative and no url is set there' '
 754         (
 755                 cd addtest &&
 756                 git submodule add ../repo relative &&
 757                 test "$(git config -f .gitmodules submodule.relative.url)" = ../repo &&
 758                 git submodule sync relative &&
 759                 test "$(git config submodule.relative.url)" = "$submodurl/repo"
 760         )
 761 '
 762
 763 test_expect_success 'set up for relative path tests' '
 764         mkdir reltest &&
 765         (
 766                 cd reltest &&
 767                 git init &&
 768                 mkdir sub &&
 769                 (
 770                         cd sub &&
 771                         git init &&
 772                         test_commit foo
 773                 ) &&
 774                 git add sub &&
 775                 git config -f .gitmodules submodule.sub.path sub &&
 776                 git config -f .gitmodules submodule.sub.url ../subrepo &&
 777                 cp .git/config pristine-.git-config &&
 778                 cp .gitmodules pristine-.gitmodules
 779         )
 780 '
 781
 782 test_expect_success '../subrepo works with URL - ssh://hostname/repo' '
 783         (
 784                 cd reltest &&
 785                 cp pristine-.git-config .git/config &&
 786                 cp pristine-.gitmodules .gitmodules &&
 787                 git config remote.origin.url ssh://hostname/repo &&
 788                 git submodule init &&
 789                 test "$(git config submodule.sub.url)" = ssh://hostname/subrepo
 790         )
 791 '
 792
 793 test_expect_success '../subrepo works with port-qualified URL - ssh://hostname:22/repo' '
 794         (
 795                 cd reltest &&
 796                 cp pristine-.git-config .git/config &&
 797                 cp pristine-.gitmodules .gitmodules &&
 798                 git config remote.origin.url ssh://hostname:22/repo &&
 799                 git submodule init &&
 800                 test "$(git config submodule.sub.url)" = ssh://hostname:22/subrepo
 801         )
 802 '
 803
 804 # About the choice of the path in the next test:
 805 # - double-slash side-steps path mangling issues on Windows
 806 # - it is still an absolute local path
 807 # - there cannot be a server with a blank in its name just in case the
 808 #   path is used erroneously to access a //server/share style path
 809 test_expect_success '../subrepo path works with local path - //somewhere else/repo' '
 810         (
 811                 cd reltest &&
 812                 cp pristine-.git-config .git/config &&
 813                 cp pristine-.gitmodules .gitmodules &&
 814                 git config remote.origin.url "//somewhere else/repo" &&
 815                 git submodule init &&
 816                 test "$(git config submodule.sub.url)" = "//somewhere else/subrepo"
 817         )
 818 '
 819
 820 test_expect_success '../subrepo works with file URL - file:///tmp/repo' '
 821         (
 822                 cd reltest &&
 823                 cp pristine-.git-config .git/config &&
 824                 cp pristine-.gitmodules .gitmodules &&
 825                 git config remote.origin.url file:///tmp/repo &&
 826                 git submodule init &&
 827                 test "$(git config submodule.sub.url)" = file:///tmp/subrepo
 828         )
 829 '
 830
 831 test_expect_success '../subrepo works with helper URL- helper:://hostname/repo' '
 832         (
 833                 cd reltest &&
 834                 cp pristine-.git-config .git/config &&
 835                 cp pristine-.gitmodules .gitmodules &&
 836                 git config remote.origin.url helper:://hostname/repo &&
 837                 git submodule init &&
 838                 test "$(git config submodule.sub.url)" = helper:://hostname/subrepo
 839         )
 840 '
 841
 842 test_expect_success '../subrepo works with scp-style URL - user@host:repo' '
 843         (
 844                 cd reltest &&
 845                 cp pristine-.git-config .git/config &&
 846                 git config remote.origin.url user@host:repo &&
 847                 git submodule init &&
 848                 test "$(git config submodule.sub.url)" = user@host:subrepo
 849         )
 850 '
 851
 852 test_expect_success '../subrepo works with scp-style URL - user@host:path/to/repo' '
 853         (
 854                 cd reltest &&
 855                 cp pristine-.git-config .git/config &&
 856                 cp pristine-.gitmodules .gitmodules &&
 857                 git config remote.origin.url user@host:path/to/repo &&
 858                 git submodule init &&
 859                 test "$(git config submodule.sub.url)" = user@host:path/to/subrepo
 860         )
 861 '
 862
 863 test_expect_success '../subrepo works with relative local path - foo' '
 864         (
 865                 cd reltest &&
 866                 cp pristine-.git-config .git/config &&
 867                 cp pristine-.gitmodules .gitmodules &&
 868                 git config remote.origin.url foo &&
 869                 # actual: fails with an error
 870                 git submodule init &&
 871                 test "$(git config submodule.sub.url)" = subrepo
 872         )
 873 '
 874
 875 test_expect_success '../subrepo works with relative local path - foo/bar' '
 876         (
 877                 cd reltest &&
 878                 cp pristine-.git-config .git/config &&
 879                 cp pristine-.gitmodules .gitmodules &&
 880                 git config remote.origin.url foo/bar &&
 881                 git submodule init &&
 882                 test "$(git config submodule.sub.url)" = foo/subrepo
 883         )
 884 '
 885
 886 test_expect_success '../subrepo works with relative local path - ./foo' '
 887         (
 888                 cd reltest &&
 889                 cp pristine-.git-config .git/config &&
 890                 cp pristine-.gitmodules .gitmodules &&
 891                 git config remote.origin.url ./foo &&
 892                 git submodule init &&
 893                 test "$(git config submodule.sub.url)" = subrepo
 894         )
 895 '
 896
 897 test_expect_success '../subrepo works with relative local path - ./foo/bar' '
 898         (
 899                 cd reltest &&
 900                 cp pristine-.git-config .git/config &&
 901                 cp pristine-.gitmodules .gitmodules &&
 902                 git config remote.origin.url ./foo/bar &&
 903                 git submodule init &&
 904                 test "$(git config submodule.sub.url)" = foo/subrepo
 905         )
 906 '
 907
 908 test_expect_success '../subrepo works with relative local path - ../foo' '
 909         (
 910                 cd reltest &&
 911                 cp pristine-.git-config .git/config &&
 912                 cp pristine-.gitmodules .gitmodules &&
 913                 git config remote.origin.url ../foo &&
 914                 git submodule init &&
 915                 test "$(git config submodule.sub.url)" = ../subrepo
 916         )
 917 '
 918
 919 test_expect_success '../subrepo works with relative local path - ../foo/bar' '
 920         (
 921                 cd reltest &&
 922                 cp pristine-.git-config .git/config &&
 923                 cp pristine-.gitmodules .gitmodules &&
 924                 git config remote.origin.url ../foo/bar &&
 925                 git submodule init &&
 926                 test "$(git config submodule.sub.url)" = ../foo/subrepo
 927         )
 928 '
 929
 930 test_expect_success '../bar/a/b/c works with relative local path - ../foo/bar.git' '
 931         (
 932                 cd reltest &&
 933                 cp pristine-.git-config .git/config &&
 934                 cp pristine-.gitmodules .gitmodules &&
 935                 mkdir -p a/b/c &&
 936                 (cd a/b/c && git init && test_commit msg) &&
 937                 git config remote.origin.url ../foo/bar.git &&
 938                 git submodule add ../bar/a/b/c ./a/b/c &&
 939                 git submodule init &&
 940                 test "$(git config submodule.a/b/c.url)" = ../foo/bar/a/b/c
 941         )
 942 '
 943
 944 test_expect_success 'moving the superproject does not break submodules' '
 945         (
 946                 cd addtest &&
 947                 git submodule status >expect
 948         ) &&
 949         mv addtest addtest2 &&
 950         (
 951                 cd addtest2 &&
 952                 git submodule status >actual &&
 953                 test_cmp expect actual
 954         )
 955 '
 956
 957 test_expect_success 'moving the submodule does not break the superproject' '
 958         (
 959                 cd addtest2 &&
 960                 git submodule status
 961         ) >actual &&
 962         sed -e "s/^ \([^ ]* repo\) .*/-\1/" <actual >expect &&
 963         mv addtest2/repo addtest2/repo.bak &&
 964         test_when_finished "mv addtest2/repo.bak addtest2/repo" &&
 965         (
 966                 cd addtest2 &&
 967                 git submodule status
 968         ) >actual &&
 969         test_cmp expect actual
 970 '
 971
 972 test_expect_success 'submodule add --name allows to replace a submodule with another at the same path' '
 973         (
 974                 cd addtest2 &&
 975                 (
 976                         cd repo &&
 977                         echo "$submodurl/repo" >expect &&
 978                         git config remote.origin.url >actual &&
 979                         test_cmp expect actual &&
 980                         echo "gitdir: ../.git/modules/repo" >expect &&
 981                         test_cmp expect .git
 982                 ) &&
 983                 rm -rf repo &&
 984                 git rm repo &&
 985                 git submodule add -q --name repo_new "$submodurl/bare.git" repo >actual &&
 986                 test_must_be_empty actual &&
 987                 echo "gitdir: ../.git/modules/submod" >expect &&
 988                 test_cmp expect submod/.git &&
 989                 (
 990                         cd repo &&
 991                         echo "$submodurl/bare.git" >expect &&
 992                         git config remote.origin.url >actual &&
 993                         test_cmp expect actual &&
 994                         echo "gitdir: ../.git/modules/repo_new" >expect &&
 995                         test_cmp expect .git
 996                 ) &&
 997                 echo "repo" >expect &&
 998                 test_must_fail git config -f .gitmodules submodule.repo.path &&
 999                 git config -f .gitmodules submodule.repo_new.path >actual &&
1000                 test_cmp expect actual &&
1001                 echo "$submodurl/repo" >expect &&
1002                 test_must_fail git config -f .gitmodules submodule.repo.url &&
1003                 echo "$submodurl/bare.git" >expect &&
1004                 git config -f .gitmodules submodule.repo_new.url >actual &&
1005                 test_cmp expect actual &&
1006                 echo "$submodurl/repo" >expect &&
1007                 git config submodule.repo.url >actual &&
1008                 test_cmp expect actual &&
1009                 echo "$submodurl/bare.git" >expect &&
1010                 git config submodule.repo_new.url >actual &&
1011                 test_cmp expect actual
1012         )
1013 '
1014
1015 test_expect_success 'recursive relative submodules stay relative' '
1016         test_when_finished "rm -rf super clone2 subsub sub3" &&
1017         mkdir subsub &&
1018         (
1019                 cd subsub &&
1020                 git init &&
1021                 >t &&
1022                 git add t &&
1023                 git commit -m "initial commit"
1024         ) &&
1025         mkdir sub3 &&
1026         (
1027                 cd sub3 &&
1028                 git init &&
1029                 >t &&
1030                 git add t &&
1031                 git commit -m "initial commit" &&
1032                 git submodule add ../subsub dirdir/subsub &&
1033                 git commit -m "add submodule subsub"
1034         ) &&
1035         mkdir super &&
1036         (
1037                 cd super &&
1038                 git init &&
1039                 >t &&
1040                 git add t &&
1041                 git commit -m "initial commit" &&
1042                 git submodule add ../sub3 &&
1043                 git commit -m "add submodule sub"
1044         ) &&
1045         git clone super clone2 &&
1046         (
1047                 cd clone2 &&
1048                 git submodule update --init --recursive &&
1049                 echo "gitdir: ../.git/modules/sub3" >./sub3/.git_expect &&
1050                 echo "gitdir: ../../../.git/modules/sub3/modules/dirdir/subsub" >./sub3/dirdir/subsub/.git_expect
1051         ) &&
1052         test_cmp clone2/sub3/.git_expect clone2/sub3/.git &&
1053         test_cmp clone2/sub3/dirdir/subsub/.git_expect clone2/sub3/dirdir/subsub/.git
1054 '
1055
1056 test_expect_success 'submodule add with an existing name fails unless forced' '
1057         (
1058                 cd addtest2 &&
1059                 rm -rf repo &&
1060                 git rm repo &&
1061                 test_must_fail git submodule add -q --name repo_new "$submodurl/repo.git" repo &&
1062                 test ! -d repo &&
1063                 test_must_fail git config -f .gitmodules submodule.repo_new.path &&
1064                 test_must_fail git config -f .gitmodules submodule.repo_new.url &&
1065                 echo "$submodurl/bare.git" >expect &&
1066                 git config submodule.repo_new.url >actual &&
1067                 test_cmp expect actual &&
1068                 git submodule add -f -q --name repo_new "$submodurl/repo.git" repo &&
1069                 test -d repo &&
1070                 echo "repo" >expect &&
1071                 git config -f .gitmodules submodule.repo_new.path >actual &&
1072                 test_cmp expect actual &&
1073                 echo "$submodurl/repo.git" >expect &&
1074                 git config -f .gitmodules submodule.repo_new.url >actual &&
1075                 test_cmp expect actual &&
1076                 echo "$submodurl/repo.git" >expect &&
1077                 git config submodule.repo_new.url >actual &&
1078                 test_cmp expect actual
1079         )
1080 '
1081
1082 test_expect_success 'set up a second submodule' '
1083         git submodule add ./init2 example2 &&
1084         git commit -m "submodule example2 added"
1085 '
1086
1087 test_expect_success 'submodule deinit works on repository without submodules' '
1088         test_when_finished "rm -rf newdirectory" &&
1089         mkdir newdirectory &&
1090         (
1091                 cd newdirectory &&
1092                 git init &&
1093                 >file &&
1094                 git add file &&
1095                 git commit -m "repo should not be empty" &&
1096                 git submodule deinit . &&
1097                 git submodule deinit --all
1098         )
1099 '
1100
1101 test_expect_success 'submodule deinit should remove the whole submodule section from .git/config' '
1102         git config submodule.example.foo bar &&
1103         git config submodule.example2.frotz nitfol &&
1104         git submodule deinit init &&
1105         test -z "$(git config --get-regexp "submodule\.example\.")" &&
1106         test -n "$(git config --get-regexp "submodule\.example2\.")" &&
1107         test -f example2/.git &&
1108         rmdir init
1109 '
1110
1111 test_expect_success 'submodule deinit should unset core.worktree' '
1112         test_path_is_file .git/modules/example/config &&
1113         test_must_fail git config -f .git/modules/example/config core.worktree
1114 '
1115
1116 test_expect_success 'submodule deinit from subdirectory' '
1117         git submodule update --init &&
1118         git config submodule.example.foo bar &&
1119         mkdir -p sub &&
1120         (
1121                 cd sub &&
1122                 git submodule deinit ../init >../output
1123         ) &&
1124         test_grep "\\.\\./init" output &&
1125         test -z "$(git config --get-regexp "submodule\.example\.")" &&
1126         test -n "$(git config --get-regexp "submodule\.example2\.")" &&
1127         test -f example2/.git &&
1128         rmdir init
1129 '
1130
1131 test_expect_success 'submodule deinit . deinits all initialized submodules' '
1132         git submodule update --init &&
1133         git config submodule.example.foo bar &&
1134         git config submodule.example2.frotz nitfol &&
1135         test_must_fail git submodule deinit &&
1136         git submodule deinit . >actual &&
1137         test -z "$(git config --get-regexp "submodule\.example\.")" &&
1138         test -z "$(git config --get-regexp "submodule\.example2\.")" &&
1139         test_grep "Cleared directory .init" actual &&
1140         test_grep "Cleared directory .example2" actual &&
1141         rmdir init example2
1142 '
1143
1144 test_expect_success 'submodule deinit --all deinits all initialized submodules' '
1145         git submodule update --init &&
1146         git config submodule.example.foo bar &&
1147         git config submodule.example2.frotz nitfol &&
1148         test_must_fail git submodule deinit &&
1149         git submodule deinit --all >actual &&
1150         test -z "$(git config --get-regexp "submodule\.example\.")" &&
1151         test -z "$(git config --get-regexp "submodule\.example2\.")" &&
1152         test_grep "Cleared directory .init" actual &&
1153         test_grep "Cleared directory .example2" actual &&
1154         rmdir init example2
1155 '
1156
1157 test_expect_success 'submodule deinit deinits a submodule when its work tree is missing or empty' '
1158         git submodule update --init &&
1159         rm -rf init example2/* example2/.git &&
1160         git submodule deinit init example2 >actual &&
1161         test -z "$(git config --get-regexp "submodule\.example\.")" &&
1162         test -z "$(git config --get-regexp "submodule\.example2\.")" &&
1163         test_grep ! "Cleared directory .init" actual &&
1164         test_grep "Cleared directory .example2" actual &&
1165         rmdir init
1166 '
1167
1168 test_expect_success 'submodule deinit fails when the submodule contains modifications unless forced' '
1169         git submodule update --init &&
1170         echo X >>init/s &&
1171         test_must_fail git submodule deinit init &&
1172         test -n "$(git config --get-regexp "submodule\.example\.")" &&
1173         test -f example2/.git &&
1174         git submodule deinit -f init >actual &&
1175         test -z "$(git config --get-regexp "submodule\.example\.")" &&
1176         test_grep "Cleared directory .init" actual &&
1177         rmdir init
1178 '
1179
1180 test_expect_success 'submodule deinit fails when the submodule contains untracked files unless forced' '
1181         git submodule update --init &&
1182         echo X >>init/untracked &&
1183         test_must_fail git submodule deinit init &&
1184         test -n "$(git config --get-regexp "submodule\.example\.")" &&
1185         test -f example2/.git &&
1186         git submodule deinit -f init >actual &&
1187         test -z "$(git config --get-regexp "submodule\.example\.")" &&
1188         test_grep "Cleared directory .init" actual &&
1189         rmdir init
1190 '
1191
1192 test_expect_success 'submodule deinit fails when the submodule HEAD does not match unless forced' '
1193         git submodule update --init &&
1194         (
1195                 cd init &&
1196                 git checkout HEAD^
1197         ) &&
1198         test_must_fail git submodule deinit init &&
1199         test -n "$(git config --get-regexp "submodule\.example\.")" &&
1200         test -f example2/.git &&
1201         git submodule deinit -f init >actual &&
1202         test -z "$(git config --get-regexp "submodule\.example\.")" &&
1203         test_grep "Cleared directory .init" actual &&
1204         rmdir init
1205 '
1206
1207 test_expect_success 'submodule deinit is silent when used on an uninitialized submodule' '
1208         git submodule update --init &&
1209         git submodule deinit init >actual &&
1210         test_grep "Submodule .example. (.*) unregistered for path .init" actual &&
1211         test_grep "Cleared directory .init" actual &&
1212         git submodule deinit init >actual &&
1213         test_grep ! "Submodule .example. (.*) unregistered for path .init" actual &&
1214         test_grep "Cleared directory .init" actual &&
1215         git submodule deinit . >actual &&
1216         test_grep ! "Submodule .example. (.*) unregistered for path .init" actual &&
1217         test_grep "Submodule .example2. (.*) unregistered for path .example2" actual &&
1218         test_grep "Cleared directory .init" actual &&
1219         git submodule deinit . >actual &&
1220         test_grep ! "Submodule .example. (.*) unregistered for path .init" actual &&
1221         test_grep ! "Submodule .example2. (.*) unregistered for path .example2" actual &&
1222         test_grep "Cleared directory .init" actual &&
1223         git submodule deinit --all >actual &&
1224         test_grep ! "Submodule .example. (.*) unregistered for path .init" actual &&
1225         test_grep ! "Submodule .example2. (.*) unregistered for path .example2" actual &&
1226         test_grep "Cleared directory .init" actual &&
1227         rmdir init example2
1228 '
1229
1230 test_expect_success 'submodule deinit absorbs .git directory if .git is a directory' '
1231         git submodule update --init &&
1232         (
1233                 cd init &&
1234                 rm .git &&
1235                 mv ../.git/modules/example .git &&
1236                 GIT_WORK_TREE=. git config --unset core.worktree
1237         ) &&
1238         git submodule deinit init &&
1239         test_path_is_missing init/.git &&
1240         test -z "$(git config --get-regexp "submodule\.example\.")"
1241 '
1242
1243 test_expect_success 'submodule with UTF-8 name' '
1244         svname=$(printf "\303\245 \303\244\303\266") &&
1245         mkdir "$svname" &&
1246         (
1247                 cd "$svname" &&
1248                 git init &&
1249                 >sub &&
1250                 git add sub &&
1251                 git commit -m "init sub"
1252         ) &&
1253         git submodule add ./"$svname" &&
1254         git submodule >&2 &&
1255         test -n "$(git submodule | grep "$svname")"
1256 '
1257
1258 test_expect_success 'submodule add clone shallow submodule' '
1259         mkdir super &&
1260         pwd=$(pwd) &&
1261         (
1262                 cd super &&
1263                 git init &&
1264                 git submodule add --depth=1 file://"$pwd"/example2 submodule &&
1265                 (
1266                         cd submodule &&
1267                         test 1 = $(git log --oneline | wc -l)
1268                 )
1269         )
1270 '
1271
1272 test_expect_success 'setup superproject with submodules' '
1273         git init sub1 &&
1274         test_commit -C sub1 test &&
1275         test_commit -C sub1 test2 &&
1276         git init multisuper &&
1277         git -C multisuper submodule add ../sub1 sub0 &&
1278         git -C multisuper submodule add ../sub1 sub1 &&
1279         git -C multisuper submodule add ../sub1 sub2 &&
1280         git -C multisuper submodule add ../sub1 sub3 &&
1281         git -C multisuper commit -m "add some submodules"
1282 '
1283
1284 cat >expect <<-EOF
1285 -sub0
1286  sub1 (test2)
1287  sub2 (test2)
1288  sub3 (test2)
1289 EOF
1290
1291 test_expect_success 'submodule update --init with a specification' '
1292         test_when_finished "rm -rf multisuper_clone" &&
1293         pwd=$(pwd) &&
1294         git clone file://"$pwd"/multisuper multisuper_clone &&
1295         git -C multisuper_clone submodule update --init . ":(exclude)sub0" &&
1296         git -C multisuper_clone submodule status | sed "s/$OID_REGEX //" >actual &&
1297         test_cmp expect actual
1298 '
1299
1300 test_expect_success 'submodule update --init with submodule.active set' '
1301         test_when_finished "rm -rf multisuper_clone" &&
1302         pwd=$(pwd) &&
1303         git clone file://"$pwd"/multisuper multisuper_clone &&
1304         git -C multisuper_clone config submodule.active "." &&
1305         git -C multisuper_clone config --add submodule.active ":(exclude)sub0" &&
1306         git -C multisuper_clone submodule update --init &&
1307         git -C multisuper_clone submodule status | sed "s/$OID_REGEX //" >actual &&
1308         test_cmp expect actual
1309 '
1310
1311 test_expect_success 'submodule update and setting submodule.<name>.active' '
1312         test_when_finished "rm -rf multisuper_clone" &&
1313         pwd=$(pwd) &&
1314         git clone file://"$pwd"/multisuper multisuper_clone &&
1315         git -C multisuper_clone config --bool submodule.sub0.active "true" &&
1316         git -C multisuper_clone config --bool submodule.sub1.active "false" &&
1317         git -C multisuper_clone config --bool submodule.sub2.active "true" &&
1318
1319         cat >expect <<-\EOF &&
1320          sub0 (test2)
1321         -sub1
1322          sub2 (test2)
1323         -sub3
1324         EOF
1325         git -C multisuper_clone submodule update &&
1326         git -C multisuper_clone submodule status | sed "s/$OID_REGEX //" >actual &&
1327         test_cmp expect actual
1328 '
1329
1330 test_expect_success 'clone active submodule without submodule url set' '
1331         test_when_finished "rm -rf test/test" &&
1332         mkdir test &&
1333         # another dir breaks accidental relative paths still being correct
1334         git clone file://"$pwd"/multisuper test/test &&
1335         (
1336                 cd test/test &&
1337                 git config submodule.active "." &&
1338
1339                 # do not pass --init flag, as the submodule is already active:
1340                 git submodule update &&
1341                 git submodule status >actual_raw &&
1342
1343                 cut -d" " -f3- actual_raw >actual &&
1344                 cat >expect <<-\EOF &&
1345                 sub0 (test2)
1346                 sub1 (test2)
1347                 sub2 (test2)
1348                 sub3 (test2)
1349                 EOF
1350                 test_cmp expect actual
1351         )
1352 '
1353
1354 test_expect_success 'update submodules without url set in .gitconfig' '
1355         test_when_finished "rm -rf multisuper_clone" &&
1356         git clone file://"$pwd"/multisuper multisuper_clone &&
1357
1358         git -C multisuper_clone submodule init &&
1359         for s in sub0 sub1 sub2 sub3
1360         do
1361                 key=submodule.$s.url &&
1362                 git -C multisuper_clone config --local --unset $key &&
1363                 git -C multisuper_clone config --file .gitmodules --unset $key || return 1
1364         done &&
1365
1366         test_must_fail git -C multisuper_clone submodule update 2>err &&
1367         grep "cannot clone submodule .sub[0-3]. without a URL" err
1368 '
1369
1370 test_expect_success 'clone --recurse-submodules with a pathspec works' '
1371         test_when_finished "rm -rf multisuper_clone" &&
1372         cat >expected <<-\EOF &&
1373          sub0 (test2)
1374         -sub1
1375         -sub2
1376         -sub3
1377         EOF
1378
1379         git clone --recurse-submodules="sub0" multisuper multisuper_clone &&
1380         git -C multisuper_clone submodule status | sed "s/$OID_REGEX //" >actual &&
1381         test_cmp expected actual
1382 '
1383
1384 test_expect_success 'clone with multiple --recurse-submodules options' '
1385         test_when_finished "rm -rf multisuper_clone" &&
1386         cat >expect <<-\EOF &&
1387         -sub0
1388          sub1 (test2)
1389         -sub2
1390          sub3 (test2)
1391         EOF
1392
1393         git clone --recurse-submodules="." \
1394                   --recurse-submodules=":(exclude)sub0" \
1395                   --recurse-submodules=":(exclude)sub2" \
1396                   multisuper multisuper_clone &&
1397         git -C multisuper_clone submodule status | sed "s/$OID_REGEX //" >actual &&
1398         test_cmp expect actual
1399 '
1400
1401 test_expect_success 'clone and subsequent updates correctly auto-initialize submodules' '
1402         test_when_finished "rm -rf multisuper_clone" &&
1403         cat <<-\EOF >expect &&
1404         -sub0
1405          sub1 (test2)
1406         -sub2
1407          sub3 (test2)
1408         EOF
1409
1410         cat <<-\EOF >expect2 &&
1411         -sub0
1412          sub1 (test2)
1413         -sub2
1414          sub3 (test2)
1415         -sub4
1416          sub5 (test2)
1417         EOF
1418
1419         git clone --recurse-submodules="." \
1420                   --recurse-submodules=":(exclude)sub0" \
1421                   --recurse-submodules=":(exclude)sub2" \
1422                   --recurse-submodules=":(exclude)sub4" \
1423                   multisuper multisuper_clone &&
1424
1425         git -C multisuper_clone submodule status | sed "s/$OID_REGEX //" >actual &&
1426         test_cmp expect actual &&
1427
1428         git -C multisuper submodule add ../sub1 sub4 &&
1429         git -C multisuper submodule add ../sub1 sub5 &&
1430         git -C multisuper commit -m "add more submodules" &&
1431         # obtain the new superproject
1432         git -C multisuper_clone pull &&
1433         git -C multisuper_clone submodule update --init &&
1434         git -C multisuper_clone submodule status | sed "s/$OID_REGEX //" >actual &&
1435         test_cmp expect2 actual
1436 '
1437
1438 test_expect_success 'init properly sets the config' '
1439         test_when_finished "rm -rf multisuper_clone" &&
1440         git clone --recurse-submodules="." \
1441                   --recurse-submodules=":(exclude)sub0" \
1442                   multisuper multisuper_clone &&
1443
1444         git -C multisuper_clone submodule init -- sub0 sub1 &&
1445         git -C multisuper_clone config --get submodule.sub0.active &&
1446         test_must_fail git -C multisuper_clone config --get submodule.sub1.active
1447 '
1448
1449 test_expect_success 'recursive clone respects -q' '
1450         test_when_finished "rm -rf multisuper_clone" &&
1451         git clone -q --recurse-submodules multisuper multisuper_clone >actual &&
1452         test_must_be_empty actual
1453 '
1454
1455 test_done