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