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 'fetch refs from cmdline' '
 443         (
 444                 cd client &&
 445                 git fetch-pack --no-progress .. $(cat ../input)
 446         ) >output &&
 447         cut -d " " -f 2 <output | sort >actual &&
 448         test_cmp expect actual
 449 '
 450
 451 test_expect_success 'fetch refs from stdin' '
 452         (
 453                 cd client &&
 454                 git fetch-pack --stdin --no-progress .. <../input
 455         ) >output &&
 456         cut -d " " -f 2 <output | sort >actual &&
 457         test_cmp expect actual
 458 '
 459
 460 test_expect_success 'fetch mixed refs from cmdline and stdin' '
 461         (
 462                 cd client &&
 463                 tail -n +5 ../input |
 464                 git fetch-pack --stdin --no-progress .. $(head -n 4 ../input)
 465         ) >output &&
 466         cut -d " " -f 2 <output | sort >actual &&
 467         test_cmp expect actual
 468 '
 469
 470 test_expect_success 'test duplicate refs from stdin' '
 471         (
 472         cd client &&
 473         git fetch-pack --stdin --no-progress .. <../input.dup
 474         ) >output &&
 475         cut -d " " -f 2 <output | sort >actual &&
 476         test_cmp expect actual
 477 '
 478
 479 test_expect_success 'set up tests of missing reference' '
 480         cat >expect-error <<-\EOF
 481         error: no such remote ref refs/heads/xyzzy
 482         EOF
 483 '
 484
 485 test_expect_success 'test lonely missing ref' '
 486         (
 487                 cd client &&
 488                 test_must_fail git fetch-pack --no-progress .. refs/heads/xyzzy 2>../error-m
 489         ) &&
 490         test_i18ncmp expect-error error-m
 491 '
 492
 493 test_expect_success 'test missing ref after existing' '
 494         (
 495                 cd client &&
 496                 test_must_fail git fetch-pack --no-progress .. refs/heads/A refs/heads/xyzzy 2>../error-em
 497         ) &&
 498         test_i18ncmp expect-error error-em
 499 '
 500
 501 test_expect_success 'test missing ref before existing' '
 502         (
 503                 cd client &&
 504                 test_must_fail git fetch-pack --no-progress .. refs/heads/xyzzy refs/heads/A 2>../error-me
 505         ) &&
 506         test_i18ncmp expect-error error-me
 507 '
 508
 509 test_expect_success 'test --all, --depth, and explicit head' '
 510         (
 511                 cd client &&
 512                 git fetch-pack --no-progress --all --depth=1 .. refs/heads/A
 513         ) >out-adh 2>error-adh
 514 '
 515
 516 test_expect_success 'test --all, --depth, and explicit tag' '
 517         git tag OLDTAG refs/heads/B~5 &&
 518         (
 519                 cd client &&
 520                 git fetch-pack --no-progress --all --depth=1 .. refs/tags/OLDTAG
 521         ) >out-adt 2>error-adt
 522 '
 523
 524 test_expect_success 'test --all with tag to non-tip' '
 525         git commit --allow-empty -m non-tip &&
 526         git commit --allow-empty -m tip &&
 527         git tag -m "annotated" non-tip HEAD^ &&
 528         (
 529                 cd client &&
 530                 git fetch-pack --all ..
 531         )
 532 '
 533
 534 test_expect_success 'test --all wrt tag to non-commits' '
 535         # create tag-to-{blob,tree,commit,tag}, making sure all tagged objects
 536         # are reachable only via created tag references.
 537         blob=$(echo "hello blob" | git hash-object -t blob -w --stdin) &&
 538         git tag -a -m "tag -> blob" tag-to-blob $blob &&
 539
 540         tree=$(printf "100644 blob $blob\tfile" | git mktree) &&
 541         git tag -a -m "tag -> tree" tag-to-tree $tree &&
 542
 543         tree2=$(printf "100644 blob $blob\tfile2" | git mktree) &&
 544         commit=$(git commit-tree -m "hello commit" $tree) &&
 545         git tag -a -m "tag -> commit" tag-to-commit $commit &&
 546
 547         blob2=$(echo "hello blob2" | git hash-object -t blob -w --stdin) &&
 548         tag=$(git mktag <<-EOF
 549                 object $blob2
 550                 type blob
 551                 tag tag-to-blob2
 552                 tagger author A U Thor <author@example.com> 0 +0000
 553
 554                 hello tag
 555         EOF
 556         ) &&
 557         git tag -a -m "tag -> tag" tag-to-tag $tag &&
 558
 559         # `fetch-pack --all` should succeed fetching all those objects.
 560         mkdir fetchall &&
 561         (
 562                 cd fetchall &&
 563                 git init &&
 564                 git fetch-pack --all .. &&
 565                 git cat-file blob $blob >/dev/null &&
 566                 git cat-file tree $tree >/dev/null &&
 567                 git cat-file commit $commit >/dev/null &&
 568                 git cat-file tag $tag >/dev/null
 569         )
 570 '
 571
 572 test_expect_success 'shallow fetch with tags does not break the repository' '
 573         mkdir repo1 &&
 574         (
 575                 cd repo1 &&
 576                 git init &&
 577                 test_commit 1 &&
 578                 test_commit 2 &&
 579                 test_commit 3 &&
 580                 mkdir repo2 &&
 581                 cd repo2 &&
 582                 git init &&
 583                 git fetch --depth=2 ../.git master:branch &&
 584                 git fsck
 585         )
 586 '
 587
 588 test_expect_success 'fetch-pack can fetch a raw sha1' '
 589         git init hidden &&
 590         (
 591                 cd hidden &&
 592                 test_commit 1 &&
 593                 test_commit 2 &&
 594                 git update-ref refs/hidden/one HEAD^ &&
 595                 git config transfer.hiderefs refs/hidden &&
 596                 git config uploadpack.allowtipsha1inwant true
 597         ) &&
 598         git fetch-pack hidden $(git -C hidden rev-parse refs/hidden/one)
 599 '
 600
 601 test_expect_success 'fetch-pack can fetch a raw sha1 that is advertised as a ref' '
 602         rm -rf server client &&
 603         git init server &&
 604         test_commit -C server 1 &&
 605
 606         git init client &&
 607         git -C client fetch-pack ../server \
 608                 $(git -C server rev-parse refs/heads/master)
 609 '
 610
 611 test_expect_success 'fetch-pack can fetch a raw sha1 overlapping a named ref' '
 612         rm -rf server client &&
 613         git init server &&
 614         test_commit -C server 1 &&
 615         test_commit -C server 2 &&
 616
 617         git init client &&
 618         git -C client fetch-pack ../server \
 619                 $(git -C server rev-parse refs/tags/1) refs/tags/1
 620 '
 621
 622 test_expect_success 'fetch-pack cannot fetch a raw sha1 that is not advertised as a ref' '
 623         rm -rf server &&
 624
 625         git init server &&
 626         test_commit -C server 5 &&
 627         git -C server tag -d 5 &&
 628         test_commit -C server 6 &&
 629
 630         git init client &&
 631         test_must_fail git -C client fetch-pack ../server \
 632                 $(git -C server rev-parse refs/heads/master^) 2>err &&
 633         test_i18ngrep "Server does not allow request for unadvertised object" err
 634 '
 635
 636 check_prot_path () {
 637         cat >expected <<-EOF &&
 638         Diag: url=$1
 639         Diag: protocol=$2
 640         Diag: path=$3
 641         EOF
 642         git fetch-pack --diag-url "$1" | grep -v hostandport= >actual &&
 643         test_cmp expected actual
 644 }
 645
 646 check_prot_host_port_path () {
 647         case "$2" in
 648                 *ssh*)
 649                 pp=ssh
 650                 uah=userandhost
 651                 ehost=$(echo $3 | tr -d "[]")
 652                 diagport="Diag: port=$4"
 653                 ;;
 654                 *)
 655                 pp=$p
 656                 uah=hostandport
 657                 ehost=$(echo $3$4 | sed -e "s/22$/:22/" -e "s/NONE//")
 658                 diagport=""
 659                 ;;
 660         esac
 661         cat >exp <<-EOF &&
 662         Diag: url=$1
 663         Diag: protocol=$pp
 664         Diag: $uah=$ehost
 665         $diagport
 666         Diag: path=$5
 667         EOF
 668         grep -v "^$" exp >expected
 669         git fetch-pack --diag-url "$1" >actual &&
 670         test_cmp expected actual
 671 }
 672
 673 for r in repo re:po re/po
 674 do
 675         # git or ssh with scheme
 676         for p in "ssh+git" "git+ssh" git ssh
 677         do
 678                 for h in host user@host user@[::1] user@::1
 679                 do
 680                         for c in "" :
 681                         do
 682                                 test_expect_success "fetch-pack --diag-url $p://$h$c/$r" '
 683                                         check_prot_host_port_path $p://$h/$r $p "$h" NONE "/$r"
 684                                 '
 685                                 # "/~" -> "~" conversion
 686                                 test_expect_success "fetch-pack --diag-url $p://$h$c/~$r" '
 687                                         check_prot_host_port_path $p://$h/~$r $p "$h" NONE "~$r"
 688                                 '
 689                         done
 690                 done
 691                 for h in host User@host User@[::1]
 692                 do
 693                         test_expect_success "fetch-pack --diag-url $p://$h:22/$r" '
 694                                 check_prot_host_port_path $p://$h:22/$r $p "$h" 22 "/$r"
 695                         '
 696                 done
 697         done
 698         # file with scheme
 699         for p in file
 700         do
 701                 test_expect_success "fetch-pack --diag-url $p://$h/$r" '
 702                         check_prot_path $p://$h/$r $p "/$r"
 703                 '
 704                 # No "/~" -> "~" conversion for file
 705                 test_expect_success "fetch-pack --diag-url $p://$h/~$r" '
 706                         check_prot_path $p://$h/~$r $p "/~$r"
 707                 '
 708         done
 709         # file without scheme
 710         for h in nohost nohost:12 [::1] [::1]:23 [ [:aa
 711         do
 712                 test_expect_success "fetch-pack --diag-url ./$h:$r" '
 713                         check_prot_path ./$h:$r $p "./$h:$r"
 714                 '
 715                 # No "/~" -> "~" conversion for file
 716                 test_expect_success "fetch-pack --diag-url ./$p:$h/~$r" '
 717                 check_prot_path ./$p:$h/~$r $p "./$p:$h/~$r"
 718                 '
 719         done
 720         #ssh without scheme
 721         p=ssh
 722         for h in host [::1]
 723         do
 724                 test_expect_success "fetch-pack --diag-url $h:$r" '
 725                         check_prot_host_port_path $h:$r $p "$h" NONE "$r"
 726                 '
 727                 # Do "/~" -> "~" conversion
 728                 test_expect_success "fetch-pack --diag-url $h:/~$r" '
 729                         check_prot_host_port_path $h:/~$r $p "$h" NONE "~$r"
 730                 '
 731         done
 732 done
 733
 734 test_expect_success MINGW 'fetch-pack --diag-url file://c:/repo' '
 735         check_prot_path file://c:/repo file c:/repo
 736 '
 737 test_expect_success MINGW 'fetch-pack --diag-url c:repo' '
 738         check_prot_path c:repo file c:repo
 739 '
 740
 741 test_expect_success 'clone shallow since ...' '
 742         test_create_repo shallow-since &&
 743         (
 744         cd shallow-since &&
 745         GIT_COMMITTER_DATE="100000000 +0700" git commit --allow-empty -m one &&
 746         GIT_COMMITTER_DATE="200000000 +0700" git commit --allow-empty -m two &&
 747         GIT_COMMITTER_DATE="300000000 +0700" git commit --allow-empty -m three &&
 748         git clone --shallow-since "300000000 +0700" "file://$(pwd)/." ../shallow11 &&
 749         git -C ../shallow11 log --pretty=tformat:%s HEAD >actual &&
 750         echo three >expected &&
 751         test_cmp expected actual
 752         )
 753 '
 754
 755 test_expect_success 'fetch shallow since ...' '
 756         git -C shallow11 fetch --shallow-since "200000000 +0700" origin &&
 757         git -C shallow11 log --pretty=tformat:%s origin/master >actual &&
 758         cat >expected <<-\EOF &&
 759         three
 760         two
 761         EOF
 762         test_cmp expected actual
 763 '
 764
 765 test_expect_success 'clone shallow since selects no commits' '
 766         test_create_repo shallow-since-the-future &&
 767         (
 768         cd shallow-since-the-future &&
 769         GIT_COMMITTER_DATE="100000000 +0700" git commit --allow-empty -m one &&
 770         GIT_COMMITTER_DATE="200000000 +0700" git commit --allow-empty -m two &&
 771         GIT_COMMITTER_DATE="300000000 +0700" git commit --allow-empty -m three &&
 772         test_must_fail git clone --shallow-since "900000000 +0700" "file://$(pwd)/." ../shallow111
 773         )
 774 '
 775
 776 test_expect_success 'shallow clone exclude tag two' '
 777         test_create_repo shallow-exclude &&
 778         (
 779         cd shallow-exclude &&
 780         test_commit one &&
 781         test_commit two &&
 782         test_commit three &&
 783         git clone --shallow-exclude two "file://$(pwd)/." ../shallow12 &&
 784         git -C ../shallow12 log --pretty=tformat:%s HEAD >actual &&
 785         echo three >expected &&
 786         test_cmp expected actual
 787         )
 788 '
 789
 790 test_expect_success 'fetch exclude tag one' '
 791         git -C shallow12 fetch --shallow-exclude one origin &&
 792         git -C shallow12 log --pretty=tformat:%s origin/master >actual &&
 793         test_write_lines three two >expected &&
 794         test_cmp expected actual
 795 '
 796
 797 test_expect_success 'fetching deepen' '
 798         test_create_repo shallow-deepen &&
 799         (
 800         cd shallow-deepen &&
 801         test_commit one &&
 802         test_commit two &&
 803         test_commit three &&
 804         git clone --depth 1 "file://$(pwd)/." deepen &&
 805         test_commit four &&
 806         git -C deepen log --pretty=tformat:%s master >actual &&
 807         echo three >expected &&
 808         test_cmp expected actual &&
 809         git -C deepen fetch --deepen=1 &&
 810         git -C deepen log --pretty=tformat:%s origin/master >actual &&
 811         cat >expected <<-\EOF &&
 812         four
 813         three
 814         two
 815         EOF
 816         test_cmp expected actual
 817         )
 818 '
 819
 820 test_expect_success 'use ref advertisement to prune "have" lines sent' '
 821         rm -rf server client &&
 822         git init server &&
 823         test_commit -C server both_have_1 &&
 824         git -C server tag -d both_have_1 &&
 825         test_commit -C server both_have_2 &&
 826
 827         git clone server client &&
 828         test_commit -C server server_has &&
 829         test_commit -C client client_has &&
 830
 831         # In both protocol v0 and v2, ensure that the parent of both_have_2 is
 832         # not sent as a "have" line. The client should know that the server has
 833         # both_have_2, so it only needs to inform the server that it has
 834         # both_have_2, and the server can infer the rest.
 835
 836         rm -f trace &&
 837         cp -r client clientv0 &&
 838         GIT_TRACE_PACKET="$(pwd)/trace" git -C clientv0 \
 839                 fetch origin server_has both_have_2 &&
 840         grep "have $(git -C client rev-parse client_has)" trace &&
 841         grep "have $(git -C client rev-parse both_have_2)" trace &&
 842         ! grep "have $(git -C client rev-parse both_have_2^)" trace &&
 843
 844         rm -f trace &&
 845         cp -r client clientv2 &&
 846         GIT_TRACE_PACKET="$(pwd)/trace" git -C clientv2 -c protocol.version=2 \
 847                 fetch origin server_has both_have_2 &&
 848         grep "have $(git -C client rev-parse client_has)" trace &&
 849         grep "have $(git -C client rev-parse both_have_2)" trace &&
 850         ! grep "have $(git -C client rev-parse both_have_2^)" trace
 851 '
 852
 853 test_expect_success 'filtering by size' '
 854         rm -rf server client &&
 855         test_create_repo server &&
 856         test_commit -C server one &&
 857         test_config -C server uploadpack.allowfilter 1 &&
 858
 859         test_create_repo client &&
 860         git -C client fetch-pack --filter=blob:limit=0 ../server HEAD &&
 861
 862         # Ensure that object is not inadvertently fetched
 863         test_must_fail git -C client cat-file -e $(git hash-object server/one.t)
 864 '
 865
 866 test_expect_success 'filtering by size has no effect if support for it is not advertised' '
 867         rm -rf server client &&
 868         test_create_repo server &&
 869         test_commit -C server one &&
 870
 871         test_create_repo client &&
 872         git -C client fetch-pack --filter=blob:limit=0 ../server HEAD 2> err &&
 873
 874         # Ensure that object is fetched
 875         git -C client cat-file -e $(git hash-object server/one.t) &&
 876
 877         test_i18ngrep "filtering not recognized by server" err
 878 '
 879
 880 fetch_filter_blob_limit_zero () {
 881         SERVER="$1"
 882         URL="$2"
 883
 884         rm -rf "$SERVER" client &&
 885         test_create_repo "$SERVER" &&
 886         test_commit -C "$SERVER" one &&
 887         test_config -C "$SERVER" uploadpack.allowfilter 1 &&
 888
 889         git clone "$URL" client &&
 890         test_config -C client extensions.partialclone origin &&
 891
 892         test_commit -C "$SERVER" two &&
 893
 894         git -C client fetch --filter=blob:limit=0 origin HEAD:somewhere &&
 895
 896         # Ensure that commit is fetched, but blob is not
 897         test_config -C client extensions.partialclone "arbitrary string" &&
 898         git -C client cat-file -e $(git -C "$SERVER" rev-parse two) &&
 899         test_must_fail git -C client cat-file -e $(git hash-object "$SERVER/two.t")
 900 }
 901
 902 test_expect_success 'fetch with --filter=blob:limit=0' '
 903         fetch_filter_blob_limit_zero server server
 904 '
 905
 906 . "$TEST_DIRECTORY"/lib-httpd.sh
 907 start_httpd
 908
 909 test_expect_success 'fetch with --filter=blob:limit=0 and HTTP' '
 910         fetch_filter_blob_limit_zero "$HTTPD_DOCUMENT_ROOT_PATH/server" "$HTTPD_URL/smart/server"
 911 '
 912
 913 stop_httpd
 914
 915
 916 test_done