Sync with 1.7.4.5
[git] / t / t5526-fetch-submodules.sh
1 #!/bin/sh
2 # Copyright (c) 2010, Jens Lehmann
3
4 test_description='Recursive "git fetch" for submodules'
5
6 . ./test-lib.sh
7
8 pwd=$(pwd)
9
10 add_upstream_commit() {
11         (
12                 cd submodule &&
13                 head1=$(git rev-parse --short HEAD) &&
14                 echo new >> subfile &&
15                 test_tick &&
16                 git add subfile &&
17                 git commit -m new subfile &&
18                 head2=$(git rev-parse --short HEAD) &&
19                 echo "From $pwd/submodule" > ../expect.err &&
20                 echo "   $head1..$head2  master     -> origin/master" >> ../expect.err
21         ) &&
22         (
23                 cd deepsubmodule &&
24                 head1=$(git rev-parse --short HEAD) &&
25                 echo new >> deepsubfile &&
26                 test_tick &&
27                 git add deepsubfile &&
28                 git commit -m new deepsubfile &&
29                 head2=$(git rev-parse --short HEAD) &&
30                 echo "From $pwd/deepsubmodule" >> ../expect.err &&
31                 echo "   $head1..$head2  master     -> origin/master" >> ../expect.err
32         )
33 }
34
35 test_expect_success setup '
36         mkdir deepsubmodule &&
37         (
38                 cd deepsubmodule &&
39                 git init &&
40                 echo deepsubcontent > deepsubfile &&
41                 git add deepsubfile &&
42                 git commit -m new deepsubfile
43         ) &&
44         mkdir submodule &&
45         (
46                 cd submodule &&
47                 git init &&
48                 echo subcontent > subfile &&
49                 git add subfile &&
50                 git submodule add "$pwd/deepsubmodule" deepsubmodule &&
51                 git commit -a -m new
52         ) &&
53         git submodule add "$pwd/submodule" submodule &&
54         git commit -am initial &&
55         git clone . downstream &&
56         (
57                 cd downstream &&
58                 git submodule update --init --recursive
59         ) &&
60         echo "Fetching submodule submodule" > expect.out &&
61         echo "Fetching submodule submodule/deepsubmodule" >> expect.out
62 '
63
64 test_expect_success "fetch --recurse-submodules recurses into submodules" '
65         add_upstream_commit &&
66         (
67                 cd downstream &&
68                 git fetch --recurse-submodules >../actual.out 2>../actual.err
69         )
70 '
71
72 test_expect_success C_LOCALE_OUTPUT "fetch --recurse-submodules recurses into submodules: output" '
73         test_cmp expect.out actual.out &&
74         test_cmp expect.err actual.err
75 '
76
77 test_expect_success "fetch alone only fetches superproject" '
78         add_upstream_commit &&
79         (
80                 cd downstream &&
81                 git fetch >../actual.out 2>../actual.err
82         ) &&
83         ! test -s actual.out &&
84         ! test -s actual.err
85 '
86
87 test_expect_success "fetch --no-recurse-submodules only fetches superproject" '
88         (
89                 cd downstream &&
90                 git fetch --no-recurse-submodules >../actual.out 2>../actual.err
91         ) &&
92         ! test -s actual.out &&
93         ! test -s actual.err
94 '
95
96 test_expect_success "using fetchRecurseSubmodules=true in .gitmodules recurses into submodules" '
97         (
98                 cd downstream &&
99                 git config -f .gitmodules submodule.submodule.fetchRecurseSubmodules true &&
100                 git fetch >../actual.out 2>../actual.err
101         )
102 '
103
104 test_expect_success C_LOCALE_OUTPUT "using fetchRecurseSubmodules=true in .gitmodules recurses into submodules" '
105         test_cmp expect.out actual.out &&
106         test_cmp expect.err actual.err
107 '
108
109 test_expect_success "--no-recurse-submodules overrides .gitmodules config" '
110         add_upstream_commit &&
111         (
112                 cd downstream &&
113                 git fetch --no-recurse-submodules >../actual.out 2>../actual.err
114         ) &&
115         ! test -s actual.out &&
116         ! test -s actual.err
117 '
118
119 test_expect_success "using fetchRecurseSubmodules=false in .git/config overrides setting in .gitmodules" '
120         (
121                 cd downstream &&
122                 git config submodule.submodule.fetchRecurseSubmodules false &&
123                 git fetch >../actual.out 2>../actual.err
124         ) &&
125         ! test -s actual.out &&
126         ! test -s actual.err
127 '
128
129 test_expect_success "--recurse-submodules overrides fetchRecurseSubmodules setting from .git/config" '
130         (
131                 cd downstream &&
132                 git fetch --recurse-submodules >../actual.out 2>../actual.err &&
133                 git config --unset -f .gitmodules submodule.submodule.fetchRecurseSubmodules &&
134                 git config --unset submodule.submodule.fetchRecurseSubmodules
135         )
136 '
137
138 test_expect_success C_LOCALE_OUTPUT "--recurse-submodules overrides fetchRecurseSubmodules setting from .git/config: output" '
139         test_cmp expect.out actual.out &&
140         test_cmp expect.err actual.err
141 '
142
143 test_expect_success "--quiet propagates to submodules" '
144         (
145                 cd downstream &&
146                 git fetch --recurse-submodules --quiet >../actual.out 2>../actual.err
147         ) &&
148         ! test -s actual.out &&
149         ! test -s actual.err
150 '
151
152 test_expect_success "--dry-run propagates to submodules" '
153         add_upstream_commit &&
154         (
155                 cd downstream &&
156                 git fetch --recurse-submodules --dry-run >../actual.out 2>../actual.err
157         )
158 '
159
160 test_expect_success C_LOCALE_OUTPUT "--dry-run propagates to submodules: output" '
161         test_cmp expect.out actual.out &&
162         test_cmp expect.err actual.err
163 '
164
165 test_expect_success "Without --dry-run propagates to submodules" '
166         (
167                 cd downstream &&
168                 git fetch --recurse-submodules >../actual.out 2>../actual.err
169         )
170 '
171
172 test_expect_success C_LOCALE_OUTPUT "Without --dry-run propagates to submodules: output" '
173         test_cmp expect.out actual.out &&
174         test_cmp expect.err actual.err
175 '
176
177 test_expect_success "recurseSubmodules=true propagates into submodules" '
178         add_upstream_commit &&
179         (
180                 cd downstream &&
181                 git config fetch.recurseSubmodules true
182                 git fetch >../actual.out 2>../actual.err
183         )
184 '
185
186 test_expect_success C_LOCALE_OUTPUT "recurseSubmodules=true propagates into submodules: output" '
187         test_cmp expect.out actual.out &&
188         test_cmp expect.err actual.err
189 '
190
191 test_expect_success "--recurse-submodules overrides config in submodule" '
192         add_upstream_commit &&
193         (
194                 cd downstream &&
195                 (
196                         cd submodule &&
197                         git config fetch.recurseSubmodules false
198                 ) &&
199                 git fetch --recurse-submodules >../actual.out 2>../actual.err
200         )
201 '
202
203 test_expect_success C_LOCALE_OUTPUT "--recurse-submodules overrides config in submodule: output" '
204         test_cmp expect.out actual.out &&
205         test_cmp expect.err actual.err
206 '
207
208 test_expect_success "--no-recurse-submodules overrides config setting" '
209         add_upstream_commit &&
210         (
211                 cd downstream &&
212                 git config fetch.recurseSubmodules true
213                 git fetch --no-recurse-submodules >../actual.out 2>../actual.err
214         ) &&
215         ! test -s actual.out &&
216         ! test -s actual.err
217 '
218
219 test_expect_success "Recursion doesn't happen when no new commits are fetched in the superproject" '
220         (
221                 cd downstream &&
222                 (
223                         cd submodule &&
224                         git config --unset fetch.recurseSubmodules
225                 ) &&
226                 git config --unset fetch.recurseSubmodules
227                 git fetch >../actual.out 2>../actual.err
228         ) &&
229         ! test -s actual.out &&
230         ! test -s actual.err
231 '
232
233 test_expect_success "Recursion stops when no new submodule commits are fetched" '
234         head1=$(git rev-parse --short HEAD) &&
235         git add submodule &&
236         git commit -m "new submodule" &&
237         head2=$(git rev-parse --short HEAD) &&
238         echo "Fetching submodule submodule" > expect.out.sub &&
239         echo "From $pwd/." > expect.err.sub &&
240         echo "   $head1..$head2  master     -> origin/master" >> expect.err.sub
241         head -2 expect.err >> expect.err.sub &&
242         (
243                 cd downstream &&
244                 git fetch >../actual.out 2>../actual.err
245         ) &&
246         test_cmp expect.err.sub actual.err &&
247         test_cmp expect.out.sub actual.out
248 '
249
250 test_expect_success "Recursion doesn't happen when new superproject commits don't change any submodules" '
251         add_upstream_commit &&
252         head1=$(git rev-parse --short HEAD) &&
253         echo a > file &&
254         git add file &&
255         git commit -m "new file" &&
256         head2=$(git rev-parse --short HEAD) &&
257         echo "From $pwd/." > expect.err.file &&
258         echo "   $head1..$head2  master     -> origin/master" >> expect.err.file &&
259         (
260                 cd downstream &&
261                 git fetch >../actual.out 2>../actual.err
262         ) &&
263         ! test -s actual.out &&
264         test_cmp expect.err.file actual.err
265 '
266
267 test_expect_success "Recursion picks up config in submodule" '
268         (
269                 cd downstream &&
270                 git fetch --recurse-submodules &&
271                 (
272                         cd submodule &&
273                         git config fetch.recurseSubmodules true
274                 )
275         ) &&
276         add_upstream_commit &&
277         head1=$(git rev-parse --short HEAD) &&
278         git add submodule &&
279         git commit -m "new submodule" &&
280         head2=$(git rev-parse --short HEAD) &&
281         echo "From $pwd/." > expect.err.sub &&
282         echo "   $head1..$head2  master     -> origin/master" >> expect.err.sub &&
283         cat expect.err >> expect.err.sub &&
284         (
285                 cd downstream &&
286                 git fetch >../actual.out 2>../actual.err &&
287                 (
288                         cd submodule &&
289                         git config --unset fetch.recurseSubmodules
290                 )
291         ) &&
292         test_cmp expect.err.sub actual.err &&
293         test_cmp expect.out actual.out
294 '
295
296 test_expect_success "Recursion picks up all submodules when necessary" '
297         add_upstream_commit &&
298         (
299                 cd submodule &&
300                 (
301                         cd deepsubmodule &&
302                         git fetch &&
303                         git checkout -q FETCH_HEAD
304                 ) &&
305                 head1=$(git rev-parse --short HEAD^) &&
306                 git add deepsubmodule &&
307                 git commit -m "new deepsubmodule"
308                 head2=$(git rev-parse --short HEAD) &&
309                 echo "From $pwd/submodule" > ../expect.err.sub &&
310                 echo "   $head1..$head2  master     -> origin/master" >> ../expect.err.sub
311         ) &&
312         head1=$(git rev-parse --short HEAD) &&
313         git add submodule &&
314         git commit -m "new submodule" &&
315         head2=$(git rev-parse --short HEAD) &&
316         echo "From $pwd/." > expect.err.2 &&
317         echo "   $head1..$head2  master     -> origin/master" >> expect.err.2 &&
318         cat expect.err.sub >> expect.err.2 &&
319         tail -2 expect.err >> expect.err.2 &&
320         (
321                 cd downstream &&
322                 git fetch >../actual.out 2>../actual.err
323         ) &&
324         test_cmp expect.err.2 actual.err &&
325         test_cmp expect.out actual.out
326 '
327
328 test_expect_success "'--recurse-submodules=on-demand' doesn't recurse when no new commits are fetched in the superproject (and ignores config)" '
329         add_upstream_commit &&
330         (
331                 cd submodule &&
332                 (
333                         cd deepsubmodule &&
334                         git fetch &&
335                         git checkout -q FETCH_HEAD
336                 ) &&
337                 head1=$(git rev-parse --short HEAD^) &&
338                 git add deepsubmodule &&
339                 git commit -m "new deepsubmodule"
340                 head2=$(git rev-parse --short HEAD) &&
341                 echo "From $pwd/submodule" > ../expect.err.sub &&
342                 echo "   $head1..$head2  master     -> origin/master" >> ../expect.err.sub
343         ) &&
344         (
345                 cd downstream &&
346                 git config fetch.recurseSubmodules true &&
347                 git fetch --recurse-submodules=on-demand >../actual.out 2>../actual.err &&
348                 git config --unset fetch.recurseSubmodules
349         ) &&
350         ! test -s actual.out &&
351         ! test -s actual.err
352 '
353
354 test_expect_success "'--recurse-submodules=on-demand' recurses as deep as necessary (and ignores config)" '
355         head1=$(git rev-parse --short HEAD) &&
356         git add submodule &&
357         git commit -m "new submodule" &&
358         head2=$(git rev-parse --short HEAD) &&
359         tail -2 expect.err > expect.err.deepsub &&
360         echo "From $pwd/." > expect.err &&
361         echo "   $head1..$head2  master     -> origin/master" >> expect.err
362         cat expect.err.sub >> expect.err &&
363         cat expect.err.deepsub >> expect.err &&
364         (
365                 cd downstream &&
366                 git config fetch.recurseSubmodules false &&
367                 (
368                         cd submodule &&
369                         git config -f .gitmodules submodule.deepsubmodule.fetchRecursive false
370                 ) &&
371                 git fetch --recurse-submodules=on-demand >../actual.out 2>../actual.err &&
372                 git config --unset fetch.recurseSubmodules
373                 (
374                         cd submodule &&
375                         git config --unset -f .gitmodules submodule.deepsubmodule.fetchRecursive
376                 )
377         ) &&
378         test_cmp expect.out actual.out &&
379         test_cmp expect.err actual.err
380 '
381
382 test_expect_success "'--recurse-submodules=on-demand' stops when no new submodule commits are found in the superproject (and ignores config)" '
383         add_upstream_commit &&
384         head1=$(git rev-parse --short HEAD) &&
385         echo a >> file &&
386         git add file &&
387         git commit -m "new file" &&
388         head2=$(git rev-parse --short HEAD) &&
389         echo "From $pwd/." > expect.err.file &&
390         echo "   $head1..$head2  master     -> origin/master" >> expect.err.file &&
391         (
392                 cd downstream &&
393                 git fetch --recurse-submodules=on-demand >../actual.out 2>../actual.err
394         ) &&
395         ! test -s actual.out &&
396         test_cmp expect.err.file actual.err
397 '
398
399 test_expect_success "'fetch.recurseSubmodules=on-demand' overrides global config" '
400         (
401                 cd downstream &&
402                 git fetch --recurse-submodules
403         ) &&
404         add_upstream_commit &&
405         git config --global fetch.recurseSubmodules false &&
406         head1=$(git rev-parse --short HEAD) &&
407         git add submodule &&
408         git commit -m "new submodule" &&
409         head2=$(git rev-parse --short HEAD) &&
410         echo "From $pwd/." > expect.err.2 &&
411         echo "   $head1..$head2  master     -> origin/master" >> expect.err.2
412         head -2 expect.err >> expect.err.2 &&
413         (
414                 cd downstream &&
415                 git config fetch.recurseSubmodules on-demand &&
416                 git fetch >../actual.out 2>../actual.err
417         ) &&
418         git config --global --unset fetch.recurseSubmodules &&
419         (
420                 cd downstream &&
421                 git config --unset fetch.recurseSubmodules
422         ) &&
423         test_cmp expect.out.sub actual.out &&
424         test_cmp expect.err.2 actual.err
425 '
426
427 test_expect_success "'submodule.<sub>.fetchRecurseSubmodules=on-demand' overrides fetch.recurseSubmodules" '
428         (
429                 cd downstream &&
430                 git fetch --recurse-submodules
431         ) &&
432         add_upstream_commit &&
433         git config fetch.recurseSubmodules false &&
434         head1=$(git rev-parse --short HEAD) &&
435         git add submodule &&
436         git commit -m "new submodule" &&
437         head2=$(git rev-parse --short HEAD) &&
438         echo "From $pwd/." > expect.err.2 &&
439         echo "   $head1..$head2  master     -> origin/master" >> expect.err.2
440         head -2 expect.err >> expect.err.2 &&
441         (
442                 cd downstream &&
443                 git config submodule.submodule.fetchRecurseSubmodules on-demand &&
444                 git fetch >../actual.out 2>../actual.err
445         ) &&
446         git config --unset fetch.recurseSubmodules &&
447         (
448                 cd downstream &&
449                 git config --unset submodule.submodule.fetchRecurseSubmodules
450         ) &&
451         test_cmp expect.out.sub actual.out &&
452         test_cmp expect.err.2 actual.err
453 '
454
455 test_expect_success "don't fetch submodule when newly recorded commits are already present" '
456         (
457                 cd submodule &&
458                 git checkout -q HEAD^^
459         ) &&
460         head1=$(git rev-parse --short HEAD) &&
461         git add submodule &&
462         git commit -m "submodule rewound" &&
463         head2=$(git rev-parse --short HEAD) &&
464         echo "From $pwd/." > expect.err &&
465         echo "   $head1..$head2  master     -> origin/master" >> expect.err &&
466         (
467                 cd downstream &&
468                 git fetch >../actual.out 2>../actual.err
469         ) &&
470         ! test -s actual.out &&
471         test_cmp expect.err actual.err
472 '
473
474 test_done