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 'fetch in shallow repo unreachable shallow objects' '
 389         (
 390                 git clone --bare --branch B --single-branch "file://$(pwd)/." no-reflog &&
 391                 git clone --depth 1 "file://$(pwd)/no-reflog" shallow9 &&
 392                 cd no-reflog &&
 393                 git tag -d TAGB1 TAGB2 &&
 394                 git update-ref refs/heads/B B~~ &&
 395                 git gc --prune=now &&
 396                 cd ../shallow9 &&
 397                 git fetch origin &&
 398                 git fsck --no-dangling
 399         )
 400 '
 401 test_expect_success 'fetch creating new shallow root' '
 402         (
 403                 git clone "file://$(pwd)/." shallow10 &&
 404                 git commit --allow-empty -m empty &&
 405                 cd shallow10 &&
 406                 git fetch --depth=1 --progress 2>actual &&
 407                 # This should fetch only the empty commit, no tree or
 408                 # blob objects
 409                 test_i18ngrep "remote: Total 1" actual
 410         )
 411 '
 412
 413 test_expect_success 'setup tests for the --stdin parameter' '
 414         for head in C D E F
 415         do
 416                 add $head
 417         done &&
 418         for head in A B C D E F
 419         do
 420                 git tag $head $head
 421         done &&
 422         cat >input <<-\EOF &&
 423         refs/heads/C
 424         refs/heads/A
 425         refs/heads/D
 426         refs/tags/C
 427         refs/heads/B
 428         refs/tags/A
 429         refs/heads/E
 430         refs/tags/B
 431         refs/tags/E
 432         refs/tags/D
 433         EOF
 434         sort <input >expect &&
 435         (
 436                 echo refs/heads/E &&
 437                 echo refs/tags/E &&
 438                 cat input
 439         ) >input.dup
 440 '
 441
 442 test_expect_success 'setup fetch refs from cmdline v[12]' '
 443         cp -r client client0 &&
 444         cp -r client client1 &&
 445         cp -r client client2
 446 '
 447
 448 for version in '' 0 1 2
 449 do
 450         test_expect_success "protocol.version=$version fetch refs from cmdline" "
 451                 (
 452                         cd client$version &&
 453                         GIT_TEST_PROTOCOL_VERSION=$version git fetch-pack --no-progress .. \$(cat ../input)
 454                 ) >output &&
 455                 cut -d ' ' -f 2 <output | sort >actual &&
 456                 test_cmp expect actual
 457         "
 458 done
 459
 460 test_expect_success 'fetch refs from stdin' '
 461         (
 462                 cd client &&
 463                 git fetch-pack --stdin --no-progress .. <../input
 464         ) >output &&
 465         cut -d " " -f 2 <output | sort >actual &&
 466         test_cmp expect actual
 467 '
 468
 469 test_expect_success 'fetch mixed refs from cmdline and stdin' '
 470         (
 471                 cd client &&
 472                 tail -n +5 ../input |
 473                 git fetch-pack --stdin --no-progress .. $(head -n 4 ../input)
 474         ) >output &&
 475         cut -d " " -f 2 <output | sort >actual &&
 476         test_cmp expect actual
 477 '
 478
 479 test_expect_success 'test duplicate refs from stdin' '
 480         (
 481         cd client &&
 482         git fetch-pack --stdin --no-progress .. <../input.dup
 483         ) >output &&
 484         cut -d " " -f 2 <output | sort >actual &&
 485         test_cmp expect actual
 486 '
 487
 488 test_expect_success 'set up tests of missing reference' '
 489         cat >expect-error <<-\EOF
 490         error: no such remote ref refs/heads/xyzzy
 491         EOF
 492 '
 493
 494 test_expect_success 'test lonely missing ref' '
 495         (
 496                 cd client &&
 497                 test_must_fail git fetch-pack --no-progress .. refs/heads/xyzzy 2>../error-m
 498         ) &&
 499         test_i18ncmp expect-error error-m
 500 '
 501
 502 test_expect_success 'test missing ref after existing' '
 503         (
 504                 cd client &&
 505                 test_must_fail git fetch-pack --no-progress .. refs/heads/A refs/heads/xyzzy 2>../error-em
 506         ) &&
 507         test_i18ncmp expect-error error-em
 508 '
 509
 510 test_expect_success 'test missing ref before existing' '
 511         (
 512                 cd client &&
 513                 test_must_fail git fetch-pack --no-progress .. refs/heads/xyzzy refs/heads/A 2>../error-me
 514         ) &&
 515         test_i18ncmp expect-error error-me
 516 '
 517
 518 test_expect_success 'test --all, --depth, and explicit head' '
 519         (
 520                 cd client &&
 521                 git fetch-pack --no-progress --all --depth=1 .. refs/heads/A
 522         ) >out-adh 2>error-adh
 523 '
 524
 525 test_expect_success 'test --all, --depth, and explicit tag' '
 526         git tag OLDTAG refs/heads/B~5 &&
 527         (
 528                 cd client &&
 529                 git fetch-pack --no-progress --all --depth=1 .. refs/tags/OLDTAG
 530         ) >out-adt 2>error-adt
 531 '
 532
 533 test_expect_success 'test --all with tag to non-tip' '
 534         git commit --allow-empty -m non-tip &&
 535         git commit --allow-empty -m tip &&
 536         git tag -m "annotated" non-tip HEAD^ &&
 537         (
 538                 cd client &&
 539                 git fetch-pack --all ..
 540         )
 541 '
 542
 543 test_expect_success 'test --all wrt tag to non-commits' '
 544         # create tag-to-{blob,tree,commit,tag}, making sure all tagged objects
 545         # are reachable only via created tag references.
 546         blob=$(echo "hello blob" | git hash-object -t blob -w --stdin) &&
 547         git tag -a -m "tag -> blob" tag-to-blob $blob &&
 548
 549         tree=$(printf "100644 blob $blob\tfile" | git mktree) &&
 550         git tag -a -m "tag -> tree" tag-to-tree $tree &&
 551
 552         tree2=$(printf "100644 blob $blob\tfile2" | git mktree) &&
 553         commit=$(git commit-tree -m "hello commit" $tree) &&
 554         git tag -a -m "tag -> commit" tag-to-commit $commit &&
 555
 556         blob2=$(echo "hello blob2" | git hash-object -t blob -w --stdin) &&
 557         tag=$(git mktag <<-EOF
 558                 object $blob2
 559                 type blob
 560                 tag tag-to-blob2
 561                 tagger author A U Thor <author@example.com> 0 +0000
 562
 563                 hello tag
 564         EOF
 565         ) &&
 566         git tag -a -m "tag -> tag" tag-to-tag $tag &&
 567
 568         # `fetch-pack --all` should succeed fetching all those objects.
 569         mkdir fetchall &&
 570         (
 571                 cd fetchall &&
 572                 git init &&
 573                 git fetch-pack --all .. &&
 574                 git cat-file blob $blob >/dev/null &&
 575                 git cat-file tree $tree >/dev/null &&
 576                 git cat-file commit $commit >/dev/null &&
 577                 git cat-file tag $tag >/dev/null
 578         )
 579 '
 580
 581 test_expect_success 'shallow fetch with tags does not break the repository' '
 582         mkdir repo1 &&
 583         (
 584                 cd repo1 &&
 585                 git init &&
 586                 test_commit 1 &&
 587                 test_commit 2 &&
 588                 test_commit 3 &&
 589                 mkdir repo2 &&
 590                 cd repo2 &&
 591                 git init &&
 592                 git fetch --depth=2 ../.git master:branch &&
 593                 git fsck
 594         )
 595 '
 596
 597 test_expect_success 'fetch-pack can fetch a raw sha1' '
 598         git init hidden &&
 599         (
 600                 cd hidden &&
 601                 test_commit 1 &&
 602                 test_commit 2 &&
 603                 git update-ref refs/hidden/one HEAD^ &&
 604                 git config transfer.hiderefs refs/hidden &&
 605                 git config uploadpack.allowtipsha1inwant true
 606         ) &&
 607         git fetch-pack hidden $(git -C hidden rev-parse refs/hidden/one)
 608 '
 609
 610 test_expect_success 'fetch-pack can fetch a raw sha1 that is advertised as a ref' '
 611         rm -rf server client &&
 612         git init server &&
 613         test_commit -C server 1 &&
 614
 615         git init client &&
 616         git -C client fetch-pack ../server \
 617                 $(git -C server rev-parse refs/heads/master)
 618 '
 619
 620 test_expect_success 'fetch-pack can fetch a raw sha1 overlapping a named ref' '
 621         rm -rf server client &&
 622         git init server &&
 623         test_commit -C server 1 &&
 624         test_commit -C server 2 &&
 625
 626         git init client &&
 627         git -C client fetch-pack ../server \
 628                 $(git -C server rev-parse refs/tags/1) refs/tags/1
 629 '
 630
 631 test_expect_success 'fetch-pack cannot fetch a raw sha1 that is not advertised as a ref' '
 632         rm -rf server &&
 633
 634         git init server &&
 635         test_commit -C server 5 &&
 636         git -C server tag -d 5 &&
 637         test_commit -C server 6 &&
 638
 639         git init client &&
 640         # Some protocol versions (e.g. 2) support fetching
 641         # unadvertised objects, so restrict this test to v0.
 642         test_must_fail env GIT_TEST_PROTOCOL_VERSION=0 git -C client fetch-pack ../server \
 643                 $(git -C server rev-parse refs/heads/master^) 2>err &&
 644         test_i18ngrep "Server does not allow request for unadvertised object" err
 645 '
 646
 647 check_prot_path () {
 648         cat >expected <<-EOF &&
 649         Diag: url=$1
 650         Diag: protocol=$2
 651         Diag: path=$3
 652         EOF
 653         git fetch-pack --diag-url "$1" | grep -v hostandport= >actual &&
 654         test_cmp expected actual
 655 }
 656
 657 check_prot_host_port_path () {
 658         case "$2" in
 659                 *ssh*)
 660                 pp=ssh
 661                 uah=userandhost
 662                 ehost=$(echo $3 | tr -d "[]")
 663                 diagport="Diag: port=$4"
 664                 ;;
 665                 *)
 666                 pp=$p
 667                 uah=hostandport
 668                 ehost=$(echo $3$4 | sed -e "s/22$/:22/" -e "s/NONE//")
 669                 diagport=""
 670                 ;;
 671         esac
 672         cat >exp <<-EOF &&
 673         Diag: url=$1
 674         Diag: protocol=$pp
 675         Diag: $uah=$ehost
 676         $diagport
 677         Diag: path=$5
 678         EOF
 679         grep -v "^$" exp >expected
 680         git fetch-pack --diag-url "$1" >actual &&
 681         test_cmp expected actual
 682 }
 683
 684 for r in repo re:po re/po
 685 do
 686         # git or ssh with scheme
 687         for p in "ssh+git" "git+ssh" git ssh
 688         do
 689                 for h in host user@host user@[::1] user@::1
 690                 do
 691                         for c in "" :
 692                         do
 693                                 test_expect_success "fetch-pack --diag-url $p://$h$c/$r" '
 694                                         check_prot_host_port_path $p://$h/$r $p "$h" NONE "/$r"
 695                                 '
 696                                 # "/~" -> "~" conversion
 697                                 test_expect_success "fetch-pack --diag-url $p://$h$c/~$r" '
 698                                         check_prot_host_port_path $p://$h/~$r $p "$h" NONE "~$r"
 699                                 '
 700                         done
 701                 done
 702                 for h in host User@host User@[::1]
 703                 do
 704                         test_expect_success "fetch-pack --diag-url $p://$h:22/$r" '
 705                                 check_prot_host_port_path $p://$h:22/$r $p "$h" 22 "/$r"
 706                         '
 707                 done
 708         done
 709         # file with scheme
 710         for p in file
 711         do
 712                 test_expect_success !MINGW "fetch-pack --diag-url $p://$h/$r" '
 713                         check_prot_path $p://$h/$r $p "/$r"
 714                 '
 715                 test_expect_success MINGW "fetch-pack --diag-url $p://$h/$r" '
 716                         check_prot_path $p://$h/$r $p "//$h/$r"
 717                 '
 718                 test_expect_success MINGW "fetch-pack --diag-url $p:///$r" '
 719                         check_prot_path $p:///$r $p "/$r"
 720                 '
 721                 # No "/~" -> "~" conversion for file
 722                 test_expect_success !MINGW "fetch-pack --diag-url $p://$h/~$r" '
 723                         check_prot_path $p://$h/~$r $p "/~$r"
 724                 '
 725                 test_expect_success MINGW "fetch-pack --diag-url $p://$h/~$r" '
 726                         check_prot_path $p://$h/~$r $p "//$h/~$r"
 727                 '
 728         done
 729         # file without scheme
 730         for h in nohost nohost:12 [::1] [::1]:23 [ [:aa
 731         do
 732                 test_expect_success "fetch-pack --diag-url ./$h:$r" '
 733                         check_prot_path ./$h:$r $p "./$h:$r"
 734                 '
 735                 # No "/~" -> "~" conversion for file
 736                 test_expect_success "fetch-pack --diag-url ./$p:$h/~$r" '
 737                 check_prot_path ./$p:$h/~$r $p "./$p:$h/~$r"
 738                 '
 739         done
 740         #ssh without scheme
 741         p=ssh
 742         for h in host [::1]
 743         do
 744                 test_expect_success "fetch-pack --diag-url $h:$r" '
 745                         check_prot_host_port_path $h:$r $p "$h" NONE "$r"
 746                 '
 747                 # Do "/~" -> "~" conversion
 748                 test_expect_success "fetch-pack --diag-url $h:/~$r" '
 749                         check_prot_host_port_path $h:/~$r $p "$h" NONE "~$r"
 750                 '
 751         done
 752 done
 753
 754 test_expect_success MINGW 'fetch-pack --diag-url file://c:/repo' '
 755         check_prot_path file://c:/repo file c:/repo
 756 '
 757 test_expect_success MINGW 'fetch-pack --diag-url c:repo' '
 758         check_prot_path c:repo file c:repo
 759 '
 760
 761 test_expect_success 'clone shallow since ...' '
 762         test_create_repo shallow-since &&
 763         (
 764         cd shallow-since &&
 765         GIT_COMMITTER_DATE="100000000 +0700" git commit --allow-empty -m one &&
 766         GIT_COMMITTER_DATE="200000000 +0700" git commit --allow-empty -m two &&
 767         GIT_COMMITTER_DATE="300000000 +0700" git commit --allow-empty -m three &&
 768         git clone --shallow-since "300000000 +0700" "file://$(pwd)/." ../shallow11 &&
 769         git -C ../shallow11 log --pretty=tformat:%s HEAD >actual &&
 770         echo three >expected &&
 771         test_cmp expected actual
 772         )
 773 '
 774
 775 test_expect_success 'fetch shallow since ...' '
 776         git -C shallow11 fetch --shallow-since "200000000 +0700" origin &&
 777         git -C shallow11 log --pretty=tformat:%s origin/master >actual &&
 778         cat >expected <<-\EOF &&
 779         three
 780         two
 781         EOF
 782         test_cmp expected actual
 783 '
 784
 785 test_expect_success 'clone shallow since selects no commits' '
 786         test_create_repo shallow-since-the-future &&
 787         (
 788         cd shallow-since-the-future &&
 789         GIT_COMMITTER_DATE="100000000 +0700" git commit --allow-empty -m one &&
 790         GIT_COMMITTER_DATE="200000000 +0700" git commit --allow-empty -m two &&
 791         GIT_COMMITTER_DATE="300000000 +0700" git commit --allow-empty -m three &&
 792         test_must_fail git clone --shallow-since "900000000 +0700" "file://$(pwd)/." ../shallow111
 793         )
 794 '
 795
 796 # A few subtle things about the request in this test:
 797 #
 798 #  - the server must have commit-graphs present and enabled
 799 #
 800 #  - the history is such that our want/have share a common ancestor ("base"
 801 #    here)
 802 #
 803 #  - we send only a single have, which is fewer than a normal client would
 804 #    send. This ensures that we don't parse "base" up front with
 805 #    parse_object(), but rather traverse to it as a parent while deciding if we
 806 #    can stop the "have" negotiation, and call parse_commit(). The former
 807 #    sees the actual object data and so always loads the three oid, whereas the
 808 #    latter will try to load it lazily.
 809 #
 810 #  - we must use protocol v2, because it handles the "have" negotiation before
 811 #    processing the shallow directives
 812 #
 813 test_expect_success 'shallow since with commit graph and already-seen commit' '
 814         test_create_repo shallow-since-graph &&
 815         (
 816         cd shallow-since-graph &&
 817         test_commit base &&
 818         test_commit master &&
 819         git checkout -b other HEAD^ &&
 820         test_commit other &&
 821         git commit-graph write --reachable &&
 822         git config core.commitGraph true &&
 823
 824         GIT_PROTOCOL=version=2 git upload-pack . <<-EOF >/dev/null
 825         0012command=fetch
 826         00010013deepen-since 1
 827         0032want $(git rev-parse other)
 828         0032have $(git rev-parse master)
 829         0000
 830         EOF
 831         )
 832 '
 833
 834 test_expect_success 'shallow clone exclude tag two' '
 835         test_create_repo shallow-exclude &&
 836         (
 837         cd shallow-exclude &&
 838         test_commit one &&
 839         test_commit two &&
 840         test_commit three &&
 841         git clone --shallow-exclude two "file://$(pwd)/." ../shallow12 &&
 842         git -C ../shallow12 log --pretty=tformat:%s HEAD >actual &&
 843         echo three >expected &&
 844         test_cmp expected actual
 845         )
 846 '
 847
 848 test_expect_success 'fetch exclude tag one' '
 849         git -C shallow12 fetch --shallow-exclude one origin &&
 850         git -C shallow12 log --pretty=tformat:%s origin/master >actual &&
 851         test_write_lines three two >expected &&
 852         test_cmp expected actual
 853 '
 854
 855 test_expect_success 'fetching deepen' '
 856         test_create_repo shallow-deepen &&
 857         (
 858         cd shallow-deepen &&
 859         test_commit one &&
 860         test_commit two &&
 861         test_commit three &&
 862         git clone --depth 1 "file://$(pwd)/." deepen &&
 863         test_commit four &&
 864         git -C deepen log --pretty=tformat:%s master >actual &&
 865         echo three >expected &&
 866         test_cmp expected actual &&
 867         git -C deepen fetch --deepen=1 &&
 868         git -C deepen log --pretty=tformat:%s origin/master >actual &&
 869         cat >expected <<-\EOF &&
 870         four
 871         three
 872         two
 873         EOF
 874         test_cmp expected actual
 875         )
 876 '
 877
 878 test_expect_success 'use ref advertisement to prune "have" lines sent' '
 879         rm -rf server client &&
 880         git init server &&
 881         test_commit -C server both_have_1 &&
 882         git -C server tag -d both_have_1 &&
 883         test_commit -C server both_have_2 &&
 884
 885         git clone server client &&
 886         test_commit -C server server_has &&
 887         test_commit -C client client_has &&
 888
 889         # In both protocol v0 and v2, ensure that the parent of both_have_2 is
 890         # not sent as a "have" line. The client should know that the server has
 891         # both_have_2, so it only needs to inform the server that it has
 892         # both_have_2, and the server can infer the rest.
 893
 894         rm -f trace &&
 895         cp -r client clientv0 &&
 896         GIT_TRACE_PACKET="$(pwd)/trace" git -C clientv0 \
 897                 fetch origin server_has both_have_2 &&
 898         grep "have $(git -C client rev-parse client_has)" trace &&
 899         grep "have $(git -C client rev-parse both_have_2)" trace &&
 900         ! grep "have $(git -C client rev-parse both_have_2^)" trace &&
 901
 902         rm -f trace &&
 903         cp -r client clientv2 &&
 904         GIT_TRACE_PACKET="$(pwd)/trace" git -C clientv2 -c protocol.version=2 \
 905                 fetch origin server_has both_have_2 &&
 906         grep "have $(git -C client rev-parse client_has)" trace &&
 907         grep "have $(git -C client rev-parse both_have_2)" trace &&
 908         ! grep "have $(git -C client rev-parse both_have_2^)" trace
 909 '
 910
 911 test_expect_success 'filtering by size' '
 912         rm -rf server client &&
 913         test_create_repo server &&
 914         test_commit -C server one &&
 915         test_config -C server uploadpack.allowfilter 1 &&
 916
 917         test_create_repo client &&
 918         git -C client fetch-pack --filter=blob:limit=0 ../server HEAD &&
 919
 920         # Ensure that object is not inadvertently fetched
 921         commit=$(git -C server rev-parse HEAD) &&
 922         blob=$(git hash-object server/one.t) &&
 923         git -C client rev-list --objects --missing=allow-any "$commit" >oids &&
 924         ! grep "$blob" oids
 925 '
 926
 927 test_expect_success 'filtering by size has no effect if support for it is not advertised' '
 928         rm -rf server client &&
 929         test_create_repo server &&
 930         test_commit -C server one &&
 931
 932         test_create_repo client &&
 933         git -C client fetch-pack --filter=blob:limit=0 ../server HEAD 2> err &&
 934
 935         # Ensure that object is fetched
 936         commit=$(git -C server rev-parse HEAD) &&
 937         blob=$(git hash-object server/one.t) &&
 938         git -C client rev-list --objects --missing=allow-any "$commit" >oids &&
 939         grep "$blob" oids &&
 940
 941         test_i18ngrep "filtering not recognized by server" err
 942 '
 943
 944 fetch_filter_blob_limit_zero () {
 945         SERVER="$1"
 946         URL="$2"
 947
 948         rm -rf "$SERVER" client &&
 949         test_create_repo "$SERVER" &&
 950         test_commit -C "$SERVER" one &&
 951         test_config -C "$SERVER" uploadpack.allowfilter 1 &&
 952
 953         git clone "$URL" client &&
 954         test_config -C client extensions.partialclone origin &&
 955
 956         test_commit -C "$SERVER" two &&
 957
 958         git -C client fetch --filter=blob:limit=0 origin HEAD:somewhere &&
 959
 960         # Ensure that commit is fetched, but blob is not
 961         commit=$(git -C "$SERVER" rev-parse two) &&
 962         blob=$(git hash-object server/two.t) &&
 963         git -C client rev-list --objects --missing=allow-any "$commit" >oids &&
 964         grep "$commit" oids &&
 965         ! grep "$blob" oids
 966 }
 967
 968 test_expect_success 'fetch with --filter=blob:limit=0' '
 969         fetch_filter_blob_limit_zero server server
 970 '
 971
 972 . "$TEST_DIRECTORY"/lib-httpd.sh
 973 start_httpd
 974
 975 test_expect_success 'fetch with --filter=blob:limit=0 and HTTP' '
 976         fetch_filter_blob_limit_zero "$HTTPD_DOCUMENT_ROOT_PATH/server" "$HTTPD_URL/smart/server"
 977 '
 978
 979 # DO NOT add non-httpd-specific tests here, because the last part of this
 980 # test script is only executed when httpd is available and enabled.
 981
 982 test_done