]>
Commit | Line | Data |
---|---|---|
6b17c674 JS |
1 | #!/bin/sh |
2 | # | |
3 | # Copyright (c) 2005 Johannes Schindelin | |
4 | # | |
5 | ||
3902985a | 6 | test_description='Testing multi_ack pack fetching' |
6b17c674 | 7 | |
6b17c674 JS |
8 | . ./test-lib.sh |
9 | ||
10 | # Test fetch-pack/upload-pack pair. | |
11 | ||
12 | # Some convenience functions | |
13 | ||
1010437d | 14 | add () { |
3902985a SB |
15 | name=$1 && |
16 | text="$@" && | |
2feed907 | 17 | branch=$(echo $name | sed -e 's/^\(.\).*$/\1/') && |
3902985a | 18 | parents="" && |
6b17c674 | 19 | |
3902985a | 20 | shift && |
6b17c674 | 21 | while test $1; do |
3902985a | 22 | parents="$parents -p $1" && |
6b17c674 | 23 | shift |
3902985a | 24 | done && |
6b17c674 | 25 | |
3902985a SB |
26 | echo "$text" > test.txt && |
27 | git update-index --add test.txt && | |
28 | tree=$(git write-tree) && | |
6b17c674 | 29 | # make sure timestamps are in correct order |
3902985a SB |
30 | test_tick && |
31 | commit=$(echo "$text" | git commit-tree $tree $parents) && | |
32 | eval "$name=$commit; export $name" && | |
cbc5cf7c | 33 | git update-ref "refs/heads/$branch" "$commit" && |
6b17c674 JS |
34 | eval ${branch}TIP=$commit |
35 | } | |
36 | ||
1010437d | 37 | pull_to_client () { |
3902985a SB |
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*) | |
cbc5cf7c | 48 | git update-ref refs/heads/A "$ATIP";; |
3902985a SB |
49 | esac && |
50 | case "$heads" in *B*) | |
cbc5cf7c | 51 | git update-ref refs/heads/B "$BTIP";; |
3902985a | 52 | esac && |
bdbc17e8 MD |
53 | |
54 | git symbolic-ref HEAD refs/heads/$( | |
55 | echo $heads | | |
56 | sed -e "s/^\(.\).*$/\1/" | |
57 | ) && | |
3902985a SB |
58 | |
59 | git fsck --full && | |
60 | ||
61 | mv .git/objects/pack/pack-* . && | |
2feed907 | 62 | p=$(ls -1 pack-*.pack) && |
3902985a SB |
63 | git unpack-objects <$p && |
64 | git fsck --full && | |
65 | ||
2feed907 EP |
66 | idx=$(echo pack-*.idx) && |
67 | pack_count=$(git show-index <$idx | wc -l) && | |
3902985a SB |
68 | test $pack_count = $count && |
69 | rm -f pack-* | |
70 | ) | |
71 | ' | |
6b17c674 JS |
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 | ||
3902985a | 82 | test_expect_success 'setup' ' |
6b17c674 | 83 | mkdir client && |
3902985a SB |
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 && | |
a48fcd83 | 97 | add B1 $A1 && |
cbc5cf7c DT |
98 | git update-ref refs/heads/A "$ATIP" && |
99 | git update-ref refs/heads/B "$BTIP" && | |
3902985a SB |
100 | git symbolic-ref HEAD refs/heads/B |
101 | ' | |
6b17c674 | 102 | |
e9d866e3 | 103 | pull_to_client 1st "refs/heads/B refs/heads/A" $((11*3)) |
6b17c674 | 104 | |
3902985a SB |
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 | ' | |
6b17c674 | 115 | |
e9d866e3 | 116 | pull_to_client 2nd "refs/heads/B" $((64*3)) |
6b17c674 | 117 | |
e9d866e3 | 118 | pull_to_client 3rd "refs/heads/A" $((1*3)) |
16ad3579 | 119 | |
3e6e0edd NTND |
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 | ||
0ec4b165 NTND |
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 | ||
682c7d2f NTND |
136 | test_expect_success 'clone shallow depth 1' ' |
137 | git clone --no-single-branch --depth 1 "file://$(pwd)/." shallow0 && | |
2feed907 | 138 | test "$(git --git-dir=shallow0/.git rev-list --count HEAD)" = 1 |
682c7d2f NTND |
139 | ' |
140 | ||
6035d6aa NTND |
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 && | |
2feed907 | 144 | test "$(git --git-dir=shallow0fsck/.git rev-list --count HEAD)" = 1 && |
6035d6aa NTND |
145 | git config --global --unset fetch.fsckobjects |
146 | ' | |
147 | ||
3902985a | 148 | test_expect_success 'clone shallow' ' |
3e6e0edd | 149 | git clone --no-single-branch --depth 2 "file://$(pwd)/." shallow |
3902985a | 150 | ' |
37818d7d | 151 | |
682c7d2f | 152 | test_expect_success 'clone shallow depth count' ' |
2feed907 | 153 | test "$(git --git-dir=shallow/.git rev-list --count HEAD)" = 2 |
682c7d2f NTND |
154 | ' |
155 | ||
3902985a SB |
156 | test_expect_success 'clone shallow object count' ' |
157 | ( | |
158 | cd shallow && | |
159 | git count-objects -v | |
160 | ) > count.shallow && | |
682c7d2f | 161 | grep "^in-pack: 12" count.shallow |
37818d7d | 162 | ' |
16ad3579 | 163 | |
3902985a SB |
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 && | |
ec10b018 | 167 | test_must_be_empty count_output |
3902985a | 168 | ' |
16ad3579 | 169 | |
3902985a SB |
170 | test_expect_success 'fsck in shallow repo' ' |
171 | ( | |
172 | cd shallow && | |
173 | git fsck --full | |
174 | ) | |
175 | ' | |
16ad3579 | 176 | |
86386829 NP |
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 | ' | |
16ad3579 | 206 | |
3902985a SB |
207 | test_expect_success 'add two more' ' |
208 | add B66 $B65 && | |
209 | add B67 $B66 | |
210 | ' | |
16ad3579 | 211 | |
3902985a SB |
212 | test_expect_success 'pull in shallow repo' ' |
213 | ( | |
214 | cd shallow && | |
215 | git pull .. B | |
216 | ) | |
217 | ' | |
16ad3579 | 218 | |
3902985a SB |
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 | ' | |
16ad3579 | 226 | |
3902985a SB |
227 | test_expect_success 'add two more (part 2)' ' |
228 | add B68 $B67 && | |
229 | add B69 $B68 | |
230 | ' | |
16ad3579 | 231 | |
3902985a SB |
232 | test_expect_success 'deepening pull in shallow repo' ' |
233 | ( | |
234 | cd shallow && | |
235 | git pull --depth 4 .. B | |
236 | ) | |
237 | ' | |
16ad3579 | 238 | |
3902985a SB |
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 | ' | |
16ad3579 | 246 | |
3902985a SB |
247 | test_expect_success 'deepening fetch in shallow repo' ' |
248 | ( | |
249 | cd shallow && | |
250 | git fetch --depth 4 .. A:A | |
251 | ) | |
252 | ' | |
16ad3579 | 253 | |
3902985a SB |
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 | ' | |
16ad3579 | 261 | |
3902985a SB |
262 | test_expect_success 'pull in shallow repo with missing merge base' ' |
263 | ( | |
264 | cd shallow && | |
51b85471 | 265 | git fetch --depth 4 .. A && |
e379fdf3 | 266 | test_must_fail git merge --allow-unrelated-histories FETCH_HEAD |
3902985a SB |
267 | ) |
268 | ' | |
16ad3579 | 269 | |
86386829 NP |
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 | ||
682c7d2f | 279 | test_expect_success 'clone shallow depth count' ' |
2feed907 | 280 | test "$(git --git-dir=shallow/.git rev-list --count HEAD)" = 11 |
682c7d2f NTND |
281 | ' |
282 | ||
86386829 NP |
283 | test_expect_success 'clone shallow object count' ' |
284 | ( | |
285 | cd shallow && | |
e379fdf3 | 286 | git prune && |
86386829 NP |
287 | git count-objects -v |
288 | ) > count.shallow && | |
e379fdf3 | 289 | grep "^count: 54" count.shallow |
86386829 NP |
290 | ' |
291 | ||
4dcb167f NTND |
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 | ||
3e6e0edd NTND |
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 && | |
682c7d2f | 321 | grep "^in-pack: 3" count.shallow2 |
3e6e0edd NTND |
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' ' | |
682c7d2f | 329 | echo "in-pack: 3" > count3.expected && |
3e6e0edd NTND |
330 | GIT_DIR=shallow3/.git git count-objects -v | |
331 | grep "^in-pack" > count3.actual && | |
332 | test_cmp count3.expected count3.actual | |
333 | ' | |
334 | ||
3e6e0edd NTND |
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 | ||
682c7d2f | 358 | echo "in-pack: 4" > count6.expected && |
3e6e0edd NTND |
359 | GIT_DIR=shallow6/.git git count-objects -v | |
360 | grep "^in-pack" > count6.actual && | |
361 | test_cmp count6.expected count6.actual | |
362 | ' | |
363 | ||
5a7d5b68 NTND |
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 | ||
682c7d2f | 373 | echo "in-pack: 4" > count7.expected && |
5a7d5b68 NTND |
374 | GIT_DIR=shallow7/.git git count-objects -v | |
375 | grep "^in-pack" > count7.actual && | |
376 | test_cmp count7.expected count7.actual | |
377 | ' | |
378 | ||
06f15bf1 JK |
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 | ||
71d5f938 MH |
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 | ' | |
f21d2a78 MK |
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 | |
f616db6a | 409 | test_i18ngrep "remote: Total 1" actual |
f21d2a78 MK |
410 | ) |
411 | ' | |
71d5f938 | 412 | |
b2a9f4da IT |
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 && | |
99094a7a | 422 | cat >input <<-\EOF && |
b2a9f4da IT |
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 && | |
4c58f13b | 473 | git fetch-pack --stdin --no-progress .. <../input.dup |
b2a9f4da IT |
474 | ) >output && |
475 | cut -d " " -f 2 <output | sort >actual && | |
476 | test_cmp expect actual | |
477 | ' | |
478 | ||
3b082004 MH |
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 | ||
778e7543 | 485 | test_expect_success 'test lonely missing ref' ' |
3b082004 MH |
486 | ( |
487 | cd client && | |
fa06eb6f SG |
488 | test_must_fail git fetch-pack --no-progress .. refs/heads/xyzzy 2>../error-m |
489 | ) && | |
e860d96b | 490 | test_i18ncmp expect-error error-m |
3b082004 MH |
491 | ' |
492 | ||
493 | test_expect_success 'test missing ref after existing' ' | |
494 | ( | |
495 | cd client && | |
fa06eb6f SG |
496 | test_must_fail git fetch-pack --no-progress .. refs/heads/A refs/heads/xyzzy 2>../error-em |
497 | ) && | |
e860d96b | 498 | test_i18ncmp expect-error error-em |
3b082004 MH |
499 | ' |
500 | ||
501 | test_expect_success 'test missing ref before existing' ' | |
502 | ( | |
503 | cd client && | |
fa06eb6f SG |
504 | test_must_fail git fetch-pack --no-progress .. refs/heads/xyzzy refs/heads/A 2>../error-me |
505 | ) && | |
e860d96b | 506 | test_i18ncmp expect-error error-me |
3b082004 MH |
507 | ' |
508 | ||
5f0fc645 | 509 | test_expect_success 'test --all, --depth, and explicit head' ' |
8db43d29 MH |
510 | ( |
511 | cd client && | |
512 | git fetch-pack --no-progress --all --depth=1 .. refs/heads/A | |
513 | ) >out-adh 2>error-adh | |
514 | ' | |
515 | ||
5f0fc645 | 516 | test_expect_success 'test --all, --depth, and explicit tag' ' |
8db43d29 MH |
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 | ||
e9502c0a JK |
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 | ||
c12c9df5 KS |
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 && | |
5e834a4f | 539 | |
c12c9df5 KS |
540 | tree=$(printf "100644 blob $blob\tfile" | git mktree) && |
541 | git tag -a -m "tag -> tree" tag-to-tree $tree && | |
5e834a4f | 542 | |
c12c9df5 KS |
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 && | |
5e834a4f | 546 | |
c12c9df5 | 547 | blob2=$(echo "hello blob2" | git hash-object -t blob -w --stdin) && |
5e834a4f JK |
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 | ) && | |
c12c9df5 | 557 | git tag -a -m "tag -> tag" tag-to-tag $tag && |
5e834a4f | 558 | |
c12c9df5 KS |
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 | ||
6da8bdcb NTND |
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 | ' | |
4a8d202c GSF |
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 | ||
fdb69d33 JT |
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 | ||
854aeb7b TB |
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 | ||
3f55ccab | 646 | check_prot_host_port_path () { |
3f55ccab TB |
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 && | |
854aeb7b | 662 | Diag: url=$1 |
3f55ccab TB |
663 | Diag: protocol=$pp |
664 | Diag: $uah=$ehost | |
665 | $diagport | |
666 | Diag: path=$5 | |
854aeb7b | 667 | EOF |
3f55ccab | 668 | grep -v "^$" exp >expected |
854aeb7b TB |
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 | |
3f55ccab | 678 | for h in host user@host user@[::1] user@::1 |
854aeb7b | 679 | do |
6b6c5f7a TB |
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 | |
3f55ccab TB |
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" | |
854aeb7b TB |
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 | |
6a599748 TB |
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 | |
6a599748 | 724 | test_expect_success "fetch-pack --diag-url $h:$r" ' |
3f55ccab | 725 | check_prot_host_port_path $h:$r $p "$h" NONE "$r" |
6a599748 TB |
726 | ' |
727 | # Do "/~" -> "~" conversion | |
728 | test_expect_success "fetch-pack --diag-url $h:/~$r" ' | |
3f55ccab | 729 | check_prot_host_port_path $h:/~$r $p "$h" NONE "~$r" |
6a599748 TB |
730 | ' |
731 | done | |
854aeb7b | 732 | done |
6da8bdcb | 733 | |
c59ab2e5 TB |
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 | ||
6d43a0ce NTND |
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 | ||
e34de73c NTND |
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 | ||
cdc37277 NTND |
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 | ||
cccf74e2 NTND |
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 | ||
af1c90d1 JT |
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 | ||
0b6069fe JT |
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 | ||
acb0c572 JH |
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 | ||
6b17c674 | 916 | test_done |