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