Merge branch 'wk/doc-pre-rebase'
[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         echo $commit > .git/refs/heads/$branch &&
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                                     echo $ATIP > .git/refs/heads/A;;
49                         esac &&
50                         case "$heads" in *B*)
51                             echo $BTIP > .git/refs/heads/B;;
52                         esac &&
53                         git symbolic-ref HEAD refs/heads/`echo $heads \
54                                 | sed -e "s/^\(.\).*$/\1/"` &&
55
56                         git fsck --full &&
57
58                         mv .git/objects/pack/pack-* . &&
59                         p=`ls -1 pack-*.pack` &&
60                         git unpack-objects <$p &&
61                         git fsck --full &&
62
63                         idx=`echo pack-*.idx` &&
64                         pack_count=`git show-index <$idx | wc -l` &&
65                         test $pack_count = $count &&
66                         rm -f pack-*
67                 )
68         '
69 }
70
71 # Here begins the actual testing
72
73 # A1 - ... - A20 - A21
74 #    \
75 #      B1  -   B2 - .. - B70
76
77 # client pulls A20, B1. Then tracks only B. Then pulls A.
78
79 test_expect_success 'setup' '
80         mkdir client &&
81         (
82                 cd client &&
83                 git init &&
84                 git config transfer.unpacklimit 0
85         ) &&
86         add A1 &&
87         prev=1 &&
88         cur=2 &&
89         while [ $cur -le 10 ]; do
90                 add A$cur $(eval echo \$A$prev) &&
91                 prev=$cur &&
92                 cur=$(($cur+1))
93         done &&
94         add B1 $A1 &&
95         echo $ATIP > .git/refs/heads/A &&
96         echo $BTIP > .git/refs/heads/B &&
97         git symbolic-ref HEAD refs/heads/B
98 '
99
100 pull_to_client 1st "refs/heads/B refs/heads/A" $((11*3))
101
102 test_expect_success 'post 1st pull setup' '
103         add A11 $A10 &&
104         prev=1 &&
105         cur=2 &&
106         while [ $cur -le 65 ]; do
107                 add B$cur $(eval echo \$B$prev) &&
108                 prev=$cur &&
109                 cur=$(($cur+1))
110         done
111 '
112
113 pull_to_client 2nd "refs/heads/B" $((64*3))
114
115 pull_to_client 3rd "refs/heads/A" $((1*3))
116
117 test_expect_success 'single branch clone' '
118         git clone --single-branch "file://$(pwd)/." singlebranch
119 '
120
121 test_expect_success 'single branch object count' '
122         GIT_DIR=singlebranch/.git git count-objects -v |
123                 grep "^in-pack:" > count.singlebranch &&
124         echo "in-pack: 198" >expected &&
125         test_cmp expected count.singlebranch
126 '
127
128 test_expect_success 'single given branch clone' '
129         git clone --single-branch --branch A "file://$(pwd)/." branch-a &&
130         test_must_fail git --git-dir=branch-a/.git rev-parse origin/B
131 '
132
133 test_expect_success 'clone shallow depth 1' '
134         git clone --no-single-branch --depth 1 "file://$(pwd)/." shallow0 &&
135         test "`git --git-dir=shallow0/.git rev-list --count HEAD`" = 1
136 '
137
138 test_expect_success 'clone shallow' '
139         git clone --no-single-branch --depth 2 "file://$(pwd)/." shallow
140 '
141
142 test_expect_success 'clone shallow depth count' '
143         test "`git --git-dir=shallow/.git rev-list --count HEAD`" = 2
144 '
145
146 test_expect_success 'clone shallow object count' '
147         (
148                 cd shallow &&
149                 git count-objects -v
150         ) > count.shallow &&
151         grep "^in-pack: 12" count.shallow
152 '
153
154 test_expect_success 'clone shallow object count (part 2)' '
155         sed -e "/^in-pack:/d" -e "/^packs:/d" -e "/^size-pack:/d" \
156             -e "/: 0$/d" count.shallow > count_output &&
157         ! test -s count_output
158 '
159
160 test_expect_success 'fsck in shallow repo' '
161         (
162                 cd shallow &&
163                 git fsck --full
164         )
165 '
166
167 test_expect_success 'simple fetch in shallow repo' '
168         (
169                 cd shallow &&
170                 git fetch
171         )
172 '
173
174 test_expect_success 'no changes expected' '
175         (
176                 cd shallow &&
177                 git count-objects -v
178         ) > count.shallow.2 &&
179         cmp count.shallow count.shallow.2
180 '
181
182 test_expect_success 'fetch same depth in shallow repo' '
183         (
184                 cd shallow &&
185                 git fetch --depth=2
186         )
187 '
188
189 test_expect_success 'no changes expected' '
190         (
191                 cd shallow &&
192                 git count-objects -v
193         ) > count.shallow.3 &&
194         cmp count.shallow count.shallow.3
195 '
196
197 test_expect_success 'add two more' '
198         add B66 $B65 &&
199         add B67 $B66
200 '
201
202 test_expect_success 'pull in shallow repo' '
203         (
204                 cd shallow &&
205                 git pull .. B
206         )
207 '
208
209 test_expect_success 'clone shallow object count' '
210         (
211                 cd shallow &&
212                 git count-objects -v
213         ) > count.shallow &&
214         grep "^count: 6" count.shallow
215 '
216
217 test_expect_success 'add two more (part 2)' '
218         add B68 $B67 &&
219         add B69 $B68
220 '
221
222 test_expect_success 'deepening pull in shallow repo' '
223         (
224                 cd shallow &&
225                 git pull --depth 4 .. B
226         )
227 '
228
229 test_expect_success 'clone shallow object count' '
230         (
231                 cd shallow &&
232                 git count-objects -v
233         ) > count.shallow &&
234         grep "^count: 12" count.shallow
235 '
236
237 test_expect_success 'deepening fetch in shallow repo' '
238         (
239                 cd shallow &&
240                 git fetch --depth 4 .. A:A
241         )
242 '
243
244 test_expect_success 'clone shallow object count' '
245         (
246                 cd shallow &&
247                 git count-objects -v
248         ) > count.shallow &&
249         grep "^count: 18" count.shallow
250 '
251
252 test_expect_success 'pull in shallow repo with missing merge base' '
253         (
254                 cd shallow &&
255                 test_must_fail git pull --depth 4 .. A
256         )
257 '
258
259 test_expect_success 'additional simple shallow deepenings' '
260         (
261                 cd shallow &&
262                 git fetch --depth=8 &&
263                 git fetch --depth=10 &&
264                 git fetch --depth=11
265         )
266 '
267
268 test_expect_success 'clone shallow depth count' '
269         test "`git --git-dir=shallow/.git rev-list --count HEAD`" = 11
270 '
271
272 test_expect_success 'clone shallow object count' '
273         (
274                 cd shallow &&
275                 git count-objects -v
276         ) > count.shallow &&
277         grep "^count: 55" count.shallow
278 '
279
280 test_expect_success 'fetch --no-shallow on full repo' '
281         test_must_fail git fetch --noshallow
282 '
283
284 test_expect_success 'fetch --depth --no-shallow' '
285         (
286                 cd shallow &&
287                 test_must_fail git fetch --depth=1 --noshallow
288         )
289 '
290
291 test_expect_success 'turn shallow to complete repository' '
292         (
293                 cd shallow &&
294                 git fetch --unshallow &&
295                 ! test -f .git/shallow &&
296                 git fsck --full
297         )
298 '
299
300 test_expect_success 'clone shallow without --no-single-branch' '
301         git clone --depth 1 "file://$(pwd)/." shallow2
302 '
303
304 test_expect_success 'clone shallow object count' '
305         (
306                 cd shallow2 &&
307                 git count-objects -v
308         ) > count.shallow2 &&
309         grep "^in-pack: 3" count.shallow2
310 '
311
312 test_expect_success 'clone shallow with --branch' '
313         git clone --depth 1 --branch A "file://$(pwd)/." shallow3
314 '
315
316 test_expect_success 'clone shallow object count' '
317         echo "in-pack: 3" > count3.expected &&
318         GIT_DIR=shallow3/.git git count-objects -v |
319                 grep "^in-pack" > count3.actual &&
320         test_cmp count3.expected count3.actual
321 '
322
323 test_expect_success 'clone shallow with detached HEAD' '
324         git checkout HEAD^ &&
325         git clone --depth 1 "file://$(pwd)/." shallow5 &&
326         git checkout - &&
327         GIT_DIR=shallow5/.git git rev-parse HEAD >actual &&
328         git rev-parse HEAD^ >expected &&
329         test_cmp expected actual
330 '
331
332 test_expect_success 'shallow clone pulling tags' '
333         git tag -a -m A TAGA1 A &&
334         git tag -a -m B TAGB1 B &&
335         git tag TAGA2 A &&
336         git tag TAGB2 B &&
337         git clone --depth 1 "file://$(pwd)/." shallow6 &&
338
339         cat >taglist.expected <<\EOF &&
340 TAGB1
341 TAGB2
342 EOF
343         GIT_DIR=shallow6/.git git tag -l >taglist.actual &&
344         test_cmp taglist.expected taglist.actual &&
345
346         echo "in-pack: 4" > count6.expected &&
347         GIT_DIR=shallow6/.git git count-objects -v |
348                 grep "^in-pack" > count6.actual &&
349         test_cmp count6.expected count6.actual
350 '
351
352 test_expect_success 'shallow cloning single tag' '
353         git clone --depth 1 --branch=TAGB1 "file://$(pwd)/." shallow7 &&
354         cat >taglist.expected <<\EOF &&
355 TAGB1
356 TAGB2
357 EOF
358         GIT_DIR=shallow7/.git git tag -l >taglist.actual &&
359         test_cmp taglist.expected taglist.actual &&
360
361         echo "in-pack: 4" > count7.expected &&
362         GIT_DIR=shallow7/.git git count-objects -v |
363                 grep "^in-pack" > count7.actual &&
364         test_cmp count7.expected count7.actual
365 '
366
367 test_expect_success 'setup tests for the --stdin parameter' '
368         for head in C D E F
369         do
370                 add $head
371         done &&
372         for head in A B C D E F
373         do
374                 git tag $head $head
375         done &&
376         cat >input <<-\EOF
377         refs/heads/C
378         refs/heads/A
379         refs/heads/D
380         refs/tags/C
381         refs/heads/B
382         refs/tags/A
383         refs/heads/E
384         refs/tags/B
385         refs/tags/E
386         refs/tags/D
387         EOF
388         sort <input >expect &&
389         (
390                 echo refs/heads/E &&
391                 echo refs/tags/E &&
392                 cat input
393         ) >input.dup
394 '
395
396 test_expect_success 'fetch refs from cmdline' '
397         (
398                 cd client &&
399                 git fetch-pack --no-progress .. $(cat ../input)
400         ) >output &&
401         cut -d " " -f 2 <output | sort >actual &&
402         test_cmp expect actual
403 '
404
405 test_expect_success 'fetch refs from stdin' '
406         (
407                 cd client &&
408                 git fetch-pack --stdin --no-progress .. <../input
409         ) >output &&
410         cut -d " " -f 2 <output | sort >actual &&
411         test_cmp expect actual
412 '
413
414 test_expect_success 'fetch mixed refs from cmdline and stdin' '
415         (
416                 cd client &&
417                 tail -n +5 ../input |
418                 git fetch-pack --stdin --no-progress .. $(head -n 4 ../input)
419         ) >output &&
420         cut -d " " -f 2 <output | sort >actual &&
421         test_cmp expect actual
422 '
423
424 test_expect_success 'test duplicate refs from stdin' '
425         (
426         cd client &&
427         git fetch-pack --stdin --no-progress .. <../input.dup
428         ) >output &&
429         cut -d " " -f 2 <output | sort >actual &&
430         test_cmp expect actual
431 '
432
433 test_expect_success 'set up tests of missing reference' '
434         cat >expect-error <<-\EOF
435         error: no such remote ref refs/heads/xyzzy
436         EOF
437 '
438
439 test_expect_success 'test lonely missing ref' '
440         (
441                 cd client &&
442                 test_must_fail git fetch-pack --no-progress .. refs/heads/xyzzy
443         ) >/dev/null 2>error-m &&
444         test_cmp expect-error error-m
445 '
446
447 test_expect_success 'test missing ref after existing' '
448         (
449                 cd client &&
450                 test_must_fail git fetch-pack --no-progress .. refs/heads/A refs/heads/xyzzy
451         ) >/dev/null 2>error-em &&
452         test_cmp expect-error error-em
453 '
454
455 test_expect_success 'test missing ref before existing' '
456         (
457                 cd client &&
458                 test_must_fail git fetch-pack --no-progress .. refs/heads/xyzzy refs/heads/A
459         ) >/dev/null 2>error-me &&
460         test_cmp expect-error error-me
461 '
462
463 test_expect_success 'test --all, --depth, and explicit head' '
464         (
465                 cd client &&
466                 git fetch-pack --no-progress --all --depth=1 .. refs/heads/A
467         ) >out-adh 2>error-adh
468 '
469
470 test_expect_success 'test --all, --depth, and explicit tag' '
471         git tag OLDTAG refs/heads/B~5 &&
472         (
473                 cd client &&
474                 git fetch-pack --no-progress --all --depth=1 .. refs/tags/OLDTAG
475         ) >out-adt 2>error-adt
476 '
477
478 test_done