git.oblomov.eu Git - git/blob - 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 . ./test-lib.sh
  13
  14 test_expect_success 'submodule deinit works on empty repository' '
  15         git submodule deinit --all
  16 '
  17
  18 test_expect_success 'setup - initial commit' '
  19         >t &&
  20         git add t &&
  21         git commit -m "initial commit" &&
  22         git branch initial
  23 '
  24
  25 test_expect_success 'submodule init aborts on missing .gitmodules file' '
  26         test_when_finished "git update-index --remove sub" &&
  27         git update-index --add --cacheinfo 160000,$(git rev-parse HEAD),sub &&
  28         # missing the .gitmodules file here
  29         test_must_fail git submodule init 2>actual &&
  30         test_i18ngrep "No url found for submodule path" actual
  31 '
  32
  33 test_expect_success 'submodule update aborts on missing .gitmodules file' '
  34         test_when_finished "git update-index --remove sub" &&
  35         git update-index --add --cacheinfo 160000,$(git rev-parse HEAD),sub &&
  36         # missing the .gitmodules file here
  37         git submodule update sub 2>actual &&
  38         test_i18ngrep "Submodule path .sub. not initialized" actual
  39 '
  40
  41 test_expect_success 'configuration parsing' '
  42         test_when_finished "rm -f .gitmodules" &&
  43         cat >.gitmodules <<-\EOF &&
  44         [submodule "s"]
  45                 path
  46                 ignore
  47         EOF
  48         test_must_fail git status
  49 '
  50
  51 test_expect_success 'setup - repository in init subdirectory' '
  52         mkdir init &&
  53         (
  54                 cd init &&
  55                 git init &&
  56                 echo a >a &&
  57                 git add a &&
  58                 git commit -m "submodule commit 1" &&
  59                 git tag -a -m "rev-1" rev-1
  60         )
  61 '
  62
  63 test_expect_success 'setup - commit with gitlink' '
  64         echo a >a &&
  65         echo z >z &&
  66         git add a init z &&
  67         git commit -m "super commit 1"
  68 '
  69
  70 test_expect_success 'setup - hide init subdirectory' '
  71         mv init .subrepo
  72 '
  73
  74 test_expect_success 'setup - repository to add submodules to' '
  75         git init addtest &&
  76         git init addtest-ignore
  77 '
  78
  79 # The 'submodule add' tests need some repository to add as a submodule.
  80 # The trash directory is a good one as any. We need to canonicalize
  81 # the name, though, as some tests compare it to the absolute path git
  82 # generates, which will expand symbolic links.
  83 submodurl=$(pwd -P)
  84
  85 listbranches() {
  86         git for-each-ref --format='%(refname)' 'refs/heads/*'
  87 }
  88
  89 inspect() {
  90         dir=$1 &&
  91         dotdot="${2:-..}" &&
  92
  93         (
  94                 cd "$dir" &&
  95                 listbranches >"$dotdot/heads" &&
  96                 { git symbolic-ref HEAD || :; } >"$dotdot/head" &&
  97                 git rev-parse HEAD >"$dotdot/head-sha1" &&
  98                 git update-index --refresh &&
  99                 git diff-files --exit-code &&
 100                 git clean -n -d -x >"$dotdot/untracked"
 101         )
 102 }
 103
 104 test_expect_success 'submodule add' '
 105         echo "refs/heads/master" >expect &&
 106         >empty &&
 107
 108         (
 109                 cd addtest &&
 110                 git submodule add -q "$submodurl" submod >actual &&
 111                 test_must_be_empty actual &&
 112                 echo "gitdir: ../.git/modules/submod" >expect &&
 113                 test_cmp expect submod/.git &&
 114                 (
 115                         cd submod &&
 116                         git config core.worktree >actual &&
 117                         echo "../../../submod" >expect &&
 118                         test_cmp expect actual &&
 119                         rm -f actual expect
 120                 ) &&
 121                 git submodule init
 122         ) &&
 123
 124         rm -f heads head untracked &&
 125         inspect addtest/submod ../.. &&
 126         test_cmp expect heads &&
 127         test_cmp expect head &&
 128         test_cmp empty untracked
 129 '
 130
 131 test_expect_success 'submodule add to .gitignored path fails' '
 132         (
 133                 cd addtest-ignore &&
 134                 cat <<-\EOF >expect &&
 135                 The following path is ignored by one of your .gitignore files:
 136                 submod
 137                 Use -f if you really want to add it.
 138                 EOF
 139                 # Does not use test_commit due to the ignore
 140                 echo "*" > .gitignore &&
 141                 git add --force .gitignore &&
 142                 git commit -m"Ignore everything" &&
 143                 ! git submodule add "$submodurl" submod >actual 2>&1 &&
 144                 test_i18ncmp expect actual
 145         )
 146 '
 147
 148 test_expect_success 'submodule add to .gitignored path with --force' '
 149         (
 150                 cd addtest-ignore &&
 151                 git submodule add --force "$submodurl" submod
 152         )
 153 '
 154
 155 test_expect_success 'submodule add --branch' '
 156         echo "refs/heads/initial" >expect-head &&
 157         cat <<-\EOF >expect-heads &&
 158         refs/heads/initial
 159         refs/heads/master
 160         EOF
 161         >empty &&
 162
 163         (
 164                 cd addtest &&
 165                 git submodule add -b initial "$submodurl" submod-branch &&
 166                 test "initial" = "$(git config -f .gitmodules submodule.submod-branch.branch)" &&
 167                 git submodule init
 168         ) &&
 169
 170         rm -f heads head untracked &&
 171         inspect addtest/submod-branch ../.. &&
 172         test_cmp expect-heads heads &&
 173         test_cmp expect-head head &&
 174         test_cmp empty untracked
 175 '
 176
 177 test_expect_success 'submodule add with ./ in path' '
 178         echo "refs/heads/master" >expect &&
 179         >empty &&
 180
 181         (
 182                 cd addtest &&
 183                 git submodule add "$submodurl" ././dotsubmod/./frotz/./ &&
 184                 git submodule init
 185         ) &&
 186
 187         rm -f heads head untracked &&
 188         inspect addtest/dotsubmod/frotz ../../.. &&
 189         test_cmp expect heads &&
 190         test_cmp expect head &&
 191         test_cmp empty untracked
 192 '
 193
 194 test_expect_success 'submodule add with /././ in path' '
 195         echo "refs/heads/master" >expect &&
 196         >empty &&
 197
 198         (
 199                 cd addtest &&
 200                 git submodule add "$submodurl" dotslashdotsubmod/././frotz/./ &&
 201                 git submodule init
 202         ) &&
 203
 204         rm -f heads head untracked &&
 205         inspect addtest/dotslashdotsubmod/frotz ../../.. &&
 206         test_cmp expect heads &&
 207         test_cmp expect head &&
 208         test_cmp empty untracked
 209 '
 210
 211 test_expect_success 'submodule add with // in path' '
 212         echo "refs/heads/master" >expect &&
 213         >empty &&
 214
 215         (
 216                 cd addtest &&
 217                 git submodule add "$submodurl" slashslashsubmod///frotz// &&
 218                 git submodule init
 219         ) &&
 220
 221         rm -f heads head untracked &&
 222         inspect addtest/slashslashsubmod/frotz ../../.. &&
 223         test_cmp expect heads &&
 224         test_cmp expect head &&
 225         test_cmp empty untracked
 226 '
 227
 228 test_expect_success 'submodule add with /.. in path' '
 229         echo "refs/heads/master" >expect &&
 230         >empty &&
 231
 232         (
 233                 cd addtest &&
 234                 git submodule add "$submodurl" dotdotsubmod/../realsubmod/frotz/.. &&
 235                 git submodule init
 236         ) &&
 237
 238         rm -f heads head untracked &&
 239         inspect addtest/realsubmod ../.. &&
 240         test_cmp expect heads &&
 241         test_cmp expect head &&
 242         test_cmp empty untracked
 243 '
 244
 245 test_expect_success 'submodule add with ./, /.. and // in path' '
 246         echo "refs/heads/master" >expect &&
 247         >empty &&
 248
 249         (
 250                 cd addtest &&
 251                 git submodule add "$submodurl" dot/dotslashsubmod/./../..////realsubmod2/a/b/c/d/../../../../frotz//.. &&
 252                 git submodule init
 253         ) &&
 254
 255         rm -f heads head untracked &&
 256         inspect addtest/realsubmod2 ../.. &&
 257         test_cmp expect heads &&
 258         test_cmp expect head &&
 259         test_cmp empty untracked
 260 '
 261
 262 test_expect_success 'submodule add in subdirectory' '
 263         echo "refs/heads/master" >expect &&
 264         >empty &&
 265
 266         mkdir addtest/sub &&
 267         (
 268                 cd addtest/sub &&
 269                 git submodule add "$submodurl" ../realsubmod3 &&
 270                 git submodule init
 271         ) &&
 272
 273         rm -f heads head untracked &&
 274         inspect addtest/realsubmod3 ../.. &&
 275         test_cmp expect heads &&
 276         test_cmp expect head &&
 277         test_cmp empty untracked
 278 '
 279
 280 test_expect_success 'submodule add in subdirectory with relative path should fail' '
 281         (
 282                 cd addtest/sub &&
 283                 test_must_fail git submodule add ../../ submod3 2>../../output.err
 284         ) &&
 285         test_i18ngrep toplevel output.err
 286 '
 287
 288 test_expect_success 'setup - add an example entry to .gitmodules' '
 289         git config --file=.gitmodules submodule.example.url git://example.com/init.git
 290 '
 291
 292 test_expect_success 'status should fail for unmapped paths' '
 293         test_must_fail git submodule status
 294 '
 295
 296 test_expect_success 'setup - map path in .gitmodules' '
 297         cat <<\EOF >expect &&
 298 [submodule "example"]
 299         url = git://example.com/init.git
 300         path = init
 301 EOF
 302
 303         git config --file=.gitmodules submodule.example.path init &&
 304
 305         test_cmp expect .gitmodules
 306 '
 307
 308 test_expect_success 'status should only print one line' '
 309         git submodule status >lines &&
 310         test_line_count = 1 lines
 311 '
 312
 313 test_expect_success 'setup - fetch commit name from submodule' '
 314         rev1=$(cd .subrepo && git rev-parse HEAD) &&
 315         printf "rev1: %s\n" "$rev1" &&
 316         test -n "$rev1"
 317 '
 318
 319 test_expect_success 'status should initially be "missing"' '
 320         git submodule status >lines &&
 321         grep "^-$rev1" lines
 322 '
 323
 324 test_expect_success 'init should register submodule url in .git/config' '
 325         echo git://example.com/init.git >expect &&
 326
 327         git submodule init &&
 328         git config submodule.example.url >url &&
 329         git config submodule.example.url ./.subrepo &&
 330
 331         test_cmp expect url
 332 '
 333
 334 test_failure_with_unknown_submodule () {
 335         test_must_fail git submodule $1 no-such-submodule 2>output.err &&
 336         grep "^error: .*no-such-submodule" output.err
 337 }
 338
 339 test_expect_success 'init should fail with unknown submodule' '
 340         test_failure_with_unknown_submodule init
 341 '
 342
 343 test_expect_success 'update should fail with unknown submodule' '
 344         test_failure_with_unknown_submodule update
 345 '
 346
 347 test_expect_success 'status should fail with unknown submodule' '
 348         test_failure_with_unknown_submodule status
 349 '
 350
 351 test_expect_success 'sync should fail with unknown submodule' '
 352         test_failure_with_unknown_submodule sync
 353 '
 354
 355 test_expect_success 'update should fail when path is used by a file' '
 356         echo hello >expect &&
 357
 358         echo "hello" >init &&
 359         test_must_fail git submodule update &&
 360
 361         test_cmp expect init
 362 '
 363
 364 test_expect_success 'update should fail when path is used by a nonempty directory' '
 365         echo hello >expect &&
 366
 367         rm -fr init &&
 368         mkdir init &&
 369         echo "hello" >init/a &&
 370
 371         test_must_fail git submodule update &&
 372
 373         test_cmp expect init/a
 374 '
 375
 376 test_expect_success 'update should work when path is an empty dir' '
 377         rm -fr init &&
 378         rm -f head-sha1 &&
 379         echo "$rev1" >expect &&
 380
 381         mkdir init &&
 382         git submodule update -q >update.out &&
 383         test_must_be_empty update.out &&
 384
 385         inspect init &&
 386         test_cmp expect head-sha1
 387 '
 388
 389 test_expect_success 'status should be "up-to-date" after update' '
 390         git submodule status >list &&
 391         grep "^ $rev1" list
 392 '
 393
 394 test_expect_success 'status "up-to-date" from subdirectory' '
 395         mkdir -p sub &&
 396         (
 397                 cd sub &&
 398                 git submodule status >../list
 399         ) &&
 400         grep "^ $rev1" list &&
 401         grep "\\.\\./init" list
 402 '
 403
 404 test_expect_success 'status "up-to-date" from subdirectory with path' '
 405         mkdir -p sub &&
 406         (
 407                 cd sub &&
 408                 git submodule status ../init >../list
 409         ) &&
 410         grep "^ $rev1" list &&
 411         grep "\\.\\./init" list
 412 '
 413
 414 test_expect_success 'status should be "modified" after submodule commit' '
 415         (
 416                 cd init &&
 417                 echo b >b &&
 418                 git add b &&
 419                 git commit -m "submodule commit 2"
 420         ) &&
 421
 422         rev2=$(cd init && git rev-parse HEAD) &&
 423         test -n "$rev2" &&
 424         git submodule status >list &&
 425
 426         grep "^+$rev2" list
 427 '
 428
 429 test_expect_success 'the --cached sha1 should be rev1' '
 430         git submodule --cached status >list &&
 431         grep "^+$rev1" list
 432 '
 433
 434 test_expect_success 'git diff should report the SHA1 of the new submodule commit' '
 435         git diff >diff &&
 436         grep "^+Subproject commit $rev2" diff
 437 '
 438
 439 test_expect_success 'update should checkout rev1' '
 440         rm -f head-sha1 &&
 441         echo "$rev1" >expect &&
 442
 443         git submodule update init &&
 444         inspect init &&
 445
 446         test_cmp expect head-sha1
 447 '
 448
 449 test_expect_success 'status should be "up-to-date" after update' '
 450         git submodule status >list &&
 451         grep "^ $rev1" list
 452 '
 453
 454 test_expect_success 'checkout superproject with subproject already present' '
 455         git checkout initial &&
 456         git checkout master
 457 '
 458
 459 test_expect_success 'apply submodule diff' '
 460         >empty &&
 461
 462         git branch second &&
 463         (
 464                 cd init &&
 465                 echo s >s &&
 466                 git add s &&
 467                 git commit -m "change subproject"
 468         ) &&
 469         git update-index --add init &&
 470         git commit -m "change init" &&
 471         git format-patch -1 --stdout >P.diff &&
 472         git checkout second &&
 473         git apply --index P.diff &&
 474
 475         git diff --cached master >staged &&
 476         test_cmp empty staged
 477 '
 478
 479 test_expect_success 'update --init' '
 480         mv init init2 &&
 481         git config -f .gitmodules submodule.example.url "$(pwd)/init2" &&
 482         git config --remove-section submodule.example &&
 483         test_must_fail git config submodule.example.url &&
 484
 485         git submodule update init 2> update.out &&
 486         cat update.out &&
 487         test_i18ngrep "not initialized" update.out &&
 488         test_must_fail git rev-parse --resolve-git-dir init/.git &&
 489
 490         git submodule update --init init &&
 491         git rev-parse --resolve-git-dir init/.git
 492 '
 493
 494 test_expect_success 'update --init from subdirectory' '
 495         mv init init2 &&
 496         git config -f .gitmodules submodule.example.url "$(pwd)/init2" &&
 497         git config --remove-section submodule.example &&
 498         test_must_fail git config submodule.example.url &&
 499
 500         mkdir -p sub &&
 501         (
 502                 cd sub &&
 503                 git submodule update ../init 2>update.out &&
 504                 cat update.out &&
 505                 test_i18ngrep "not initialized" update.out &&
 506                 test_must_fail git rev-parse --resolve-git-dir ../init/.git &&
 507
 508                 git submodule update --init ../init
 509         ) &&
 510         git rev-parse --resolve-git-dir init/.git
 511 '
 512
 513 test_expect_success 'do not add files from a submodule' '
 514
 515         git reset --hard &&
 516         test_must_fail git add init/a
 517
 518 '
 519
 520 test_expect_success 'gracefully add/reset submodule with a trailing slash' '
 521
 522         git reset --hard &&
 523         git commit -m "commit subproject" init &&
 524         (cd init &&
 525          echo b > a) &&
 526         git add init/ &&
 527         git diff --exit-code --cached init &&
 528         commit=$(cd init &&
 529          git commit -m update a >/dev/null &&
 530          git rev-parse HEAD) &&
 531         git add init/ &&
 532         test_must_fail git diff --exit-code --cached init &&
 533         test $commit = $(git ls-files --stage |
 534                 sed -n "s/^160000 \([^ ]*\).*/\1/p") &&
 535         git reset init/ &&
 536         git diff --exit-code --cached init
 537
 538 '
 539
 540 test_expect_success 'ls-files gracefully handles trailing slash' '
 541
 542         test "init" = "$(git ls-files init/)"
 543
 544 '
 545
 546 test_expect_success 'moving to a commit without submodule does not leave empty dir' '
 547         rm -rf init &&
 548         mkdir init &&
 549         git reset --hard &&
 550         git checkout initial &&
 551         test ! -d init &&
 552         git checkout second
 553 '
 554
 555 test_expect_success 'submodule <invalid-subcommand> fails' '
 556         test_must_fail git submodule no-such-subcommand
 557 '
 558
 559 test_expect_success 'add submodules without specifying an explicit path' '
 560         mkdir repo &&
 561         (
 562                 cd repo &&
 563                 git init &&
 564                 echo r >r &&
 565                 git add r &&
 566                 git commit -m "repo commit 1"
 567         ) &&
 568         git clone --bare repo/ bare.git &&
 569         (
 570                 cd addtest &&
 571                 git submodule add "$submodurl/repo" &&
 572                 git config -f .gitmodules submodule.repo.path repo &&
 573                 git submodule add "$submodurl/bare.git" &&
 574                 git config -f .gitmodules submodule.bare.path bare
 575         )
 576 '
 577
 578 test_expect_success 'add should fail when path is used by a file' '
 579         (
 580                 cd addtest &&
 581                 touch file &&
 582                 test_must_fail  git submodule add "$submodurl/repo" file
 583         )
 584 '
 585
 586 test_expect_success 'add should fail when path is used by an existing directory' '
 587         (
 588                 cd addtest &&
 589                 mkdir empty-dir &&
 590                 test_must_fail git submodule add "$submodurl/repo" empty-dir
 591         )
 592 '
 593
 594 test_expect_success 'use superproject as upstream when path is relative and no url is set there' '
 595         (
 596                 cd addtest &&
 597                 git submodule add ../repo relative &&
 598                 test "$(git config -f .gitmodules submodule.relative.url)" = ../repo &&
 599                 git submodule sync relative &&
 600                 test "$(git config submodule.relative.url)" = "$submodurl/repo"
 601         )
 602 '
 603
 604 test_expect_success 'set up for relative path tests' '
 605         mkdir reltest &&
 606         (
 607                 cd reltest &&
 608                 git init &&
 609                 mkdir sub &&
 610                 (
 611                         cd sub &&
 612                         git init &&
 613                         test_commit foo
 614                 ) &&
 615                 git add sub &&
 616                 git config -f .gitmodules submodule.sub.path sub &&
 617                 git config -f .gitmodules submodule.sub.url ../subrepo &&
 618                 cp .git/config pristine-.git-config &&
 619                 cp .gitmodules pristine-.gitmodules
 620         )
 621 '
 622
 623 test_expect_success '../subrepo works with URL - ssh://hostname/repo' '
 624         (
 625                 cd reltest &&
 626                 cp pristine-.git-config .git/config &&
 627                 cp pristine-.gitmodules .gitmodules &&
 628                 git config remote.origin.url ssh://hostname/repo &&
 629                 git submodule init &&
 630                 test "$(git config submodule.sub.url)" = ssh://hostname/subrepo
 631         )
 632 '
 633
 634 test_expect_success '../subrepo works with port-qualified URL - ssh://hostname:22/repo' '
 635         (
 636                 cd reltest &&
 637                 cp pristine-.git-config .git/config &&
 638                 cp pristine-.gitmodules .gitmodules &&
 639                 git config remote.origin.url ssh://hostname:22/repo &&
 640                 git submodule init &&
 641                 test "$(git config submodule.sub.url)" = ssh://hostname:22/subrepo
 642         )
 643 '
 644
 645 # About the choice of the path in the next test:
 646 # - double-slash side-steps path mangling issues on Windows
 647 # - it is still an absolute local path
 648 # - there cannot be a server with a blank in its name just in case the
 649 #   path is used erroneously to access a //server/share style path
 650 test_expect_success '../subrepo path works with local path - //somewhere else/repo' '
 651         (
 652                 cd reltest &&
 653                 cp pristine-.git-config .git/config &&
 654                 cp pristine-.gitmodules .gitmodules &&
 655                 git config remote.origin.url "//somewhere else/repo" &&
 656                 git submodule init &&
 657                 test "$(git config submodule.sub.url)" = "//somewhere else/subrepo"
 658         )
 659 '
 660
 661 test_expect_success '../subrepo works with file URL - file:///tmp/repo' '
 662         (
 663                 cd reltest &&
 664                 cp pristine-.git-config .git/config &&
 665                 cp pristine-.gitmodules .gitmodules &&
 666                 git config remote.origin.url file:///tmp/repo &&
 667                 git submodule init &&
 668                 test "$(git config submodule.sub.url)" = file:///tmp/subrepo
 669         )
 670 '
 671
 672 test_expect_success '../subrepo works with helper URL- helper:://hostname/repo' '
 673         (
 674                 cd reltest &&
 675                 cp pristine-.git-config .git/config &&
 676                 cp pristine-.gitmodules .gitmodules &&
 677                 git config remote.origin.url helper:://hostname/repo &&
 678                 git submodule init &&
 679                 test "$(git config submodule.sub.url)" = helper:://hostname/subrepo
 680         )
 681 '
 682
 683 test_expect_success '../subrepo works with scp-style URL - user@host:repo' '
 684         (
 685                 cd reltest &&
 686                 cp pristine-.git-config .git/config &&
 687                 git config remote.origin.url user@host:repo &&
 688                 git submodule init &&
 689                 test "$(git config submodule.sub.url)" = user@host:subrepo
 690         )
 691 '
 692
 693 test_expect_success '../subrepo works with scp-style URL - user@host:path/to/repo' '
 694         (
 695                 cd reltest &&
 696                 cp pristine-.git-config .git/config &&
 697                 cp pristine-.gitmodules .gitmodules &&
 698                 git config remote.origin.url user@host:path/to/repo &&
 699                 git submodule init &&
 700                 test "$(git config submodule.sub.url)" = user@host:path/to/subrepo
 701         )
 702 '
 703
 704 test_expect_success '../subrepo works with relative local path - foo' '
 705         (
 706                 cd reltest &&
 707                 cp pristine-.git-config .git/config &&
 708                 cp pristine-.gitmodules .gitmodules &&
 709                 git config remote.origin.url foo &&
 710                 # actual: fails with an error
 711                 git submodule init &&
 712                 test "$(git config submodule.sub.url)" = subrepo
 713         )
 714 '
 715
 716 test_expect_success '../subrepo works with relative local path - foo/bar' '
 717         (
 718                 cd reltest &&
 719                 cp pristine-.git-config .git/config &&
 720                 cp pristine-.gitmodules .gitmodules &&
 721                 git config remote.origin.url foo/bar &&
 722                 git submodule init &&
 723                 test "$(git config submodule.sub.url)" = foo/subrepo
 724         )
 725 '
 726
 727 test_expect_success '../subrepo works with relative local path - ./foo' '
 728         (
 729                 cd reltest &&
 730                 cp pristine-.git-config .git/config &&
 731                 cp pristine-.gitmodules .gitmodules &&
 732                 git config remote.origin.url ./foo &&
 733                 git submodule init &&
 734                 test "$(git config submodule.sub.url)" = subrepo
 735         )
 736 '
 737
 738 test_expect_success '../subrepo works with relative local path - ./foo/bar' '
 739         (
 740                 cd reltest &&
 741                 cp pristine-.git-config .git/config &&
 742                 cp pristine-.gitmodules .gitmodules &&
 743                 git config remote.origin.url ./foo/bar &&
 744                 git submodule init &&
 745                 test "$(git config submodule.sub.url)" = foo/subrepo
 746         )
 747 '
 748
 749 test_expect_success '../subrepo works with relative local path - ../foo' '
 750         (
 751                 cd reltest &&
 752                 cp pristine-.git-config .git/config &&
 753                 cp pristine-.gitmodules .gitmodules &&
 754                 git config remote.origin.url ../foo &&
 755                 git submodule init &&
 756                 test "$(git config submodule.sub.url)" = ../subrepo
 757         )
 758 '
 759
 760 test_expect_success '../subrepo works with relative local path - ../foo/bar' '
 761         (
 762                 cd reltest &&
 763                 cp pristine-.git-config .git/config &&
 764                 cp pristine-.gitmodules .gitmodules &&
 765                 git config remote.origin.url ../foo/bar &&
 766                 git submodule init &&
 767                 test "$(git config submodule.sub.url)" = ../foo/subrepo
 768         )
 769 '
 770
 771 test_expect_success '../bar/a/b/c works with relative local path - ../foo/bar.git' '
 772         (
 773                 cd reltest &&
 774                 cp pristine-.git-config .git/config &&
 775                 cp pristine-.gitmodules .gitmodules &&
 776                 mkdir -p a/b/c &&
 777                 (cd a/b/c; git init) &&
 778                 git config remote.origin.url ../foo/bar.git &&
 779                 git submodule add ../bar/a/b/c ./a/b/c &&
 780                 git submodule init &&
 781                 test "$(git config submodule.a/b/c.url)" = ../foo/bar/a/b/c
 782         )
 783 '
 784
 785 test_expect_success 'moving the superproject does not break submodules' '
 786         (
 787                 cd addtest &&
 788                 git submodule status >expect
 789         ) &&
 790         mv addtest addtest2 &&
 791         (
 792                 cd addtest2 &&
 793                 git submodule status >actual &&
 794                 test_cmp expect actual
 795         )
 796 '
 797
 798 test_expect_success 'submodule add --name allows to replace a submodule with another at the same path' '
 799         (
 800                 cd addtest2 &&
 801                 (
 802                         cd repo &&
 803                         echo "$submodurl/repo" >expect &&
 804                         git config remote.origin.url >actual &&
 805                         test_cmp expect actual &&
 806                         echo "gitdir: ../.git/modules/repo" >expect &&
 807                         test_cmp expect .git
 808                 ) &&
 809                 rm -rf repo &&
 810                 git rm repo &&
 811                 git submodule add -q --name repo_new "$submodurl/bare.git" repo >actual &&
 812                 test_must_be_empty actual &&
 813                 echo "gitdir: ../.git/modules/submod" >expect &&
 814                 test_cmp expect submod/.git &&
 815                 (
 816                         cd repo &&
 817                         echo "$submodurl/bare.git" >expect &&
 818                         git config remote.origin.url >actual &&
 819                         test_cmp expect actual &&
 820                         echo "gitdir: ../.git/modules/repo_new" >expect &&
 821                         test_cmp expect .git
 822                 ) &&
 823                 echo "repo" >expect &&
 824                 test_must_fail git config -f .gitmodules submodule.repo.path &&
 825                 git config -f .gitmodules submodule.repo_new.path >actual &&
 826                 test_cmp expect actual&&
 827                 echo "$submodurl/repo" >expect &&
 828                 test_must_fail git config -f .gitmodules submodule.repo.url &&
 829                 echo "$submodurl/bare.git" >expect &&
 830                 git config -f .gitmodules submodule.repo_new.url >actual &&
 831                 test_cmp expect actual &&
 832                 echo "$submodurl/repo" >expect &&
 833                 git config submodule.repo.url >actual &&
 834                 test_cmp expect actual &&
 835                 echo "$submodurl/bare.git" >expect &&
 836                 git config submodule.repo_new.url >actual &&
 837                 test_cmp expect actual
 838         )
 839 '
 840
 841 test_expect_success 'recursive relative submodules stay relative' '
 842         test_when_finished "rm -rf super clone2 subsub sub3" &&
 843         mkdir subsub &&
 844         (
 845                 cd subsub &&
 846                 git init &&
 847                 >t &&
 848                 git add t &&
 849                 git commit -m "initial commit"
 850         ) &&
 851         mkdir sub3 &&
 852         (
 853                 cd sub3 &&
 854                 git init &&
 855                 >t &&
 856                 git add t &&
 857                 git commit -m "initial commit" &&
 858                 git submodule add ../subsub dirdir/subsub &&
 859                 git commit -m "add submodule subsub"
 860         ) &&
 861         mkdir super &&
 862         (
 863                 cd super &&
 864                 git init &&
 865                 >t &&
 866                 git add t &&
 867                 git commit -m "initial commit" &&
 868                 git submodule add ../sub3 &&
 869                 git commit -m "add submodule sub"
 870         ) &&
 871         git clone super clone2 &&
 872         (
 873                 cd clone2 &&
 874                 git submodule update --init --recursive &&
 875                 echo "gitdir: ../.git/modules/sub3" >./sub3/.git_expect &&
 876                 echo "gitdir: ../../../.git/modules/sub3/modules/dirdir/subsub" >./sub3/dirdir/subsub/.git_expect
 877         ) &&
 878         test_cmp clone2/sub3/.git_expect clone2/sub3/.git &&
 879         test_cmp clone2/sub3/dirdir/subsub/.git_expect clone2/sub3/dirdir/subsub/.git
 880 '
 881
 882 test_expect_success 'submodule add with an existing name fails unless forced' '
 883         (
 884                 cd addtest2 &&
 885                 rm -rf repo &&
 886                 git rm repo &&
 887                 test_must_fail git submodule add -q --name repo_new "$submodurl/repo.git" repo &&
 888                 test ! -d repo &&
 889                 test_must_fail git config -f .gitmodules submodule.repo_new.path &&
 890                 test_must_fail git config -f .gitmodules submodule.repo_new.url &&
 891                 echo "$submodurl/bare.git" >expect &&
 892                 git config submodule.repo_new.url >actual &&
 893                 test_cmp expect actual &&
 894                 git submodule add -f -q --name repo_new "$submodurl/repo.git" repo &&
 895                 test -d repo &&
 896                 echo "repo" >expect &&
 897                 git config -f .gitmodules submodule.repo_new.path >actual &&
 898                 test_cmp expect actual&&
 899                 echo "$submodurl/repo.git" >expect &&
 900                 git config -f .gitmodules submodule.repo_new.url >actual &&
 901                 test_cmp expect actual &&
 902                 echo "$submodurl/repo.git" >expect &&
 903                 git config submodule.repo_new.url >actual &&
 904                 test_cmp expect actual
 905         )
 906 '
 907
 908 test_expect_success 'set up a second submodule' '
 909         git submodule add ./init2 example2 &&
 910         git commit -m "submodule example2 added"
 911 '
 912
 913 test_expect_success 'submodule deinit works on repository without submodules' '
 914         test_when_finished "rm -rf newdirectory" &&
 915         mkdir newdirectory &&
 916         (
 917                 cd newdirectory &&
 918                 git init &&
 919                 >file &&
 920                 git add file &&
 921                 git commit -m "repo should not be empty" &&
 922                 git submodule deinit . &&
 923                 git submodule deinit --all
 924         )
 925 '
 926
 927 test_expect_success 'submodule deinit should remove the whole submodule section from .git/config' '
 928         git config submodule.example.foo bar &&
 929         git config submodule.example2.frotz nitfol &&
 930         git submodule deinit init &&
 931         test -z "$(git config --get-regexp "submodule\.example\.")" &&
 932         test -n "$(git config --get-regexp "submodule\.example2\.")" &&
 933         test -f example2/.git &&
 934         rmdir init
 935 '
 936
 937 test_expect_success 'submodule deinit from subdirectory' '
 938         git submodule update --init &&
 939         git config submodule.example.foo bar &&
 940         mkdir -p sub &&
 941         (
 942                 cd sub &&
 943                 git submodule deinit ../init >../output
 944         ) &&
 945         grep "\\.\\./init" output &&
 946         test -z "$(git config --get-regexp "submodule\.example\.")" &&
 947         test -n "$(git config --get-regexp "submodule\.example2\.")" &&
 948         test -f example2/.git &&
 949         rmdir init
 950 '
 951
 952 test_expect_success 'submodule deinit . deinits all initialized submodules' '
 953         git submodule update --init &&
 954         git config submodule.example.foo bar &&
 955         git config submodule.example2.frotz nitfol &&
 956         test_must_fail git submodule deinit &&
 957         git submodule deinit . >actual &&
 958         test -z "$(git config --get-regexp "submodule\.example\.")" &&
 959         test -z "$(git config --get-regexp "submodule\.example2\.")" &&
 960         test_i18ngrep "Cleared directory .init" actual &&
 961         test_i18ngrep "Cleared directory .example2" actual &&
 962         rmdir init example2
 963 '
 964
 965 test_expect_success 'submodule deinit --all deinits all initialized submodules' '
 966         git submodule update --init &&
 967         git config submodule.example.foo bar &&
 968         git config submodule.example2.frotz nitfol &&
 969         test_must_fail git submodule deinit &&
 970         git submodule deinit --all >actual &&
 971         test -z "$(git config --get-regexp "submodule\.example\.")" &&
 972         test -z "$(git config --get-regexp "submodule\.example2\.")" &&
 973         test_i18ngrep "Cleared directory .init" actual &&
 974         test_i18ngrep "Cleared directory .example2" actual &&
 975         rmdir init example2
 976 '
 977
 978 test_expect_success 'submodule deinit deinits a submodule when its work tree is missing or empty' '
 979         git submodule update --init &&
 980         rm -rf init example2/* example2/.git &&
 981         git submodule deinit init example2 >actual &&
 982         test -z "$(git config --get-regexp "submodule\.example\.")" &&
 983         test -z "$(git config --get-regexp "submodule\.example2\.")" &&
 984         test_i18ngrep ! "Cleared directory .init" actual &&
 985         test_i18ngrep "Cleared directory .example2" actual &&
 986         rmdir init
 987 '
 988
 989 test_expect_success 'submodule deinit fails when the submodule contains modifications unless forced' '
 990         git submodule update --init &&
 991         echo X >>init/s &&
 992         test_must_fail git submodule deinit init &&
 993         test -n "$(git config --get-regexp "submodule\.example\.")" &&
 994         test -f example2/.git &&
 995         git submodule deinit -f init >actual &&
 996         test -z "$(git config --get-regexp "submodule\.example\.")" &&
 997         test_i18ngrep "Cleared directory .init" actual &&
 998         rmdir init
 999 '
1000
1001 test_expect_success 'submodule deinit fails when the submodule contains untracked files unless forced' '
1002         git submodule update --init &&
1003         echo X >>init/untracked &&
1004         test_must_fail git submodule deinit init &&
1005         test -n "$(git config --get-regexp "submodule\.example\.")" &&
1006         test -f example2/.git &&
1007         git submodule deinit -f init >actual &&
1008         test -z "$(git config --get-regexp "submodule\.example\.")" &&
1009         test_i18ngrep "Cleared directory .init" actual &&
1010         rmdir init
1011 '
1012
1013 test_expect_success 'submodule deinit fails when the submodule HEAD does not match unless forced' '
1014         git submodule update --init &&
1015         (
1016                 cd init &&
1017                 git checkout HEAD^
1018         ) &&
1019         test_must_fail git submodule deinit init &&
1020         test -n "$(git config --get-regexp "submodule\.example\.")" &&
1021         test -f example2/.git &&
1022         git submodule deinit -f init >actual &&
1023         test -z "$(git config --get-regexp "submodule\.example\.")" &&
1024         test_i18ngrep "Cleared directory .init" actual &&
1025         rmdir init
1026 '
1027
1028 test_expect_success 'submodule deinit is silent when used on an uninitialized submodule' '
1029         git submodule update --init &&
1030         git submodule deinit init >actual &&
1031         test_i18ngrep "Submodule .example. (.*) unregistered for path .init" actual &&
1032         test_i18ngrep "Cleared directory .init" actual &&
1033         git submodule deinit init >actual &&
1034         test_i18ngrep ! "Submodule .example. (.*) unregistered for path .init" actual &&
1035         test_i18ngrep "Cleared directory .init" actual &&
1036         git submodule deinit . >actual &&
1037         test_i18ngrep ! "Submodule .example. (.*) unregistered for path .init" actual &&
1038         test_i18ngrep "Submodule .example2. (.*) unregistered for path .example2" actual &&
1039         test_i18ngrep "Cleared directory .init" actual &&
1040         git submodule deinit . >actual &&
1041         test_i18ngrep ! "Submodule .example. (.*) unregistered for path .init" actual &&
1042         test_i18ngrep ! "Submodule .example2. (.*) unregistered for path .example2" actual &&
1043         test_i18ngrep "Cleared directory .init" actual &&
1044         git submodule deinit --all >actual &&
1045         test_i18ngrep ! "Submodule .example. (.*) unregistered for path .init" actual &&
1046         test_i18ngrep ! "Submodule .example2. (.*) unregistered for path .example2" actual &&
1047         test_i18ngrep "Cleared directory .init" actual &&
1048         rmdir init example2
1049 '
1050
1051 test_expect_success 'submodule deinit fails when submodule has a .git directory even when forced' '
1052         git submodule update --init &&
1053         (
1054                 cd init &&
1055                 rm .git &&
1056                 cp -R ../.git/modules/example .git &&
1057                 GIT_WORK_TREE=. git config --unset core.worktree
1058         ) &&
1059         test_must_fail git submodule deinit init &&
1060         test_must_fail git submodule deinit -f init &&
1061         test -d init/.git &&
1062         test -n "$(git config --get-regexp "submodule\.example\.")"
1063 '
1064
1065 test_expect_success 'submodule with UTF-8 name' '
1066         svname=$(printf "\303\245 \303\244\303\266") &&
1067         mkdir "$svname" &&
1068         (
1069                 cd "$svname" &&
1070                 git init &&
1071                 >sub &&
1072                 git add sub &&
1073                 git commit -m "init sub"
1074         ) &&
1075         git submodule add ./"$svname" &&
1076         git submodule >&2 &&
1077         test -n "$(git submodule | grep "$svname")"
1078 '
1079
1080 test_expect_success 'submodule add clone shallow submodule' '
1081         mkdir super &&
1082         pwd=$(pwd) &&
1083         (
1084                 cd super &&
1085                 git init &&
1086                 git submodule add --depth=1 file://"$pwd"/example2 submodule &&
1087                 (
1088                         cd submodule &&
1089                         test 1 = $(git log --oneline | wc -l)
1090                 )
1091         )
1092 '
1093
1094 test_expect_success 'submodule helper list is not confused by common prefixes' '
1095         mkdir -p dir1/b &&
1096         (
1097                 cd dir1/b &&
1098                 git init &&
1099                 echo hi >testfile2 &&
1100                 git add . &&
1101                 git commit -m "test1"
1102         ) &&
1103         mkdir -p dir2/b &&
1104         (
1105                 cd dir2/b &&
1106                 git init &&
1107                 echo hello >testfile1 &&
1108                 git add .  &&
1109                 git commit -m "test2"
1110         ) &&
1111         git submodule add /dir1/b dir1/b &&
1112         git submodule add /dir2/b dir2/b &&
1113         git commit -m "first submodule commit" &&
1114         git submodule--helper list dir1/b |cut -c51- >actual &&
1115         echo "dir1/b" >expect &&
1116         test_cmp expect actual
1117 '
1118
1119
1120 test_done