do not stream large files to pack when filters are in use
[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 'clone shallow' '
118         git clone --depth 2 "file://$(pwd)/." shallow
119 '
120
121 test_expect_success 'clone shallow object count' '
122         (
123                 cd shallow &&
124                 git count-objects -v
125         ) > count.shallow &&
126         grep "^in-pack: 18" count.shallow
127 '
128
129 test_expect_success 'clone shallow object count (part 2)' '
130         sed -e "/^in-pack:/d" -e "/^packs:/d" -e "/^size-pack:/d" \
131             -e "/: 0$/d" count.shallow > count_output &&
132         ! test -s count_output
133 '
134
135 test_expect_success 'fsck in shallow repo' '
136         (
137                 cd shallow &&
138                 git fsck --full
139         )
140 '
141
142 test_expect_success 'simple fetch in shallow repo' '
143         (
144                 cd shallow &&
145                 git fetch
146         )
147 '
148
149 test_expect_success 'no changes expected' '
150         (
151                 cd shallow &&
152                 git count-objects -v
153         ) > count.shallow.2 &&
154         cmp count.shallow count.shallow.2
155 '
156
157 test_expect_success 'fetch same depth in shallow repo' '
158         (
159                 cd shallow &&
160                 git fetch --depth=2
161         )
162 '
163
164 test_expect_success 'no changes expected' '
165         (
166                 cd shallow &&
167                 git count-objects -v
168         ) > count.shallow.3 &&
169         cmp count.shallow count.shallow.3
170 '
171
172 test_expect_success 'add two more' '
173         add B66 $B65 &&
174         add B67 $B66
175 '
176
177 test_expect_success 'pull in shallow repo' '
178         (
179                 cd shallow &&
180                 git pull .. B
181         )
182 '
183
184 test_expect_success 'clone shallow object count' '
185         (
186                 cd shallow &&
187                 git count-objects -v
188         ) > count.shallow &&
189         grep "^count: 6" count.shallow
190 '
191
192 test_expect_success 'add two more (part 2)' '
193         add B68 $B67 &&
194         add B69 $B68
195 '
196
197 test_expect_success 'deepening pull in shallow repo' '
198         (
199                 cd shallow &&
200                 git pull --depth 4 .. B
201         )
202 '
203
204 test_expect_success 'clone shallow object count' '
205         (
206                 cd shallow &&
207                 git count-objects -v
208         ) > count.shallow &&
209         grep "^count: 12" count.shallow
210 '
211
212 test_expect_success 'deepening fetch in shallow repo' '
213         (
214                 cd shallow &&
215                 git fetch --depth 4 .. A:A
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: 18" count.shallow
225 '
226
227 test_expect_success 'pull in shallow repo with missing merge base' '
228         (
229                 cd shallow &&
230                 test_must_fail git pull --depth 4 .. A
231         )
232 '
233
234 test_expect_success 'additional simple shallow deepenings' '
235         (
236                 cd shallow &&
237                 git fetch --depth=8 &&
238                 git fetch --depth=10 &&
239                 git fetch --depth=11
240         )
241 '
242
243 test_expect_success 'clone shallow object count' '
244         (
245                 cd shallow &&
246                 git count-objects -v
247         ) > count.shallow &&
248         grep "^count: 52" count.shallow
249 '
250
251 test_done