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