Merge branch 'jk/fsck-doc'
[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 "Fetching submodule submodule" > ../expect.err &&
20                 echo "From $pwd/submodule" >> ../expect.err &&
21                 echo "   $head1..$head2  master     -> origin/master" >> ../expect.err
22         ) &&
23         (
24                 cd deepsubmodule &&
25                 head1=$(git rev-parse --short HEAD) &&
26                 echo new >> deepsubfile &&
27                 test_tick &&
28                 git add deepsubfile &&
29                 git commit -m new deepsubfile &&
30                 head2=$(git rev-parse --short HEAD) &&
31                 echo "Fetching submodule submodule/subdir/deepsubmodule" >> ../expect.err
32                 echo "From $pwd/deepsubmodule" >> ../expect.err &&
33                 echo "   $head1..$head2  master     -> origin/master" >> ../expect.err
34         )
35 }
36
37 test_expect_success setup '
38         mkdir deepsubmodule &&
39         (
40                 cd deepsubmodule &&
41                 git init &&
42                 echo deepsubcontent > deepsubfile &&
43                 git add deepsubfile &&
44                 git commit -m new deepsubfile
45         ) &&
46         mkdir submodule &&
47         (
48                 cd submodule &&
49                 git init &&
50                 echo subcontent > subfile &&
51                 git add subfile &&
52                 git submodule add "$pwd/deepsubmodule" subdir/deepsubmodule &&
53                 git commit -a -m new
54         ) &&
55         git submodule add "$pwd/submodule" submodule &&
56         git commit -am initial &&
57         git clone . downstream &&
58         (
59                 cd downstream &&
60                 git submodule update --init --recursive
61         )
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         test_must_be_empty actual.out &&
71         test_i18ncmp expect.err actual.err
72 '
73
74 test_expect_success "submodule.recurse option triggers recursive fetch" '
75         add_upstream_commit &&
76         (
77                 cd downstream &&
78                 git -c submodule.recurse fetch >../actual.out 2>../actual.err
79         ) &&
80         test_must_be_empty actual.out &&
81         test_i18ncmp expect.err actual.err
82 '
83
84 test_expect_success "fetch --recurse-submodules -j2 has the same output behaviour" '
85         add_upstream_commit &&
86         (
87                 cd downstream &&
88                 GIT_TRACE="$TRASH_DIRECTORY/trace.out" git fetch --recurse-submodules -j2 2>../actual.err
89         ) &&
90         test_must_be_empty actual.out &&
91         test_i18ncmp expect.err actual.err &&
92         grep "2 tasks" trace.out
93 '
94
95 test_expect_success "fetch alone only fetches superproject" '
96         add_upstream_commit &&
97         (
98                 cd downstream &&
99                 git fetch >../actual.out 2>../actual.err
100         ) &&
101         test_must_be_empty actual.out &&
102         test_must_be_empty actual.err
103 '
104
105 test_expect_success "fetch --no-recurse-submodules only fetches superproject" '
106         (
107                 cd downstream &&
108                 git fetch --no-recurse-submodules >../actual.out 2>../actual.err
109         ) &&
110         test_must_be_empty actual.out &&
111         test_must_be_empty actual.err
112 '
113
114 test_expect_success "using fetchRecurseSubmodules=true in .gitmodules recurses into submodules" '
115         (
116                 cd downstream &&
117                 git config -f .gitmodules submodule.submodule.fetchRecurseSubmodules true &&
118                 git fetch >../actual.out 2>../actual.err
119         ) &&
120         test_must_be_empty actual.out &&
121         test_i18ncmp expect.err actual.err
122 '
123
124 test_expect_success "--no-recurse-submodules overrides .gitmodules config" '
125         add_upstream_commit &&
126         (
127                 cd downstream &&
128                 git fetch --no-recurse-submodules >../actual.out 2>../actual.err
129         ) &&
130         test_must_be_empty actual.out &&
131         test_must_be_empty actual.err
132 '
133
134 test_expect_success "using fetchRecurseSubmodules=false in .git/config overrides setting in .gitmodules" '
135         (
136                 cd downstream &&
137                 git config submodule.submodule.fetchRecurseSubmodules false &&
138                 git fetch >../actual.out 2>../actual.err
139         ) &&
140         test_must_be_empty actual.out &&
141         test_must_be_empty actual.err
142 '
143
144 test_expect_success "--recurse-submodules overrides fetchRecurseSubmodules setting from .git/config" '
145         (
146                 cd downstream &&
147                 git fetch --recurse-submodules >../actual.out 2>../actual.err &&
148                 git config --unset -f .gitmodules submodule.submodule.fetchRecurseSubmodules &&
149                 git config --unset submodule.submodule.fetchRecurseSubmodules
150         ) &&
151         test_must_be_empty actual.out &&
152         test_i18ncmp expect.err actual.err
153 '
154
155 test_expect_success "--quiet propagates to submodules" '
156         (
157                 cd downstream &&
158                 git fetch --recurse-submodules --quiet >../actual.out 2>../actual.err
159         ) &&
160         test_must_be_empty actual.out &&
161         test_must_be_empty actual.err
162 '
163
164 test_expect_success "--quiet propagates to parallel submodules" '
165         (
166                 cd downstream &&
167                 git fetch --recurse-submodules -j 2 --quiet  >../actual.out 2>../actual.err
168         ) &&
169         test_must_be_empty actual.out &&
170         test_must_be_empty actual.err
171 '
172
173 test_expect_success "--dry-run propagates to submodules" '
174         add_upstream_commit &&
175         (
176                 cd downstream &&
177                 git fetch --recurse-submodules --dry-run >../actual.out 2>../actual.err
178         ) &&
179         test_must_be_empty actual.out &&
180         test_i18ncmp expect.err actual.err
181 '
182
183 test_expect_success "Without --dry-run propagates to submodules" '
184         (
185                 cd downstream &&
186                 git fetch --recurse-submodules >../actual.out 2>../actual.err
187         ) &&
188         test_must_be_empty actual.out &&
189         test_i18ncmp expect.err actual.err
190 '
191
192 test_expect_success "recurseSubmodules=true propagates into submodules" '
193         add_upstream_commit &&
194         (
195                 cd downstream &&
196                 git config fetch.recurseSubmodules true &&
197                 git fetch >../actual.out 2>../actual.err
198         ) &&
199         test_must_be_empty actual.out &&
200         test_i18ncmp expect.err actual.err
201 '
202
203 test_expect_success "--recurse-submodules overrides config in submodule" '
204         add_upstream_commit &&
205         (
206                 cd downstream &&
207                 (
208                         cd submodule &&
209                         git config fetch.recurseSubmodules false
210                 ) &&
211                 git fetch --recurse-submodules >../actual.out 2>../actual.err
212         ) &&
213         test_must_be_empty actual.out &&
214         test_i18ncmp expect.err actual.err
215 '
216
217 test_expect_success "--no-recurse-submodules overrides config setting" '
218         add_upstream_commit &&
219         (
220                 cd downstream &&
221                 git config fetch.recurseSubmodules true &&
222                 git fetch --no-recurse-submodules >../actual.out 2>../actual.err
223         ) &&
224         test_must_be_empty actual.out &&
225         test_must_be_empty actual.err
226 '
227
228 test_expect_success "Recursion doesn't happen when no new commits are fetched in the superproject" '
229         (
230                 cd downstream &&
231                 (
232                         cd submodule &&
233                         git config --unset fetch.recurseSubmodules
234                 ) &&
235                 git config --unset fetch.recurseSubmodules &&
236                 git fetch >../actual.out 2>../actual.err
237         ) &&
238         test_must_be_empty actual.out &&
239         test_must_be_empty actual.err
240 '
241
242 test_expect_success "Recursion stops when no new submodule commits are fetched" '
243         head1=$(git rev-parse --short HEAD) &&
244         git add submodule &&
245         git commit -m "new submodule" &&
246         head2=$(git rev-parse --short HEAD) &&
247         echo "From $pwd/." > expect.err.sub &&
248         echo "   $head1..$head2  master     -> origin/master" >>expect.err.sub &&
249         head -3 expect.err >> expect.err.sub &&
250         (
251                 cd downstream &&
252                 git fetch >../actual.out 2>../actual.err
253         ) &&
254         test_i18ncmp expect.err.sub actual.err &&
255         test_must_be_empty actual.out
256 '
257
258 test_expect_success "Recursion doesn't happen when new superproject commits don't change any submodules" '
259         add_upstream_commit &&
260         head1=$(git rev-parse --short HEAD) &&
261         echo a > file &&
262         git add file &&
263         git commit -m "new file" &&
264         head2=$(git rev-parse --short HEAD) &&
265         echo "From $pwd/." > expect.err.file &&
266         echo "   $head1..$head2  master     -> origin/master" >> expect.err.file &&
267         (
268                 cd downstream &&
269                 git fetch >../actual.out 2>../actual.err
270         ) &&
271         test_must_be_empty actual.out &&
272         test_i18ncmp expect.err.file actual.err
273 '
274
275 test_expect_success "Recursion picks up config in submodule" '
276         (
277                 cd downstream &&
278                 git fetch --recurse-submodules &&
279                 (
280                         cd submodule &&
281                         git config fetch.recurseSubmodules true
282                 )
283         ) &&
284         add_upstream_commit &&
285         head1=$(git rev-parse --short HEAD) &&
286         git add submodule &&
287         git commit -m "new submodule" &&
288         head2=$(git rev-parse --short HEAD) &&
289         echo "From $pwd/." > expect.err.sub &&
290         echo "   $head1..$head2  master     -> origin/master" >> expect.err.sub &&
291         cat expect.err >> expect.err.sub &&
292         (
293                 cd downstream &&
294                 git fetch >../actual.out 2>../actual.err &&
295                 (
296                         cd submodule &&
297                         git config --unset fetch.recurseSubmodules
298                 )
299         ) &&
300         test_i18ncmp expect.err.sub actual.err &&
301         test_must_be_empty actual.out
302 '
303
304 test_expect_success "Recursion picks up all submodules when necessary" '
305         add_upstream_commit &&
306         (
307                 cd submodule &&
308                 (
309                         cd subdir/deepsubmodule &&
310                         git fetch &&
311                         git checkout -q FETCH_HEAD
312                 ) &&
313                 head1=$(git rev-parse --short HEAD^) &&
314                 git add subdir/deepsubmodule &&
315                 git commit -m "new deepsubmodule" &&
316                 head2=$(git rev-parse --short HEAD) &&
317                 echo "Fetching submodule submodule" > ../expect.err.sub &&
318                 echo "From $pwd/submodule" >> ../expect.err.sub &&
319                 echo "   $head1..$head2  master     -> origin/master" >> ../expect.err.sub
320         ) &&
321         head1=$(git rev-parse --short HEAD) &&
322         git add submodule &&
323         git commit -m "new submodule" &&
324         head2=$(git rev-parse --short HEAD) &&
325         echo "From $pwd/." > expect.err.2 &&
326         echo "   $head1..$head2  master     -> origin/master" >> expect.err.2 &&
327         cat expect.err.sub >> expect.err.2 &&
328         tail -3 expect.err >> expect.err.2 &&
329         (
330                 cd downstream &&
331                 git fetch >../actual.out 2>../actual.err
332         ) &&
333         test_i18ncmp expect.err.2 actual.err &&
334         test_must_be_empty actual.out
335 '
336
337 test_expect_success "'--recurse-submodules=on-demand' doesn't recurse when no new commits are fetched in the superproject (and ignores config)" '
338         add_upstream_commit &&
339         (
340                 cd submodule &&
341                 (
342                         cd subdir/deepsubmodule &&
343                         git fetch &&
344                         git checkout -q FETCH_HEAD
345                 ) &&
346                 head1=$(git rev-parse --short HEAD^) &&
347                 git add subdir/deepsubmodule &&
348                 git commit -m "new deepsubmodule" &&
349                 head2=$(git rev-parse --short HEAD) &&
350                 echo Fetching submodule submodule > ../expect.err.sub &&
351                 echo "From $pwd/submodule" >> ../expect.err.sub &&
352                 echo "   $head1..$head2  master     -> origin/master" >> ../expect.err.sub
353         ) &&
354         (
355                 cd downstream &&
356                 git config fetch.recurseSubmodules true &&
357                 git fetch --recurse-submodules=on-demand >../actual.out 2>../actual.err &&
358                 git config --unset fetch.recurseSubmodules
359         ) &&
360         test_must_be_empty actual.out &&
361         test_must_be_empty actual.err
362 '
363
364 test_expect_success "'--recurse-submodules=on-demand' recurses as deep as necessary (and ignores config)" '
365         head1=$(git rev-parse --short HEAD) &&
366         git add submodule &&
367         git commit -m "new submodule" &&
368         head2=$(git rev-parse --short HEAD) &&
369         tail -3 expect.err > expect.err.deepsub &&
370         echo "From $pwd/." > expect.err &&
371         echo "   $head1..$head2  master     -> origin/master" >>expect.err &&
372         cat expect.err.sub >> expect.err &&
373         cat expect.err.deepsub >> expect.err &&
374         (
375                 cd downstream &&
376                 git config fetch.recurseSubmodules false &&
377                 (
378                         cd submodule &&
379                         git config -f .gitmodules submodule.subdir/deepsubmodule.fetchRecursive false
380                 ) &&
381                 git fetch --recurse-submodules=on-demand >../actual.out 2>../actual.err &&
382                 git config --unset fetch.recurseSubmodules &&
383                 (
384                         cd submodule &&
385                         git config --unset -f .gitmodules submodule.subdir/deepsubmodule.fetchRecursive
386                 )
387         ) &&
388         test_must_be_empty actual.out &&
389         test_i18ncmp expect.err actual.err
390 '
391
392 test_expect_success "'--recurse-submodules=on-demand' stops when no new submodule commits are found in the superproject (and ignores config)" '
393         add_upstream_commit &&
394         head1=$(git rev-parse --short HEAD) &&
395         echo a >> file &&
396         git add file &&
397         git commit -m "new file" &&
398         head2=$(git rev-parse --short HEAD) &&
399         echo "From $pwd/." > expect.err.file &&
400         echo "   $head1..$head2  master     -> origin/master" >> expect.err.file &&
401         (
402                 cd downstream &&
403                 git fetch --recurse-submodules=on-demand >../actual.out 2>../actual.err
404         ) &&
405         test_must_be_empty actual.out &&
406         test_i18ncmp expect.err.file actual.err
407 '
408
409 test_expect_success "'fetch.recurseSubmodules=on-demand' overrides global config" '
410         (
411                 cd downstream &&
412                 git fetch --recurse-submodules
413         ) &&
414         add_upstream_commit &&
415         git config --global fetch.recurseSubmodules false &&
416         head1=$(git rev-parse --short HEAD) &&
417         git add submodule &&
418         git commit -m "new submodule" &&
419         head2=$(git rev-parse --short HEAD) &&
420         echo "From $pwd/." > expect.err.2 &&
421         echo "   $head1..$head2  master     -> origin/master" >>expect.err.2 &&
422         head -3 expect.err >> expect.err.2 &&
423         (
424                 cd downstream &&
425                 git config fetch.recurseSubmodules on-demand &&
426                 git fetch >../actual.out 2>../actual.err
427         ) &&
428         git config --global --unset fetch.recurseSubmodules &&
429         (
430                 cd downstream &&
431                 git config --unset fetch.recurseSubmodules
432         ) &&
433         test_must_be_empty actual.out &&
434         test_i18ncmp expect.err.2 actual.err
435 '
436
437 test_expect_success "'submodule.<sub>.fetchRecurseSubmodules=on-demand' overrides fetch.recurseSubmodules" '
438         (
439                 cd downstream &&
440                 git fetch --recurse-submodules
441         ) &&
442         add_upstream_commit &&
443         git config fetch.recurseSubmodules false &&
444         head1=$(git rev-parse --short HEAD) &&
445         git add submodule &&
446         git commit -m "new submodule" &&
447         head2=$(git rev-parse --short HEAD) &&
448         echo "From $pwd/." > expect.err.2 &&
449         echo "   $head1..$head2  master     -> origin/master" >>expect.err.2 &&
450         head -3 expect.err >> expect.err.2 &&
451         (
452                 cd downstream &&
453                 git config submodule.submodule.fetchRecurseSubmodules on-demand &&
454                 git fetch >../actual.out 2>../actual.err
455         ) &&
456         git config --unset fetch.recurseSubmodules &&
457         (
458                 cd downstream &&
459                 git config --unset submodule.submodule.fetchRecurseSubmodules
460         ) &&
461         test_must_be_empty actual.out &&
462         test_i18ncmp expect.err.2 actual.err
463 '
464
465 test_expect_success "don't fetch submodule when newly recorded commits are already present" '
466         (
467                 cd submodule &&
468                 git checkout -q HEAD^^
469         ) &&
470         head1=$(git rev-parse --short HEAD) &&
471         git add submodule &&
472         git commit -m "submodule rewound" &&
473         head2=$(git rev-parse --short HEAD) &&
474         echo "From $pwd/." > expect.err &&
475         echo "   $head1..$head2  master     -> origin/master" >> expect.err &&
476         (
477                 cd downstream &&
478                 git fetch >../actual.out 2>../actual.err
479         ) &&
480         test_must_be_empty actual.out &&
481         test_i18ncmp expect.err actual.err &&
482         (
483                 cd submodule &&
484                 git checkout -q master
485         )
486 '
487
488 test_expect_success "'fetch.recurseSubmodules=on-demand' works also without .gitmodules entry" '
489         (
490                 cd downstream &&
491                 git fetch --recurse-submodules
492         ) &&
493         add_upstream_commit &&
494         head1=$(git rev-parse --short HEAD) &&
495         git add submodule &&
496         git rm .gitmodules &&
497         git commit -m "new submodule without .gitmodules" &&
498         head2=$(git rev-parse --short HEAD) &&
499         echo "From $pwd/." >expect.err.2 &&
500         echo "   $head1..$head2  master     -> origin/master" >>expect.err.2 &&
501         head -3 expect.err >>expect.err.2 &&
502         (
503                 cd downstream &&
504                 rm .gitmodules &&
505                 git config fetch.recurseSubmodules on-demand &&
506                 # fake submodule configuration to avoid skipping submodule handling
507                 git config -f .gitmodules submodule.fake.path fake &&
508                 git config -f .gitmodules submodule.fake.url fakeurl &&
509                 git add .gitmodules &&
510                 git config --unset submodule.submodule.url &&
511                 git fetch >../actual.out 2>../actual.err &&
512                 # cleanup
513                 git config --unset fetch.recurseSubmodules &&
514                 git reset --hard
515         ) &&
516         test_must_be_empty actual.out &&
517         test_i18ncmp expect.err.2 actual.err &&
518         git checkout HEAD^ -- .gitmodules &&
519         git add .gitmodules &&
520         git commit -m "new submodule restored .gitmodules"
521 '
522
523 test_expect_success 'fetching submodules respects parallel settings' '
524         git config fetch.recurseSubmodules true &&
525         (
526                 cd downstream &&
527                 GIT_TRACE=$(pwd)/trace.out git fetch &&
528                 grep "1 tasks" trace.out &&
529                 GIT_TRACE=$(pwd)/trace.out git fetch --jobs 7 &&
530                 grep "7 tasks" trace.out &&
531                 git config submodule.fetchJobs 8 &&
532                 GIT_TRACE=$(pwd)/trace.out git fetch &&
533                 grep "8 tasks" trace.out &&
534                 GIT_TRACE=$(pwd)/trace.out git fetch --jobs 9 &&
535                 grep "9 tasks" trace.out
536         )
537 '
538
539 test_expect_success 'fetching submodule into a broken repository' '
540         # Prepare src and src/sub nested in it
541         git init src &&
542         (
543                 cd src &&
544                 git init sub &&
545                 git -C sub commit --allow-empty -m "initial in sub" &&
546                 git submodule add -- ./sub sub &&
547                 git commit -m "initial in top"
548         ) &&
549
550         # Clone the old-fashoned way
551         git clone src dst &&
552         git -C dst clone ../src/sub sub &&
553
554         # Make sure that old-fashoned layout is still supported
555         git -C dst status &&
556
557         # "diff" would find no change
558         git -C dst diff --exit-code &&
559
560         # Recursive-fetch works fine
561         git -C dst fetch --recurse-submodules &&
562
563         # Break the receiving submodule
564         rm -f dst/sub/.git/HEAD &&
565
566         # NOTE: without the fix the following tests will recurse forever!
567         # They should terminate with an error.
568
569         test_must_fail git -C dst status &&
570         test_must_fail git -C dst diff &&
571         test_must_fail git -C dst fetch --recurse-submodules
572 '
573
574 test_expect_success "fetch new commits when submodule got renamed" '
575         git clone . downstream_rename &&
576         (
577                 cd downstream_rename &&
578                 git submodule update --init --recursive &&
579                 git checkout -b rename &&
580                 git mv submodule submodule_renamed &&
581                 (
582                         cd submodule_renamed &&
583                         git checkout -b rename_sub &&
584                         echo a >a &&
585                         git add a &&
586                         git commit -ma &&
587                         git push origin rename_sub &&
588                         git rev-parse HEAD >../../expect
589                 ) &&
590                 git add submodule_renamed &&
591                 git commit -m "update renamed submodule" &&
592                 git push origin rename
593         ) &&
594         (
595                 cd downstream &&
596                 git fetch --recurse-submodules=on-demand &&
597                 (
598                         cd submodule &&
599                         git rev-parse origin/rename_sub >../../actual
600                 )
601         ) &&
602         test_cmp expect actual
603 '
604
605 test_expect_success "fetch new submodule commits on-demand outside standard refspec" '
606         # add a second submodule and ensure it is around in downstream first
607         git clone submodule sub1 &&
608         git submodule add ./sub1 &&
609         git commit -m "adding a second submodule" &&
610         git -C downstream pull &&
611         git -C downstream submodule update --init --recursive &&
612
613         git checkout --detach &&
614
615         C=$(git -C submodule commit-tree -m "new change outside refs/heads" HEAD^{tree}) &&
616         git -C submodule update-ref refs/changes/1 $C &&
617         git update-index --cacheinfo 160000 $C submodule &&
618         test_tick &&
619
620         D=$(git -C sub1 commit-tree -m "new change outside refs/heads" HEAD^{tree}) &&
621         git -C sub1 update-ref refs/changes/2 $D &&
622         git update-index --cacheinfo 160000 $D sub1 &&
623
624         git commit -m "updated submodules outside of refs/heads" &&
625         E=$(git rev-parse HEAD) &&
626         git update-ref refs/changes/3 $E &&
627         (
628                 cd downstream &&
629                 git fetch --recurse-submodules origin refs/changes/3:refs/heads/my_branch &&
630                 git -C submodule cat-file -t $C &&
631                 git -C sub1 cat-file -t $D &&
632                 git checkout --recurse-submodules FETCH_HEAD
633         )
634 '
635
636 test_expect_success 'fetch new submodule commit on-demand in FETCH_HEAD' '
637         # depends on the previous test for setup
638
639         C=$(git -C submodule commit-tree -m "another change outside refs/heads" HEAD^{tree}) &&
640         git -C submodule update-ref refs/changes/4 $C &&
641         git update-index --cacheinfo 160000 $C submodule &&
642         test_tick &&
643
644         D=$(git -C sub1 commit-tree -m "another change outside refs/heads" HEAD^{tree}) &&
645         git -C sub1 update-ref refs/changes/5 $D &&
646         git update-index --cacheinfo 160000 $D sub1 &&
647
648         git commit -m "updated submodules outside of refs/heads" &&
649         E=$(git rev-parse HEAD) &&
650         git update-ref refs/changes/6 $E &&
651         (
652                 cd downstream &&
653                 git fetch --recurse-submodules origin refs/changes/6 &&
654                 git -C submodule cat-file -t $C &&
655                 git -C sub1 cat-file -t $D &&
656                 git checkout --recurse-submodules FETCH_HEAD
657         )
658 '
659
660 test_expect_success 'fetch new submodule commits on-demand without .gitmodules entry' '
661         # depends on the previous test for setup
662
663         git config -f .gitmodules --remove-section submodule.sub1 &&
664         git add .gitmodules &&
665         git commit -m "delete gitmodules file" &&
666         git checkout -B master &&
667         git -C downstream fetch &&
668         git -C downstream checkout origin/master &&
669
670         C=$(git -C submodule commit-tree -m "yet another change outside refs/heads" HEAD^{tree}) &&
671         git -C submodule update-ref refs/changes/7 $C &&
672         git update-index --cacheinfo 160000 $C submodule &&
673         test_tick &&
674
675         D=$(git -C sub1 commit-tree -m "yet another change outside refs/heads" HEAD^{tree}) &&
676         git -C sub1 update-ref refs/changes/8 $D &&
677         git update-index --cacheinfo 160000 $D sub1 &&
678
679         git commit -m "updated submodules outside of refs/heads" &&
680         E=$(git rev-parse HEAD) &&
681         git update-ref refs/changes/9 $E &&
682         (
683                 cd downstream &&
684                 git fetch --recurse-submodules origin refs/changes/9 &&
685                 git -C submodule cat-file -t $C &&
686                 git -C sub1 cat-file -t $D &&
687                 git checkout --recurse-submodules FETCH_HEAD
688         )
689 '
690
691 test_expect_success 'fetch new submodule commit intermittently referenced by superproject' '
692         # depends on the previous test for setup
693
694         D=$(git -C sub1 commit-tree -m "change 10 outside refs/heads" HEAD^{tree}) &&
695         E=$(git -C sub1 commit-tree -m "change 11 outside refs/heads" HEAD^{tree}) &&
696         F=$(git -C sub1 commit-tree -m "change 12 outside refs/heads" HEAD^{tree}) &&
697
698         git -C sub1 update-ref refs/changes/10 $D &&
699         git update-index --cacheinfo 160000 $D sub1 &&
700         git commit -m "updated submodules outside of refs/heads" &&
701
702         git -C sub1 update-ref refs/changes/11 $E &&
703         git update-index --cacheinfo 160000 $E sub1 &&
704         git commit -m "updated submodules outside of refs/heads" &&
705
706         git -C sub1 update-ref refs/changes/12 $F &&
707         git update-index --cacheinfo 160000 $F sub1 &&
708         git commit -m "updated submodules outside of refs/heads" &&
709
710         G=$(git rev-parse HEAD) &&
711         git update-ref refs/changes/13 $G &&
712         (
713                 cd downstream &&
714                 git fetch --recurse-submodules origin refs/changes/13 &&
715
716                 git -C sub1 cat-file -t $D &&
717                 git -C sub1 cat-file -t $E &&
718                 git -C sub1 cat-file -t $F
719         )
720 '
721
722 test_done