t/t5500-fetch-pack.sh

   1 #!/bin/sh
   2 #
   3 # Copyright (c) 2005 Johannes Schindelin
   4 #
   5
   6 test_description='Testing multi_ack pack fetching'
   7
   8 . ./test-lib.sh
   9
  10 # Test fetch-pack/upload-pack pair.
  11
  12 # Some convenience functions
  13
  14 add () {
  15         name=$1 &&
  16         text="$@" &&
  17         branch=$(echo $name | sed -e 's/^\(.\).*$/\1/') &&
  18         parents="" &&
  19
  20         shift &&
  21         while test $1; do
  22                 parents="$parents -p $1" &&
  23                 shift
  24         done &&
  25
  26         echo "$text" > test.txt &&
  27         git update-index --add test.txt &&
  28         tree=$(git write-tree) &&
  29         # make sure timestamps are in correct order
  30         test_tick &&
  31         commit=$(echo "$text" | git commit-tree $tree $parents) &&
  32         eval "$name=$commit; export $name" &&
  33         git update-ref "refs/heads/$branch" "$commit" &&
  34         eval ${branch}TIP=$commit
  35 }
  36
  37 pull_to_client () {
  38         number=$1 &&
  39         heads=$2 &&
  40         count=$3 &&
  41         test_expect_success "$number pull" '
  42                 (
  43                         cd client &&
  44                         git fetch-pack -k -v .. $heads &&
  45
  46                         case "$heads" in
  47                             *A*)
  48                                     git update-ref refs/heads/A "$ATIP";;
  49                         esac &&
  50                         case "$heads" in *B*)
  51                             git update-ref refs/heads/B "$BTIP";;
  52                         esac &&
  53
  54                         git symbolic-ref HEAD refs/heads/$(
  55                                 echo $heads |
  56                                 sed -e "s/^\(.\).*$/\1/"
  57                         ) &&
  58
  59                         git fsck --full &&
  60
  61                         mv .git/objects/pack/pack-* . &&
  62                         p=$(ls -1 pack-*.pack) &&
  63                         git unpack-objects <$p &&
  64                         git fsck --full &&
  65
  66                         idx=$(echo pack-*.idx) &&
  67                         pack_count=$(git show-index <$idx | wc -l) &&
  68                         test $pack_count = $count &&
  69                         rm -f pack-*
  70                 )
  71         '
  72 }
  73
  74 # Here begins the actual testing
  75
  76 # A1 - ... - A20 - A21
  77 #    \
  78 #      B1  -   B2 - .. - B70
  79
  80 # client pulls A20, B1. Then tracks only B. Then pulls A.
  81
  82 test_expect_success 'setup' '
  83         mkdir client &&
  84         (
  85                 cd client &&
  86                 git init &&
  87                 git config transfer.unpacklimit 0
  88         ) &&
  89         add A1 &&
  90         prev=1 &&
  91         cur=2 &&
  92         while [ $cur -le 10 ]; do
  93                 add A$cur $(eval echo \$A$prev) &&
  94                 prev=$cur &&
  95                 cur=$(($cur+1))
  96         done &&
  97         add B1 $A1 &&
  98         git update-ref refs/heads/A "$ATIP" &&
  99         git update-ref refs/heads/B "$BTIP" &&
 100         git symbolic-ref HEAD refs/heads/B
 101 '
 102
 103 pull_to_client 1st "refs/heads/B refs/heads/A" $((11*3))
 104
 105 test_expect_success 'post 1st pull setup' '
 106         add A11 $A10 &&
 107         prev=1 &&
 108         cur=2 &&
 109         while [ $cur -le 65 ]; do
 110                 add B$cur $(eval echo \$B$prev) &&
 111                 prev=$cur &&
 112                 cur=$(($cur+1))
 113         done
 114 '
 115
 116 pull_to_client 2nd "refs/heads/B" $((64*3))
 117
 118 pull_to_client 3rd "refs/heads/A" $((1*3))
 119
 120 test_expect_success 'single branch clone' '
 121         git clone --single-branch "file://$(pwd)/." singlebranch
 122 '
 123
 124 test_expect_success 'single branch object count' '
 125         GIT_DIR=singlebranch/.git git count-objects -v |
 126                 grep "^in-pack:" > count.singlebranch &&
 127         echo "in-pack: 198" >expected &&
 128         test_cmp expected count.singlebranch
 129 '
 130
 131 test_expect_success 'single given branch clone' '
 132         git clone --single-branch --branch A "file://$(pwd)/." branch-a &&
 133         test_must_fail git --git-dir=branch-a/.git rev-parse origin/B
 134 '
 135
 136 test_expect_success 'clone shallow depth 1' '
 137         git clone --no-single-branch --depth 1 "file://$(pwd)/." shallow0 &&
 138         test "$(git --git-dir=shallow0/.git rev-list --count HEAD)" = 1
 139 '
 140
 141 test_expect_success 'clone shallow depth 1 with fsck' '
 142         git config --global fetch.fsckobjects true &&
 143         git clone --no-single-branch --depth 1 "file://$(pwd)/." shallow0fsck &&
 144         test "$(git --git-dir=shallow0fsck/.git rev-list --count HEAD)" = 1 &&
 145         git config --global --unset fetch.fsckobjects
 146 '
 147
 148 test_expect_success 'clone shallow' '
 149         git clone --no-single-branch --depth 2 "file://$(pwd)/." shallow
 150 '
 151
 152 test_expect_success 'clone shallow depth count' '
 153         test "$(git --git-dir=shallow/.git rev-list --count HEAD)" = 2
 154 '
 155
 156 test_expect_success 'clone shallow object count' '
 157         (
 158                 cd shallow &&
 159                 git count-objects -v
 160         ) > count.shallow &&
 161         grep "^in-pack: 12" count.shallow
 162 '
 163
 164 test_expect_success 'clone shallow object count (part 2)' '
 165         sed -e "/^in-pack:/d" -e "/^packs:/d" -e "/^size-pack:/d" \
 166             -e "/: 0$/d" count.shallow > count_output &&
 167         test_must_be_empty count_output
 168 '
 169
 170 test_expect_success 'fsck in shallow repo' '
 171         (
 172                 cd shallow &&
 173                 git fsck --full
 174         )
 175 '
 176
 177 test_expect_success 'simple fetch in shallow repo' '
 178         (
 179                 cd shallow &&
 180                 git fetch
 181         )
 182 '
 183
 184 test_expect_success 'no changes expected' '
 185         (
 186                 cd shallow &&
 187                 git count-objects -v
 188         ) > count.shallow.2 &&
 189         cmp count.shallow count.shallow.2
 190 '
 191
 192 test_expect_success 'fetch same depth in shallow repo' '
 193         (
 194                 cd shallow &&
 195                 git fetch --depth=2
 196         )
 197 '
 198
 199 test_expect_success 'no changes expected' '
 200         (
 201                 cd shallow &&
 202                 git count-objects -v
 203         ) > count.shallow.3 &&
 204         cmp count.shallow count.shallow.3
 205 '
 206
 207 test_expect_success 'add two more' '
 208         add B66 $B65 &&
 209         add B67 $B66
 210 '
 211
 212 test_expect_success 'pull in shallow repo' '
 213         (
 214                 cd shallow &&
 215                 git pull .. B
 216         )
 217 '
 218
 219 test_expect_success 'clone shallow object count' '
 220         (
 221                 cd shallow &&
 222                 git count-objects -v
 223         ) > count.shallow &&
 224         grep "^count: 6" count.shallow
 225 '
 226
 227 test_expect_success 'add two more (part 2)' '
 228         add B68 $B67 &&
 229         add B69 $B68
 230 '
 231
 232 test_expect_success 'deepening pull in shallow repo' '
 233         (
 234                 cd shallow &&
 235                 git pull --depth 4 .. B
 236         )
 237 '
 238
 239 test_expect_success 'clone shallow object count' '
 240         (
 241                 cd shallow &&
 242                 git count-objects -v
 243         ) > count.shallow &&
 244         grep "^count: 12" count.shallow
 245 '
 246
 247 test_expect_success 'deepening fetch in shallow repo' '
 248         (
 249                 cd shallow &&
 250                 git fetch --depth 4 .. A:A
 251         )
 252 '
 253
 254 test_expect_success 'clone shallow object count' '
 255         (
 256                 cd shallow &&
 257                 git count-objects -v
 258         ) > count.shallow &&
 259         grep "^count: 18" count.shallow
 260 '
 261
 262 test_expect_success 'pull in shallow repo with missing merge base' '
 263         (
 264                 cd shallow &&
 265                 git fetch --depth 4 .. A &&
 266                 test_must_fail git merge --allow-unrelated-histories FETCH_HEAD
 267         )
 268 '
 269
 270 test_expect_success 'additional simple shallow deepenings' '
 271         (
 272                 cd shallow &&
 273                 git fetch --depth=8 &&
 274                 git fetch --depth=10 &&
 275                 git fetch --depth=11
 276         )
 277 '
 278
 279 test_expect_success 'clone shallow depth count' '
 280         test "$(git --git-dir=shallow/.git rev-list --count HEAD)" = 11
 281 '
 282
 283 test_expect_success 'clone shallow object count' '
 284         (
 285                 cd shallow &&
 286                 git prune &&
 287                 git count-objects -v
 288         ) > count.shallow &&
 289         grep "^count: 54" count.shallow
 290 '
 291
 292 test_expect_success 'fetch --no-shallow on full repo' '
 293         test_must_fail git fetch --noshallow
 294 '
 295
 296 test_expect_success 'fetch --depth --no-shallow' '
 297         (
 298                 cd shallow &&
 299                 test_must_fail git fetch --depth=1 --noshallow
 300         )
 301 '
 302
 303 test_expect_success 'turn shallow to complete repository' '
 304         (
 305                 cd shallow &&
 306                 git fetch --unshallow &&
 307                 ! test -f .git/shallow &&
 308                 git fsck --full
 309         )
 310 '
 311
 312 test_expect_success 'clone shallow without --no-single-branch' '
 313         git clone --depth 1 "file://$(pwd)/." shallow2
 314 '
 315
 316 test_expect_success 'clone shallow object count' '
 317         (
 318                 cd shallow2 &&
 319                 git count-objects -v
 320         ) > count.shallow2 &&
 321         grep "^in-pack: 3" count.shallow2
 322 '
 323
 324 test_expect_success 'clone shallow with --branch' '
 325         git clone --depth 1 --branch A "file://$(pwd)/." shallow3
 326 '
 327
 328 test_expect_success 'clone shallow object count' '
 329         echo "in-pack: 3" > count3.expected &&
 330         GIT_DIR=shallow3/.git git count-objects -v |
 331                 grep "^in-pack" > count3.actual &&
 332         test_cmp count3.expected count3.actual
 333 '
 334
 335 test_expect_success 'clone shallow with detached HEAD' '
 336         git checkout HEAD^ &&
 337         git clone --depth 1 "file://$(pwd)/." shallow5 &&
 338         git checkout - &&
 339         GIT_DIR=shallow5/.git git rev-parse HEAD >actual &&
 340         git rev-parse HEAD^ >expected &&
 341         test_cmp expected actual
 342 '
 343
 344 test_expect_success 'shallow clone pulling tags' '
 345         git tag -a -m A TAGA1 A &&
 346         git tag -a -m B TAGB1 B &&
 347         git tag TAGA2 A &&
 348         git tag TAGB2 B &&
 349         git clone --depth 1 "file://$(pwd)/." shallow6 &&
 350
 351         cat >taglist.expected <<\EOF &&
 352 TAGB1
 353 TAGB2
 354 EOF
 355         GIT_DIR=shallow6/.git git tag -l >taglist.actual &&
 356         test_cmp taglist.expected taglist.actual &&
 357
 358         echo "in-pack: 4" > count6.expected &&
 359         GIT_DIR=shallow6/.git git count-objects -v |
 360                 grep "^in-pack" > count6.actual &&
 361         test_cmp count6.expected count6.actual
 362 '
 363
 364 test_expect_success 'shallow cloning single tag' '
 365         git clone --depth 1 --branch=TAGB1 "file://$(pwd)/." shallow7 &&
 366         cat >taglist.expected <<\EOF &&
 367 TAGB1
 368 TAGB2
 369 EOF
 370         GIT_DIR=shallow7/.git git tag -l >taglist.actual &&
 371         test_cmp taglist.expected taglist.actual &&
 372
 373         echo "in-pack: 4" > count7.expected &&
 374         GIT_DIR=shallow7/.git git count-objects -v |
 375                 grep "^in-pack" > count7.actual &&
 376         test_cmp count7.expected count7.actual
 377 '
 378
 379 test_expect_success 'clone shallow with packed refs' '
 380         git pack-refs --all &&
 381         git clone --depth 1 --branch A "file://$(pwd)/." shallow8 &&
 382         echo "in-pack: 4" > count8.expected &&
 383         GIT_DIR=shallow8/.git git count-objects -v |
 384                 grep "^in-pack" > count8.actual &&
 385         test_cmp count8.expected count8.actual
 386 '
 387
 388 test_expect_success 'in_vain not triggered before first ACK' '
 389         rm -rf myserver myclient &&
 390         git init myserver &&
 391         test_commit -C myserver foo &&
 392         git clone "file://$(pwd)/myserver" myclient &&
 393
 394         # MAX_IN_VAIN is 256. Because of batching, the client will send 496
 395         # (16+32+64+128+256) commits, not 256, before giving up. So create 496
 396         # irrelevant commits.
 397         test_commit_bulk -C myclient 496 &&
 398
 399         # The new commit that the client wants to fetch.
 400         test_commit -C myserver bar &&
 401
 402         git -C myclient fetch --progress origin 2>log &&
 403         test_i18ngrep "remote: Total 3 " log
 404 '
 405
 406 test_expect_success 'in_vain resetted upon ACK' '
 407         rm -rf myserver myclient &&
 408         git init myserver &&
 409
 410         # Linked list of commits on master. The first is common; the rest are
 411         # not.
 412         test_commit -C myserver first_master_commit &&
 413         git clone "file://$(pwd)/myserver" myclient &&
 414         test_commit_bulk -C myclient 255 &&
 415
 416         # Another linked list of commits on anotherbranch with no connection to
 417         # master. The first is common; the rest are not.
 418         git -C myserver checkout --orphan anotherbranch &&
 419         test_commit -C myserver first_anotherbranch_commit &&
 420         git -C myclient fetch origin anotherbranch:refs/heads/anotherbranch &&
 421         git -C myclient checkout anotherbranch &&
 422         test_commit_bulk -C myclient 255 &&
 423
 424         # The new commit that the client wants to fetch.
 425         git -C myserver checkout master &&
 426         test_commit -C myserver to_fetch &&
 427
 428         # The client will send (as "have"s) all 256 commits in anotherbranch
 429         # first. The 256th commit is common between the client and the server,
 430         # and should reset in_vain. This allows negotiation to continue until
 431         # the client reports that first_anotherbranch_commit is common.
 432         git -C myclient fetch --progress origin master 2>log &&
 433         test_i18ngrep "Total 3 " log
 434 '
 435
 436 test_expect_success 'fetch in shallow repo unreachable shallow objects' '
 437         (
 438                 git clone --bare --branch B --single-branch "file://$(pwd)/." no-reflog &&
 439                 git clone --depth 1 "file://$(pwd)/no-reflog" shallow9 &&
 440                 cd no-reflog &&
 441                 git tag -d TAGB1 TAGB2 &&
 442                 git update-ref refs/heads/B B~~ &&
 443                 git gc --prune=now &&
 444                 cd ../shallow9 &&
 445                 git fetch origin &&
 446                 git fsck --no-dangling
 447         )
 448 '
 449 test_expect_success 'fetch creating new shallow root' '
 450         (
 451                 git clone "file://$(pwd)/." shallow10 &&
 452                 git commit --allow-empty -m empty &&
 453                 cd shallow10 &&
 454                 git fetch --depth=1 --progress 2>actual &&
 455                 # This should fetch only the empty commit, no tree or
 456                 # blob objects
 457                 test_i18ngrep "remote: Total 1" actual
 458         )
 459 '
 460
 461 test_expect_success 'setup tests for the --stdin parameter' '
 462         for head in C D E F
 463         do
 464                 add $head
 465         done &&
 466         for head in A B C D E F
 467         do
 468                 git tag $head $head
 469         done &&
 470         cat >input <<-\EOF &&
 471         refs/heads/C
 472         refs/heads/A
 473         refs/heads/D
 474         refs/tags/C
 475         refs/heads/B
 476         refs/tags/A
 477         refs/heads/E
 478         refs/tags/B
 479         refs/tags/E
 480         refs/tags/D
 481         EOF
 482         sort <input >expect &&
 483         (
 484                 echo refs/heads/E &&
 485                 echo refs/tags/E &&
 486                 cat input
 487         ) >input.dup
 488 '
 489
 490 test_expect_success 'setup fetch refs from cmdline v[12]' '
 491         cp -r client client0 &&
 492         cp -r client client1 &&
 493         cp -r client client2
 494 '
 495
 496 for version in '' 0 1 2
 497 do
 498         test_expect_success "protocol.version=$version fetch refs from cmdline" "
 499                 (
 500                         cd client$version &&
 501                         GIT_TEST_PROTOCOL_VERSION=$version git fetch-pack --no-progress .. \$(cat ../input)
 502                 ) >output &&
 503                 cut -d ' ' -f 2 <output | sort >actual &&
 504                 test_cmp expect actual
 505         "
 506 done
 507
 508 test_expect_success 'fetch refs from stdin' '
 509         (
 510                 cd client &&
 511                 git fetch-pack --stdin --no-progress .. <../input
 512         ) >output &&
 513         cut -d " " -f 2 <output | sort >actual &&
 514         test_cmp expect actual
 515 '
 516
 517 test_expect_success 'fetch mixed refs from cmdline and stdin' '
 518         (
 519                 cd client &&
 520                 tail -n +5 ../input |
 521                 git fetch-pack --stdin --no-progress .. $(head -n 4 ../input)
 522         ) >output &&
 523         cut -d " " -f 2 <output | sort >actual &&
 524         test_cmp expect actual
 525 '
 526
 527 test_expect_success 'test duplicate refs from stdin' '
 528         (
 529         cd client &&
 530         git fetch-pack --stdin --no-progress .. <../input.dup
 531         ) >output &&
 532         cut -d " " -f 2 <output | sort >actual &&
 533         test_cmp expect actual
 534 '
 535
 536 test_expect_success 'set up tests of missing reference' '
 537         cat >expect-error <<-\EOF
 538         error: no such remote ref refs/heads/xyzzy
 539         EOF
 540 '
 541
 542 test_expect_success 'test lonely missing ref' '
 543         (
 544                 cd client &&
 545                 test_must_fail git fetch-pack --no-progress .. refs/heads/xyzzy 2>../error-m
 546         ) &&
 547         test_i18ncmp expect-error error-m
 548 '
 549
 550 test_expect_success 'test missing ref after existing' '
 551         (
 552                 cd client &&
 553                 test_must_fail git fetch-pack --no-progress .. refs/heads/A refs/heads/xyzzy 2>../error-em
 554         ) &&
 555         test_i18ncmp expect-error error-em
 556 '
 557
 558 test_expect_success 'test missing ref before existing' '
 559         (
 560                 cd client &&
 561                 test_must_fail git fetch-pack --no-progress .. refs/heads/xyzzy refs/heads/A 2>../error-me
 562         ) &&
 563         test_i18ncmp expect-error error-me
 564 '
 565
 566 test_expect_success 'test --all, --depth, and explicit head' '
 567         (
 568                 cd client &&
 569                 git fetch-pack --no-progress --all --depth=1 .. refs/heads/A
 570         ) >out-adh 2>error-adh
 571 '
 572
 573 test_expect_success 'test --all, --depth, and explicit tag' '
 574         git tag OLDTAG refs/heads/B~5 &&
 575         (
 576                 cd client &&
 577                 git fetch-pack --no-progress --all --depth=1 .. refs/tags/OLDTAG
 578         ) >out-adt 2>error-adt
 579 '
 580
 581 test_expect_success 'test --all with tag to non-tip' '
 582         git commit --allow-empty -m non-tip &&
 583         git commit --allow-empty -m tip &&
 584         git tag -m "annotated" non-tip HEAD^ &&
 585         (
 586                 cd client &&
 587                 git fetch-pack --all ..
 588         )
 589 '
 590
 591 test_expect_success 'test --all wrt tag to non-commits' '
 592         # create tag-to-{blob,tree,commit,tag}, making sure all tagged objects
 593         # are reachable only via created tag references.
 594         blob=$(echo "hello blob" | git hash-object -t blob -w --stdin) &&
 595         git tag -a -m "tag -> blob" tag-to-blob $blob &&
 596
 597         tree=$(printf "100644 blob $blob\tfile" | git mktree) &&
 598         git tag -a -m "tag -> tree" tag-to-tree $tree &&
 599
 600         tree2=$(printf "100644 blob $blob\tfile2" | git mktree) &&
 601         commit=$(git commit-tree -m "hello commit" $tree) &&
 602         git tag -a -m "tag -> commit" tag-to-commit $commit &&
 603
 604         blob2=$(echo "hello blob2" | git hash-object -t blob -w --stdin) &&
 605         tag=$(git mktag <<-EOF
 606                 object $blob2
 607                 type blob
 608                 tag tag-to-blob2
 609                 tagger author A U Thor <author@example.com> 0 +0000
 610
 611                 hello tag
 612         EOF
 613         ) &&
 614         git tag -a -m "tag -> tag" tag-to-tag $tag &&
 615
 616         # `fetch-pack --all` should succeed fetching all those objects.
 617         mkdir fetchall &&
 618         (
 619                 cd fetchall &&
 620                 git init &&
 621                 git fetch-pack --all .. &&
 622                 git cat-file blob $blob >/dev/null &&
 623                 git cat-file tree $tree >/dev/null &&
 624                 git cat-file commit $commit >/dev/null &&
 625                 git cat-file tag $tag >/dev/null
 626         )
 627 '
 628
 629 test_expect_success 'shallow fetch with tags does not break the repository' '
 630         mkdir repo1 &&
 631         (
 632                 cd repo1 &&
 633                 git init &&
 634                 test_commit 1 &&
 635                 test_commit 2 &&
 636                 test_commit 3 &&
 637                 mkdir repo2 &&
 638                 cd repo2 &&
 639                 git init &&
 640                 git fetch --depth=2 ../.git master:branch &&
 641                 git fsck
 642         )
 643 '
 644
 645 test_expect_success 'fetch-pack can fetch a raw sha1' '
 646         git init hidden &&
 647         (
 648                 cd hidden &&
 649                 test_commit 1 &&
 650                 test_commit 2 &&
 651                 git update-ref refs/hidden/one HEAD^ &&
 652                 git config transfer.hiderefs refs/hidden &&
 653                 git config uploadpack.allowtipsha1inwant true
 654         ) &&
 655         git fetch-pack hidden $(git -C hidden rev-parse refs/hidden/one)
 656 '
 657
 658 test_expect_success 'fetch-pack can fetch a raw sha1 that is advertised as a ref' '
 659         rm -rf server client &&
 660         git init server &&
 661         test_commit -C server 1 &&
 662
 663         git init client &&
 664         git -C client fetch-pack ../server \
 665                 $(git -C server rev-parse refs/heads/master)
 666 '
 667
 668 test_expect_success 'fetch-pack can fetch a raw sha1 overlapping a named ref' '
 669         rm -rf server client &&
 670         git init server &&
 671         test_commit -C server 1 &&
 672         test_commit -C server 2 &&
 673
 674         git init client &&
 675         git -C client fetch-pack ../server \
 676                 $(git -C server rev-parse refs/tags/1) refs/tags/1
 677 '
 678
 679 test_expect_success 'fetch-pack cannot fetch a raw sha1 that is not advertised as a ref' '
 680         rm -rf server &&
 681
 682         git init server &&
 683         test_commit -C server 5 &&
 684         git -C server tag -d 5 &&
 685         test_commit -C server 6 &&
 686
 687         git init client &&
 688         # Some protocol versions (e.g. 2) support fetching
 689         # unadvertised objects, so restrict this test to v0.
 690         test_must_fail env GIT_TEST_PROTOCOL_VERSION=0 git -C client fetch-pack ../server \
 691                 $(git -C server rev-parse refs/heads/master^) 2>err &&
 692         test_i18ngrep "Server does not allow request for unadvertised object" err
 693 '
 694
 695 check_prot_path () {
 696         cat >expected <<-EOF &&
 697         Diag: url=$1
 698         Diag: protocol=$2
 699         Diag: path=$3
 700         EOF
 701         git fetch-pack --diag-url "$1" | grep -v hostandport= >actual &&
 702         test_cmp expected actual
 703 }
 704
 705 check_prot_host_port_path () {
 706         case "$2" in
 707                 *ssh*)
 708                 pp=ssh
 709                 uah=userandhost
 710                 ehost=$(echo $3 | tr -d "[]")
 711                 diagport="Diag: port=$4"
 712                 ;;
 713                 *)
 714                 pp=$p
 715                 uah=hostandport
 716                 ehost=$(echo $3$4 | sed -e "s/22$/:22/" -e "s/NONE//")
 717                 diagport=""
 718                 ;;
 719         esac
 720         cat >exp <<-EOF &&
 721         Diag: url=$1
 722         Diag: protocol=$pp
 723         Diag: $uah=$ehost
 724         $diagport
 725         Diag: path=$5
 726         EOF
 727         grep -v "^$" exp >expected
 728         git fetch-pack --diag-url "$1" >actual &&
 729         test_cmp expected actual
 730 }
 731
 732 for r in repo re:po re/po
 733 do
 734         # git or ssh with scheme
 735         for p in "ssh+git" "git+ssh" git ssh
 736         do
 737                 for h in host user@host user@[::1] user@::1
 738                 do
 739                         for c in "" :
 740                         do
 741                                 test_expect_success "fetch-pack --diag-url $p://$h$c/$r" '
 742                                         check_prot_host_port_path $p://$h/$r $p "$h" NONE "/$r"
 743                                 '
 744                                 # "/~" -> "~" conversion
 745                                 test_expect_success "fetch-pack --diag-url $p://$h$c/~$r" '
 746                                         check_prot_host_port_path $p://$h/~$r $p "$h" NONE "~$r"
 747                                 '
 748                         done
 749                 done
 750                 for h in host User@host User@[::1]
 751                 do
 752                         test_expect_success "fetch-pack --diag-url $p://$h:22/$r" '
 753                                 check_prot_host_port_path $p://$h:22/$r $p "$h" 22 "/$r"
 754                         '
 755                 done
 756         done
 757         # file with scheme
 758         for p in file
 759         do
 760                 test_expect_success !MINGW "fetch-pack --diag-url $p://$h/$r" '
 761                         check_prot_path $p://$h/$r $p "/$r"
 762                 '
 763                 test_expect_success MINGW "fetch-pack --diag-url $p://$h/$r" '
 764                         check_prot_path $p://$h/$r $p "//$h/$r"
 765                 '
 766                 test_expect_success MINGW "fetch-pack --diag-url $p:///$r" '
 767                         check_prot_path $p:///$r $p "/$r"
 768                 '
 769                 # No "/~" -> "~" conversion for file
 770                 test_expect_success !MINGW "fetch-pack --diag-url $p://$h/~$r" '
 771                         check_prot_path $p://$h/~$r $p "/~$r"
 772                 '
 773                 test_expect_success MINGW "fetch-pack --diag-url $p://$h/~$r" '
 774                         check_prot_path $p://$h/~$r $p "//$h/~$r"
 775                 '
 776         done
 777         # file without scheme
 778         for h in nohost nohost:12 [::1] [::1]:23 [ [:aa
 779         do
 780                 test_expect_success "fetch-pack --diag-url ./$h:$r" '
 781                         check_prot_path ./$h:$r $p "./$h:$r"
 782                 '
 783                 # No "/~" -> "~" conversion for file
 784                 test_expect_success "fetch-pack --diag-url ./$p:$h/~$r" '
 785                 check_prot_path ./$p:$h/~$r $p "./$p:$h/~$r"
 786                 '
 787         done
 788         #ssh without scheme
 789         p=ssh
 790         for h in host [::1]
 791         do
 792                 test_expect_success "fetch-pack --diag-url $h:$r" '
 793                         check_prot_host_port_path $h:$r $p "$h" NONE "$r"
 794                 '
 795                 # Do "/~" -> "~" conversion
 796                 test_expect_success "fetch-pack --diag-url $h:/~$r" '
 797                         check_prot_host_port_path $h:/~$r $p "$h" NONE "~$r"
 798                 '
 799         done
 800 done
 801
 802 test_expect_success MINGW 'fetch-pack --diag-url file://c:/repo' '
 803         check_prot_path file://c:/repo file c:/repo
 804 '
 805 test_expect_success MINGW 'fetch-pack --diag-url c:repo' '
 806         check_prot_path c:repo file c:repo
 807 '
 808
 809 test_expect_success 'clone shallow since ...' '
 810         test_create_repo shallow-since &&
 811         (
 812         cd shallow-since &&
 813         GIT_COMMITTER_DATE="100000000 +0700" git commit --allow-empty -m one &&
 814         GIT_COMMITTER_DATE="200000000 +0700" git commit --allow-empty -m two &&
 815         GIT_COMMITTER_DATE="300000000 +0700" git commit --allow-empty -m three &&
 816         git clone --shallow-since "300000000 +0700" "file://$(pwd)/." ../shallow11 &&
 817         git -C ../shallow11 log --pretty=tformat:%s HEAD >actual &&
 818         echo three >expected &&
 819         test_cmp expected actual
 820         )
 821 '
 822
 823 test_expect_success 'fetch shallow since ...' '
 824         git -C shallow11 fetch --shallow-since "200000000 +0700" origin &&
 825         git -C shallow11 log --pretty=tformat:%s origin/master >actual &&
 826         cat >expected <<-\EOF &&
 827         three
 828         two
 829         EOF
 830         test_cmp expected actual
 831 '
 832
 833 test_expect_success 'clone shallow since selects no commits' '
 834         test_create_repo shallow-since-the-future &&
 835         (
 836         cd shallow-since-the-future &&
 837         GIT_COMMITTER_DATE="100000000 +0700" git commit --allow-empty -m one &&
 838         GIT_COMMITTER_DATE="200000000 +0700" git commit --allow-empty -m two &&
 839         GIT_COMMITTER_DATE="300000000 +0700" git commit --allow-empty -m three &&
 840         test_must_fail git clone --shallow-since "900000000 +0700" "file://$(pwd)/." ../shallow111
 841         )
 842 '
 843
 844 # A few subtle things about the request in this test:
 845 #
 846 #  - the server must have commit-graphs present and enabled
 847 #
 848 #  - the history is such that our want/have share a common ancestor ("base"
 849 #    here)
 850 #
 851 #  - we send only a single have, which is fewer than a normal client would
 852 #    send. This ensures that we don't parse "base" up front with
 853 #    parse_object(), but rather traverse to it as a parent while deciding if we
 854 #    can stop the "have" negotiation, and call parse_commit(). The former
 855 #    sees the actual object data and so always loads the three oid, whereas the
 856 #    latter will try to load it lazily.
 857 #
 858 #  - we must use protocol v2, because it handles the "have" negotiation before
 859 #    processing the shallow directives
 860 #
 861 test_expect_success 'shallow since with commit graph and already-seen commit' '
 862         test_create_repo shallow-since-graph &&
 863         (
 864         cd shallow-since-graph &&
 865         test_commit base &&
 866         test_commit master &&
 867         git checkout -b other HEAD^ &&
 868         test_commit other &&
 869         git commit-graph write --reachable &&
 870         git config core.commitGraph true &&
 871
 872         GIT_PROTOCOL=version=2 git upload-pack . <<-EOF >/dev/null
 873         0012command=fetch
 874         00010013deepen-since 1
 875         0032want $(git rev-parse other)
 876         0032have $(git rev-parse master)
 877         0000
 878         EOF
 879         )
 880 '
 881
 882 test_expect_success 'shallow clone exclude tag two' '
 883         test_create_repo shallow-exclude &&
 884         (
 885         cd shallow-exclude &&
 886         test_commit one &&
 887         test_commit two &&
 888         test_commit three &&
 889         git clone --shallow-exclude two "file://$(pwd)/." ../shallow12 &&
 890         git -C ../shallow12 log --pretty=tformat:%s HEAD >actual &&
 891         echo three >expected &&
 892         test_cmp expected actual
 893         )
 894 '
 895
 896 test_expect_success 'fetch exclude tag one' '
 897         git -C shallow12 fetch --shallow-exclude one origin &&
 898         git -C shallow12 log --pretty=tformat:%s origin/master >actual &&
 899         test_write_lines three two >expected &&
 900         test_cmp expected actual
 901 '
 902
 903 test_expect_success 'fetching deepen' '
 904         test_create_repo shallow-deepen &&
 905         (
 906         cd shallow-deepen &&
 907         test_commit one &&
 908         test_commit two &&
 909         test_commit three &&
 910         git clone --depth 1 "file://$(pwd)/." deepen &&
 911         test_commit four &&
 912         git -C deepen log --pretty=tformat:%s master >actual &&
 913         echo three >expected &&
 914         test_cmp expected actual &&
 915         git -C deepen fetch --deepen=1 &&
 916         git -C deepen log --pretty=tformat:%s origin/master >actual &&
 917         cat >expected <<-\EOF &&
 918         four
 919         three
 920         two
 921         EOF
 922         test_cmp expected actual
 923         )
 924 '
 925
 926 test_expect_success 'use ref advertisement to prune "have" lines sent' '
 927         rm -rf server client &&
 928         git init server &&
 929         test_commit -C server both_have_1 &&
 930         git -C server tag -d both_have_1 &&
 931         test_commit -C server both_have_2 &&
 932
 933         git clone server client &&
 934         test_commit -C server server_has &&
 935         test_commit -C client client_has &&
 936
 937         # In both protocol v0 and v2, ensure that the parent of both_have_2 is
 938         # not sent as a "have" line. The client should know that the server has
 939         # both_have_2, so it only needs to inform the server that it has
 940         # both_have_2, and the server can infer the rest.
 941
 942         rm -f trace &&
 943         cp -r client clientv0 &&
 944         GIT_TRACE_PACKET="$(pwd)/trace" git -C clientv0 \
 945                 fetch origin server_has both_have_2 &&
 946         grep "have $(git -C client rev-parse client_has)" trace &&
 947         grep "have $(git -C client rev-parse both_have_2)" trace &&
 948         ! grep "have $(git -C client rev-parse both_have_2^)" trace &&
 949
 950         rm -f trace &&
 951         cp -r client clientv2 &&
 952         GIT_TRACE_PACKET="$(pwd)/trace" git -C clientv2 -c protocol.version=2 \
 953                 fetch origin server_has both_have_2 &&
 954         grep "have $(git -C client rev-parse client_has)" trace &&
 955         grep "have $(git -C client rev-parse both_have_2)" trace &&
 956         ! grep "have $(git -C client rev-parse both_have_2^)" trace
 957 '
 958
 959 test_expect_success 'filtering by size' '
 960         rm -rf server client &&
 961         test_create_repo server &&
 962         test_commit -C server one &&
 963         test_config -C server uploadpack.allowfilter 1 &&
 964
 965         test_create_repo client &&
 966         git -C client fetch-pack --filter=blob:limit=0 ../server HEAD &&
 967
 968         # Ensure that object is not inadvertently fetched
 969         commit=$(git -C server rev-parse HEAD) &&
 970         blob=$(git hash-object server/one.t) &&
 971         git -C client rev-list --objects --missing=allow-any "$commit" >oids &&
 972         ! grep "$blob" oids
 973 '
 974
 975 test_expect_success 'filtering by size has no effect if support for it is not advertised' '
 976         rm -rf server client &&
 977         test_create_repo server &&
 978         test_commit -C server one &&
 979
 980         test_create_repo client &&
 981         git -C client fetch-pack --filter=blob:limit=0 ../server HEAD 2> err &&
 982
 983         # Ensure that object is fetched
 984         commit=$(git -C server rev-parse HEAD) &&
 985         blob=$(git hash-object server/one.t) &&
 986         git -C client rev-list --objects --missing=allow-any "$commit" >oids &&
 987         grep "$blob" oids &&
 988
 989         test_i18ngrep "filtering not recognized by server" err
 990 '
 991
 992 fetch_filter_blob_limit_zero () {
 993         SERVER="$1"
 994         URL="$2"
 995
 996         rm -rf "$SERVER" client &&
 997         test_create_repo "$SERVER" &&
 998         test_commit -C "$SERVER" one &&
 999         test_config -C "$SERVER" uploadpack.allowfilter 1 &&
1000
1001         git clone "$URL" client &&
1002         test_config -C client extensions.partialclone origin &&
1003
1004         test_commit -C "$SERVER" two &&
1005
1006         git -C client fetch --filter=blob:limit=0 origin HEAD:somewhere &&
1007
1008         # Ensure that commit is fetched, but blob is not
1009         commit=$(git -C "$SERVER" rev-parse two) &&
1010         blob=$(git hash-object server/two.t) &&
1011         git -C client rev-list --objects --missing=allow-any "$commit" >oids &&
1012         grep "$commit" oids &&
1013         ! grep "$blob" oids
1014 }
1015
1016 test_expect_success 'fetch with --filter=blob:limit=0' '
1017         fetch_filter_blob_limit_zero server server
1018 '
1019
1020 . "$TEST_DIRECTORY"/lib-httpd.sh
1021 start_httpd
1022
1023 test_expect_success 'fetch with --filter=blob:limit=0 and HTTP' '
1024         fetch_filter_blob_limit_zero "$HTTPD_DOCUMENT_ROOT_PATH/server" "$HTTPD_URL/smart/server"
1025 '
1026
1027 # DO NOT add non-httpd-specific tests here, because the last part of this
1028 # test script is only executed when httpd is available and enabled.
1029
1030 test_done