Merge branch 'js/regexec-buf'
[git] / t / t7400-submodule-basic.sh
1 #!/bin/sh
2 #
3 # Copyright (c) 2007 Lars Hjemli
4 #
5
6 test_description='Basic porcelain support for submodules
7
8 This test tries to verify basic sanity of the init, update and status
9 subcommands of git submodule.
10 '
11
12 . ./test-lib.sh
13
14 test_expect_success 'submodule deinit works on empty repository' '
15         git submodule deinit --all
16 '
17
18 test_expect_success 'setup - initial commit' '
19         >t &&
20         git add t &&
21         git commit -m "initial commit" &&
22         git branch initial
23 '
24
25 test_expect_success 'submodule init aborts on missing .gitmodules file' '
26         test_when_finished "git update-index --remove sub" &&
27         git update-index --add --cacheinfo 160000,$(git rev-parse HEAD),sub &&
28         # missing the .gitmodules file here
29         test_must_fail git submodule init 2>actual &&
30         test_i18ngrep "No url found for submodule path" actual
31 '
32
33 test_expect_success 'submodule update aborts on missing .gitmodules file' '
34         test_when_finished "git update-index --remove sub" &&
35         git update-index --add --cacheinfo 160000,$(git rev-parse HEAD),sub &&
36         # missing the .gitmodules file here
37         git submodule update sub 2>actual &&
38         test_i18ngrep "Submodule path .sub. not initialized" actual
39 '
40
41 test_expect_success 'configuration parsing' '
42         test_when_finished "rm -f .gitmodules" &&
43         cat >.gitmodules <<-\EOF &&
44         [submodule "s"]
45                 path
46                 ignore
47         EOF
48         test_must_fail git status
49 '
50
51 test_expect_success 'setup - repository in init subdirectory' '
52         mkdir init &&
53         (
54                 cd init &&
55                 git init &&
56                 echo a >a &&
57                 git add a &&
58                 git commit -m "submodule commit 1" &&
59                 git tag -a -m "rev-1" rev-1
60         )
61 '
62
63 test_expect_success 'setup - commit with gitlink' '
64         echo a >a &&
65         echo z >z &&
66         git add a init z &&
67         git commit -m "super commit 1"
68 '
69
70 test_expect_success 'setup - hide init subdirectory' '
71         mv init .subrepo
72 '
73
74 test_expect_success 'setup - repository to add submodules to' '
75         git init addtest &&
76         git init addtest-ignore
77 '
78
79 # The 'submodule add' tests need some repository to add as a submodule.
80 # The trash directory is a good one as any. We need to canonicalize
81 # the name, though, as some tests compare it to the absolute path git
82 # generates, which will expand symbolic links.
83 submodurl=$(pwd -P)
84
85 listbranches() {
86         git for-each-ref --format='%(refname)' 'refs/heads/*'
87 }
88
89 inspect() {
90         dir=$1 &&
91         dotdot="${2:-..}" &&
92
93         (
94                 cd "$dir" &&
95                 listbranches >"$dotdot/heads" &&
96                 { git symbolic-ref HEAD || :; } >"$dotdot/head" &&
97                 git rev-parse HEAD >"$dotdot/head-sha1" &&
98                 git update-index --refresh &&
99                 git diff-files --exit-code &&
100                 git clean -n -d -x >"$dotdot/untracked"
101         )
102 }
103
104 test_expect_success 'submodule add' '
105         echo "refs/heads/master" >expect &&
106         >empty &&
107
108         (
109                 cd addtest &&
110                 git submodule add -q "$submodurl" submod >actual &&
111                 test_must_be_empty actual &&
112                 echo "gitdir: ../.git/modules/submod" >expect &&
113                 test_cmp expect submod/.git &&
114                 (
115                         cd submod &&
116                         git config core.worktree >actual &&
117                         echo "../../../submod" >expect &&
118                         test_cmp expect actual &&
119                         rm -f actual expect
120                 ) &&
121                 git submodule init
122         ) &&
123
124         rm -f heads head untracked &&
125         inspect addtest/submod ../.. &&
126         test_cmp expect heads &&
127         test_cmp expect head &&
128         test_cmp empty untracked
129 '
130
131 test_expect_success 'submodule add to .gitignored path fails' '
132         (
133                 cd addtest-ignore &&
134                 cat <<-\EOF >expect &&
135                 The following path is ignored by one of your .gitignore files:
136                 submod
137                 Use -f if you really want to add it.
138                 EOF
139                 # Does not use test_commit due to the ignore
140                 echo "*" > .gitignore &&
141                 git add --force .gitignore &&
142                 git commit -m"Ignore everything" &&
143                 ! git submodule add "$submodurl" submod >actual 2>&1 &&
144                 test_i18ncmp expect actual
145         )
146 '
147
148 test_expect_success 'submodule add to .gitignored path with --force' '
149         (
150                 cd addtest-ignore &&
151                 git submodule add --force "$submodurl" submod
152         )
153 '
154
155 test_expect_success 'submodule add --branch' '
156         echo "refs/heads/initial" >expect-head &&
157         cat <<-\EOF >expect-heads &&
158         refs/heads/initial
159         refs/heads/master
160         EOF
161         >empty &&
162
163         (
164                 cd addtest &&
165                 git submodule add -b initial "$submodurl" submod-branch &&
166                 test "initial" = "$(git config -f .gitmodules submodule.submod-branch.branch)" &&
167                 git submodule init
168         ) &&
169
170         rm -f heads head untracked &&
171         inspect addtest/submod-branch ../.. &&
172         test_cmp expect-heads heads &&
173         test_cmp expect-head head &&
174         test_cmp empty untracked
175 '
176
177 test_expect_success 'submodule add with ./ in path' '
178         echo "refs/heads/master" >expect &&
179         >empty &&
180
181         (
182                 cd addtest &&
183                 git submodule add "$submodurl" ././dotsubmod/./frotz/./ &&
184                 git submodule init
185         ) &&
186
187         rm -f heads head untracked &&
188         inspect addtest/dotsubmod/frotz ../../.. &&
189         test_cmp expect heads &&
190         test_cmp expect head &&
191         test_cmp empty untracked
192 '
193
194 test_expect_success 'submodule add with /././ in path' '
195         echo "refs/heads/master" >expect &&
196         >empty &&
197
198         (
199                 cd addtest &&
200                 git submodule add "$submodurl" dotslashdotsubmod/././frotz/./ &&
201                 git submodule init
202         ) &&
203
204         rm -f heads head untracked &&
205         inspect addtest/dotslashdotsubmod/frotz ../../.. &&
206         test_cmp expect heads &&
207         test_cmp expect head &&
208         test_cmp empty untracked
209 '
210
211 test_expect_success 'submodule add with // in path' '
212         echo "refs/heads/master" >expect &&
213         >empty &&
214
215         (
216                 cd addtest &&
217                 git submodule add "$submodurl" slashslashsubmod///frotz// &&
218                 git submodule init
219         ) &&
220
221         rm -f heads head untracked &&
222         inspect addtest/slashslashsubmod/frotz ../../.. &&
223         test_cmp expect heads &&
224         test_cmp expect head &&
225         test_cmp empty untracked
226 '
227
228 test_expect_success 'submodule add with /.. in path' '
229         echo "refs/heads/master" >expect &&
230         >empty &&
231
232         (
233                 cd addtest &&
234                 git submodule add "$submodurl" dotdotsubmod/../realsubmod/frotz/.. &&
235                 git submodule init
236         ) &&
237
238         rm -f heads head untracked &&
239         inspect addtest/realsubmod ../.. &&
240         test_cmp expect heads &&
241         test_cmp expect head &&
242         test_cmp empty untracked
243 '
244
245 test_expect_success 'submodule add with ./, /.. and // in path' '
246         echo "refs/heads/master" >expect &&
247         >empty &&
248
249         (
250                 cd addtest &&
251                 git submodule add "$submodurl" dot/dotslashsubmod/./../..////realsubmod2/a/b/c/d/../../../../frotz//.. &&
252                 git submodule init
253         ) &&
254
255         rm -f heads head untracked &&
256         inspect addtest/realsubmod2 ../.. &&
257         test_cmp expect heads &&
258         test_cmp expect head &&
259         test_cmp empty untracked
260 '
261
262 test_expect_success 'submodule add in subdirectory' '
263         echo "refs/heads/master" >expect &&
264         >empty &&
265
266         mkdir addtest/sub &&
267         (
268                 cd addtest/sub &&
269                 git submodule add "$submodurl" ../realsubmod3 &&
270                 git submodule init
271         ) &&
272
273         rm -f heads head untracked &&
274         inspect addtest/realsubmod3 ../.. &&
275         test_cmp expect heads &&
276         test_cmp expect head &&
277         test_cmp empty untracked
278 '
279
280 test_expect_success 'submodule add in subdirectory with relative path should fail' '
281         (
282                 cd addtest/sub &&
283                 test_must_fail git submodule add ../../ submod3 2>../../output.err
284         ) &&
285         test_i18ngrep toplevel output.err
286 '
287
288 test_expect_success 'setup - add an example entry to .gitmodules' '
289         git config --file=.gitmodules submodule.example.url git://example.com/init.git
290 '
291
292 test_expect_success 'status should fail for unmapped paths' '
293         test_must_fail git submodule status
294 '
295
296 test_expect_success 'setup - map path in .gitmodules' '
297         cat <<\EOF >expect &&
298 [submodule "example"]
299         url = git://example.com/init.git
300         path = init
301 EOF
302
303         git config --file=.gitmodules submodule.example.path init &&
304
305         test_cmp expect .gitmodules
306 '
307
308 test_expect_success 'status should only print one line' '
309         git submodule status >lines &&
310         test_line_count = 1 lines
311 '
312
313 test_expect_success 'setup - fetch commit name from submodule' '
314         rev1=$(cd .subrepo && git rev-parse HEAD) &&
315         printf "rev1: %s\n" "$rev1" &&
316         test -n "$rev1"
317 '
318
319 test_expect_success 'status should initially be "missing"' '
320         git submodule status >lines &&
321         grep "^-$rev1" lines
322 '
323
324 test_expect_success 'init should register submodule url in .git/config' '
325         echo git://example.com/init.git >expect &&
326
327         git submodule init &&
328         git config submodule.example.url >url &&
329         git config submodule.example.url ./.subrepo &&
330
331         test_cmp expect url
332 '
333
334 test_failure_with_unknown_submodule () {
335         test_must_fail git submodule $1 no-such-submodule 2>output.err &&
336         grep "^error: .*no-such-submodule" output.err
337 }
338
339 test_expect_success 'init should fail with unknown submodule' '
340         test_failure_with_unknown_submodule init
341 '
342
343 test_expect_success 'update should fail with unknown submodule' '
344         test_failure_with_unknown_submodule update
345 '
346
347 test_expect_success 'status should fail with unknown submodule' '
348         test_failure_with_unknown_submodule status
349 '
350
351 test_expect_success 'sync should fail with unknown submodule' '
352         test_failure_with_unknown_submodule sync
353 '
354
355 test_expect_success 'update should fail when path is used by a file' '
356         echo hello >expect &&
357
358         echo "hello" >init &&
359         test_must_fail git submodule update &&
360
361         test_cmp expect init
362 '
363
364 test_expect_success 'update should fail when path is used by a nonempty directory' '
365         echo hello >expect &&
366
367         rm -fr init &&
368         mkdir init &&
369         echo "hello" >init/a &&
370
371         test_must_fail git submodule update &&
372
373         test_cmp expect init/a
374 '
375
376 test_expect_success 'update should work when path is an empty dir' '
377         rm -fr init &&
378         rm -f head-sha1 &&
379         echo "$rev1" >expect &&
380
381         mkdir init &&
382         git submodule update -q >update.out &&
383         test_must_be_empty update.out &&
384
385         inspect init &&
386         test_cmp expect head-sha1
387 '
388
389 test_expect_success 'status should be "up-to-date" after update' '
390         git submodule status >list &&
391         grep "^ $rev1" list
392 '
393
394 test_expect_success 'status "up-to-date" from subdirectory' '
395         mkdir -p sub &&
396         (
397                 cd sub &&
398                 git submodule status >../list
399         ) &&
400         grep "^ $rev1" list &&
401         grep "\\.\\./init" list
402 '
403
404 test_expect_success 'status "up-to-date" from subdirectory with path' '
405         mkdir -p sub &&
406         (
407                 cd sub &&
408                 git submodule status ../init >../list
409         ) &&
410         grep "^ $rev1" list &&
411         grep "\\.\\./init" list
412 '
413
414 test_expect_success 'status should be "modified" after submodule commit' '
415         (
416                 cd init &&
417                 echo b >b &&
418                 git add b &&
419                 git commit -m "submodule commit 2"
420         ) &&
421
422         rev2=$(cd init && git rev-parse HEAD) &&
423         test -n "$rev2" &&
424         git submodule status >list &&
425
426         grep "^+$rev2" list
427 '
428
429 test_expect_success 'the --cached sha1 should be rev1' '
430         git submodule --cached status >list &&
431         grep "^+$rev1" list
432 '
433
434 test_expect_success 'git diff should report the SHA1 of the new submodule commit' '
435         git diff >diff &&
436         grep "^+Subproject commit $rev2" diff
437 '
438
439 test_expect_success 'update should checkout rev1' '
440         rm -f head-sha1 &&
441         echo "$rev1" >expect &&
442
443         git submodule update init &&
444         inspect init &&
445
446         test_cmp expect head-sha1
447 '
448
449 test_expect_success 'status should be "up-to-date" after update' '
450         git submodule status >list &&
451         grep "^ $rev1" list
452 '
453
454 test_expect_success 'checkout superproject with subproject already present' '
455         git checkout initial &&
456         git checkout master
457 '
458
459 test_expect_success 'apply submodule diff' '
460         >empty &&
461
462         git branch second &&
463         (
464                 cd init &&
465                 echo s >s &&
466                 git add s &&
467                 git commit -m "change subproject"
468         ) &&
469         git update-index --add init &&
470         git commit -m "change init" &&
471         git format-patch -1 --stdout >P.diff &&
472         git checkout second &&
473         git apply --index P.diff &&
474
475         git diff --cached master >staged &&
476         test_cmp empty staged
477 '
478
479 test_expect_success 'update --init' '
480         mv init init2 &&
481         git config -f .gitmodules submodule.example.url "$(pwd)/init2" &&
482         git config --remove-section submodule.example &&
483         test_must_fail git config submodule.example.url &&
484
485         git submodule update init 2> update.out &&
486         cat update.out &&
487         test_i18ngrep "not initialized" update.out &&
488         test_must_fail git rev-parse --resolve-git-dir init/.git &&
489
490         git submodule update --init init &&
491         git rev-parse --resolve-git-dir init/.git
492 '
493
494 test_expect_success 'update --init from subdirectory' '
495         mv init init2 &&
496         git config -f .gitmodules submodule.example.url "$(pwd)/init2" &&
497         git config --remove-section submodule.example &&
498         test_must_fail git config submodule.example.url &&
499
500         mkdir -p sub &&
501         (
502                 cd sub &&
503                 git submodule update ../init 2>update.out &&
504                 cat update.out &&
505                 test_i18ngrep "not initialized" update.out &&
506                 test_must_fail git rev-parse --resolve-git-dir ../init/.git &&
507
508                 git submodule update --init ../init
509         ) &&
510         git rev-parse --resolve-git-dir init/.git
511 '
512
513 test_expect_success 'do not add files from a submodule' '
514
515         git reset --hard &&
516         test_must_fail git add init/a
517
518 '
519
520 test_expect_success 'gracefully add/reset submodule with a trailing slash' '
521
522         git reset --hard &&
523         git commit -m "commit subproject" init &&
524         (cd init &&
525          echo b > a) &&
526         git add init/ &&
527         git diff --exit-code --cached init &&
528         commit=$(cd init &&
529          git commit -m update a >/dev/null &&
530          git rev-parse HEAD) &&
531         git add init/ &&
532         test_must_fail git diff --exit-code --cached init &&
533         test $commit = $(git ls-files --stage |
534                 sed -n "s/^160000 \([^ ]*\).*/\1/p") &&
535         git reset init/ &&
536         git diff --exit-code --cached init
537
538 '
539
540 test_expect_success 'ls-files gracefully handles trailing slash' '
541
542         test "init" = "$(git ls-files init/)"
543
544 '
545
546 test_expect_success 'moving to a commit without submodule does not leave empty dir' '
547         rm -rf init &&
548         mkdir init &&
549         git reset --hard &&
550         git checkout initial &&
551         test ! -d init &&
552         git checkout second
553 '
554
555 test_expect_success 'submodule <invalid-subcommand> fails' '
556         test_must_fail git submodule no-such-subcommand
557 '
558
559 test_expect_success 'add submodules without specifying an explicit path' '
560         mkdir repo &&
561         (
562                 cd repo &&
563                 git init &&
564                 echo r >r &&
565                 git add r &&
566                 git commit -m "repo commit 1"
567         ) &&
568         git clone --bare repo/ bare.git &&
569         (
570                 cd addtest &&
571                 git submodule add "$submodurl/repo" &&
572                 git config -f .gitmodules submodule.repo.path repo &&
573                 git submodule add "$submodurl/bare.git" &&
574                 git config -f .gitmodules submodule.bare.path bare
575         )
576 '
577
578 test_expect_success 'add should fail when path is used by a file' '
579         (
580                 cd addtest &&
581                 touch file &&
582                 test_must_fail  git submodule add "$submodurl/repo" file
583         )
584 '
585
586 test_expect_success 'add should fail when path is used by an existing directory' '
587         (
588                 cd addtest &&
589                 mkdir empty-dir &&
590                 test_must_fail git submodule add "$submodurl/repo" empty-dir
591         )
592 '
593
594 test_expect_success 'use superproject as upstream when path is relative and no url is set there' '
595         (
596                 cd addtest &&
597                 git submodule add ../repo relative &&
598                 test "$(git config -f .gitmodules submodule.relative.url)" = ../repo &&
599                 git submodule sync relative &&
600                 test "$(git config submodule.relative.url)" = "$submodurl/repo"
601         )
602 '
603
604 test_expect_success 'set up for relative path tests' '
605         mkdir reltest &&
606         (
607                 cd reltest &&
608                 git init &&
609                 mkdir sub &&
610                 (
611                         cd sub &&
612                         git init &&
613                         test_commit foo
614                 ) &&
615                 git add sub &&
616                 git config -f .gitmodules submodule.sub.path sub &&
617                 git config -f .gitmodules submodule.sub.url ../subrepo &&
618                 cp .git/config pristine-.git-config &&
619                 cp .gitmodules pristine-.gitmodules
620         )
621 '
622
623 test_expect_success '../subrepo works with URL - ssh://hostname/repo' '
624         (
625                 cd reltest &&
626                 cp pristine-.git-config .git/config &&
627                 cp pristine-.gitmodules .gitmodules &&
628                 git config remote.origin.url ssh://hostname/repo &&
629                 git submodule init &&
630                 test "$(git config submodule.sub.url)" = ssh://hostname/subrepo
631         )
632 '
633
634 test_expect_success '../subrepo works with port-qualified URL - ssh://hostname:22/repo' '
635         (
636                 cd reltest &&
637                 cp pristine-.git-config .git/config &&
638                 cp pristine-.gitmodules .gitmodules &&
639                 git config remote.origin.url ssh://hostname:22/repo &&
640                 git submodule init &&
641                 test "$(git config submodule.sub.url)" = ssh://hostname:22/subrepo
642         )
643 '
644
645 # About the choice of the path in the next test:
646 # - double-slash side-steps path mangling issues on Windows
647 # - it is still an absolute local path
648 # - there cannot be a server with a blank in its name just in case the
649 #   path is used erroneously to access a //server/share style path
650 test_expect_success '../subrepo path works with local path - //somewhere else/repo' '
651         (
652                 cd reltest &&
653                 cp pristine-.git-config .git/config &&
654                 cp pristine-.gitmodules .gitmodules &&
655                 git config remote.origin.url "//somewhere else/repo" &&
656                 git submodule init &&
657                 test "$(git config submodule.sub.url)" = "//somewhere else/subrepo"
658         )
659 '
660
661 test_expect_success '../subrepo works with file URL - file:///tmp/repo' '
662         (
663                 cd reltest &&
664                 cp pristine-.git-config .git/config &&
665                 cp pristine-.gitmodules .gitmodules &&
666                 git config remote.origin.url file:///tmp/repo &&
667                 git submodule init &&
668                 test "$(git config submodule.sub.url)" = file:///tmp/subrepo
669         )
670 '
671
672 test_expect_success '../subrepo works with helper URL- helper:://hostname/repo' '
673         (
674                 cd reltest &&
675                 cp pristine-.git-config .git/config &&
676                 cp pristine-.gitmodules .gitmodules &&
677                 git config remote.origin.url helper:://hostname/repo &&
678                 git submodule init &&
679                 test "$(git config submodule.sub.url)" = helper:://hostname/subrepo
680         )
681 '
682
683 test_expect_success '../subrepo works with scp-style URL - user@host:repo' '
684         (
685                 cd reltest &&
686                 cp pristine-.git-config .git/config &&
687                 git config remote.origin.url user@host:repo &&
688                 git submodule init &&
689                 test "$(git config submodule.sub.url)" = user@host:subrepo
690         )
691 '
692
693 test_expect_success '../subrepo works with scp-style URL - user@host:path/to/repo' '
694         (
695                 cd reltest &&
696                 cp pristine-.git-config .git/config &&
697                 cp pristine-.gitmodules .gitmodules &&
698                 git config remote.origin.url user@host:path/to/repo &&
699                 git submodule init &&
700                 test "$(git config submodule.sub.url)" = user@host:path/to/subrepo
701         )
702 '
703
704 test_expect_success '../subrepo works with relative local path - foo' '
705         (
706                 cd reltest &&
707                 cp pristine-.git-config .git/config &&
708                 cp pristine-.gitmodules .gitmodules &&
709                 git config remote.origin.url foo &&
710                 # actual: fails with an error
711                 git submodule init &&
712                 test "$(git config submodule.sub.url)" = subrepo
713         )
714 '
715
716 test_expect_success '../subrepo works with relative local path - foo/bar' '
717         (
718                 cd reltest &&
719                 cp pristine-.git-config .git/config &&
720                 cp pristine-.gitmodules .gitmodules &&
721                 git config remote.origin.url foo/bar &&
722                 git submodule init &&
723                 test "$(git config submodule.sub.url)" = foo/subrepo
724         )
725 '
726
727 test_expect_success '../subrepo works with relative local path - ./foo' '
728         (
729                 cd reltest &&
730                 cp pristine-.git-config .git/config &&
731                 cp pristine-.gitmodules .gitmodules &&
732                 git config remote.origin.url ./foo &&
733                 git submodule init &&
734                 test "$(git config submodule.sub.url)" = subrepo
735         )
736 '
737
738 test_expect_success '../subrepo works with relative local path - ./foo/bar' '
739         (
740                 cd reltest &&
741                 cp pristine-.git-config .git/config &&
742                 cp pristine-.gitmodules .gitmodules &&
743                 git config remote.origin.url ./foo/bar &&
744                 git submodule init &&
745                 test "$(git config submodule.sub.url)" = foo/subrepo
746         )
747 '
748
749 test_expect_success '../subrepo works with relative local path - ../foo' '
750         (
751                 cd reltest &&
752                 cp pristine-.git-config .git/config &&
753                 cp pristine-.gitmodules .gitmodules &&
754                 git config remote.origin.url ../foo &&
755                 git submodule init &&
756                 test "$(git config submodule.sub.url)" = ../subrepo
757         )
758 '
759
760 test_expect_success '../subrepo works with relative local path - ../foo/bar' '
761         (
762                 cd reltest &&
763                 cp pristine-.git-config .git/config &&
764                 cp pristine-.gitmodules .gitmodules &&
765                 git config remote.origin.url ../foo/bar &&
766                 git submodule init &&
767                 test "$(git config submodule.sub.url)" = ../foo/subrepo
768         )
769 '
770
771 test_expect_success '../bar/a/b/c works with relative local path - ../foo/bar.git' '
772         (
773                 cd reltest &&
774                 cp pristine-.git-config .git/config &&
775                 cp pristine-.gitmodules .gitmodules &&
776                 mkdir -p a/b/c &&
777                 (cd a/b/c; git init) &&
778                 git config remote.origin.url ../foo/bar.git &&
779                 git submodule add ../bar/a/b/c ./a/b/c &&
780                 git submodule init &&
781                 test "$(git config submodule.a/b/c.url)" = ../foo/bar/a/b/c
782         )
783 '
784
785 test_expect_success 'moving the superproject does not break submodules' '
786         (
787                 cd addtest &&
788                 git submodule status >expect
789         ) &&
790         mv addtest addtest2 &&
791         (
792                 cd addtest2 &&
793                 git submodule status >actual &&
794                 test_cmp expect actual
795         )
796 '
797
798 test_expect_success 'submodule add --name allows to replace a submodule with another at the same path' '
799         (
800                 cd addtest2 &&
801                 (
802                         cd repo &&
803                         echo "$submodurl/repo" >expect &&
804                         git config remote.origin.url >actual &&
805                         test_cmp expect actual &&
806                         echo "gitdir: ../.git/modules/repo" >expect &&
807                         test_cmp expect .git
808                 ) &&
809                 rm -rf repo &&
810                 git rm repo &&
811                 git submodule add -q --name repo_new "$submodurl/bare.git" repo >actual &&
812                 test_must_be_empty actual &&
813                 echo "gitdir: ../.git/modules/submod" >expect &&
814                 test_cmp expect submod/.git &&
815                 (
816                         cd repo &&
817                         echo "$submodurl/bare.git" >expect &&
818                         git config remote.origin.url >actual &&
819                         test_cmp expect actual &&
820                         echo "gitdir: ../.git/modules/repo_new" >expect &&
821                         test_cmp expect .git
822                 ) &&
823                 echo "repo" >expect &&
824                 test_must_fail git config -f .gitmodules submodule.repo.path &&
825                 git config -f .gitmodules submodule.repo_new.path >actual &&
826                 test_cmp expect actual&&
827                 echo "$submodurl/repo" >expect &&
828                 test_must_fail git config -f .gitmodules submodule.repo.url &&
829                 echo "$submodurl/bare.git" >expect &&
830                 git config -f .gitmodules submodule.repo_new.url >actual &&
831                 test_cmp expect actual &&
832                 echo "$submodurl/repo" >expect &&
833                 git config submodule.repo.url >actual &&
834                 test_cmp expect actual &&
835                 echo "$submodurl/bare.git" >expect &&
836                 git config submodule.repo_new.url >actual &&
837                 test_cmp expect actual
838         )
839 '
840
841 test_expect_success 'recursive relative submodules stay relative' '
842         test_when_finished "rm -rf super clone2 subsub sub3" &&
843         mkdir subsub &&
844         (
845                 cd subsub &&
846                 git init &&
847                 >t &&
848                 git add t &&
849                 git commit -m "initial commit"
850         ) &&
851         mkdir sub3 &&
852         (
853                 cd sub3 &&
854                 git init &&
855                 >t &&
856                 git add t &&
857                 git commit -m "initial commit" &&
858                 git submodule add ../subsub dirdir/subsub &&
859                 git commit -m "add submodule subsub"
860         ) &&
861         mkdir super &&
862         (
863                 cd super &&
864                 git init &&
865                 >t &&
866                 git add t &&
867                 git commit -m "initial commit" &&
868                 git submodule add ../sub3 &&
869                 git commit -m "add submodule sub"
870         ) &&
871         git clone super clone2 &&
872         (
873                 cd clone2 &&
874                 git submodule update --init --recursive &&
875                 echo "gitdir: ../.git/modules/sub3" >./sub3/.git_expect &&
876                 echo "gitdir: ../../../.git/modules/sub3/modules/dirdir/subsub" >./sub3/dirdir/subsub/.git_expect
877         ) &&
878         test_cmp clone2/sub3/.git_expect clone2/sub3/.git &&
879         test_cmp clone2/sub3/dirdir/subsub/.git_expect clone2/sub3/dirdir/subsub/.git
880 '
881
882 test_expect_success 'submodule add with an existing name fails unless forced' '
883         (
884                 cd addtest2 &&
885                 rm -rf repo &&
886                 git rm repo &&
887                 test_must_fail git submodule add -q --name repo_new "$submodurl/repo.git" repo &&
888                 test ! -d repo &&
889                 test_must_fail git config -f .gitmodules submodule.repo_new.path &&
890                 test_must_fail git config -f .gitmodules submodule.repo_new.url &&
891                 echo "$submodurl/bare.git" >expect &&
892                 git config submodule.repo_new.url >actual &&
893                 test_cmp expect actual &&
894                 git submodule add -f -q --name repo_new "$submodurl/repo.git" repo &&
895                 test -d repo &&
896                 echo "repo" >expect &&
897                 git config -f .gitmodules submodule.repo_new.path >actual &&
898                 test_cmp expect actual&&
899                 echo "$submodurl/repo.git" >expect &&
900                 git config -f .gitmodules submodule.repo_new.url >actual &&
901                 test_cmp expect actual &&
902                 echo "$submodurl/repo.git" >expect &&
903                 git config submodule.repo_new.url >actual &&
904                 test_cmp expect actual
905         )
906 '
907
908 test_expect_success 'set up a second submodule' '
909         git submodule add ./init2 example2 &&
910         git commit -m "submodule example2 added"
911 '
912
913 test_expect_success 'submodule deinit works on repository without submodules' '
914         test_when_finished "rm -rf newdirectory" &&
915         mkdir newdirectory &&
916         (
917                 cd newdirectory &&
918                 git init &&
919                 >file &&
920                 git add file &&
921                 git commit -m "repo should not be empty" &&
922                 git submodule deinit . &&
923                 git submodule deinit --all
924         )
925 '
926
927 test_expect_success 'submodule deinit should remove the whole submodule section from .git/config' '
928         git config submodule.example.foo bar &&
929         git config submodule.example2.frotz nitfol &&
930         git submodule deinit init &&
931         test -z "$(git config --get-regexp "submodule\.example\.")" &&
932         test -n "$(git config --get-regexp "submodule\.example2\.")" &&
933         test -f example2/.git &&
934         rmdir init
935 '
936
937 test_expect_success 'submodule deinit from subdirectory' '
938         git submodule update --init &&
939         git config submodule.example.foo bar &&
940         mkdir -p sub &&
941         (
942                 cd sub &&
943                 git submodule deinit ../init >../output
944         ) &&
945         test_i18ngrep "\\.\\./init" output &&
946         test -z "$(git config --get-regexp "submodule\.example\.")" &&
947         test -n "$(git config --get-regexp "submodule\.example2\.")" &&
948         test -f example2/.git &&
949         rmdir init
950 '
951
952 test_expect_success 'submodule deinit . deinits all initialized submodules' '
953         git submodule update --init &&
954         git config submodule.example.foo bar &&
955         git config submodule.example2.frotz nitfol &&
956         test_must_fail git submodule deinit &&
957         git submodule deinit . >actual &&
958         test -z "$(git config --get-regexp "submodule\.example\.")" &&
959         test -z "$(git config --get-regexp "submodule\.example2\.")" &&
960         test_i18ngrep "Cleared directory .init" actual &&
961         test_i18ngrep "Cleared directory .example2" actual &&
962         rmdir init example2
963 '
964
965 test_expect_success 'submodule deinit --all deinits all initialized submodules' '
966         git submodule update --init &&
967         git config submodule.example.foo bar &&
968         git config submodule.example2.frotz nitfol &&
969         test_must_fail git submodule deinit &&
970         git submodule deinit --all >actual &&
971         test -z "$(git config --get-regexp "submodule\.example\.")" &&
972         test -z "$(git config --get-regexp "submodule\.example2\.")" &&
973         test_i18ngrep "Cleared directory .init" actual &&
974         test_i18ngrep "Cleared directory .example2" actual &&
975         rmdir init example2
976 '
977
978 test_expect_success 'submodule deinit deinits a submodule when its work tree is missing or empty' '
979         git submodule update --init &&
980         rm -rf init example2/* example2/.git &&
981         git submodule deinit init example2 >actual &&
982         test -z "$(git config --get-regexp "submodule\.example\.")" &&
983         test -z "$(git config --get-regexp "submodule\.example2\.")" &&
984         test_i18ngrep ! "Cleared directory .init" actual &&
985         test_i18ngrep "Cleared directory .example2" actual &&
986         rmdir init
987 '
988
989 test_expect_success 'submodule deinit fails when the submodule contains modifications unless forced' '
990         git submodule update --init &&
991         echo X >>init/s &&
992         test_must_fail git submodule deinit init &&
993         test -n "$(git config --get-regexp "submodule\.example\.")" &&
994         test -f example2/.git &&
995         git submodule deinit -f init >actual &&
996         test -z "$(git config --get-regexp "submodule\.example\.")" &&
997         test_i18ngrep "Cleared directory .init" actual &&
998         rmdir init
999 '
1000
1001 test_expect_success 'submodule deinit fails when the submodule contains untracked files unless forced' '
1002         git submodule update --init &&
1003         echo X >>init/untracked &&
1004         test_must_fail git submodule deinit init &&
1005         test -n "$(git config --get-regexp "submodule\.example\.")" &&
1006         test -f example2/.git &&
1007         git submodule deinit -f init >actual &&
1008         test -z "$(git config --get-regexp "submodule\.example\.")" &&
1009         test_i18ngrep "Cleared directory .init" actual &&
1010         rmdir init
1011 '
1012
1013 test_expect_success 'submodule deinit fails when the submodule HEAD does not match unless forced' '
1014         git submodule update --init &&
1015         (
1016                 cd init &&
1017                 git checkout HEAD^
1018         ) &&
1019         test_must_fail git submodule deinit init &&
1020         test -n "$(git config --get-regexp "submodule\.example\.")" &&
1021         test -f example2/.git &&
1022         git submodule deinit -f init >actual &&
1023         test -z "$(git config --get-regexp "submodule\.example\.")" &&
1024         test_i18ngrep "Cleared directory .init" actual &&
1025         rmdir init
1026 '
1027
1028 test_expect_success 'submodule deinit is silent when used on an uninitialized submodule' '
1029         git submodule update --init &&
1030         git submodule deinit init >actual &&
1031         test_i18ngrep "Submodule .example. (.*) unregistered for path .init" actual &&
1032         test_i18ngrep "Cleared directory .init" actual &&
1033         git submodule deinit init >actual &&
1034         test_i18ngrep ! "Submodule .example. (.*) unregistered for path .init" actual &&
1035         test_i18ngrep "Cleared directory .init" actual &&
1036         git submodule deinit . >actual &&
1037         test_i18ngrep ! "Submodule .example. (.*) unregistered for path .init" actual &&
1038         test_i18ngrep "Submodule .example2. (.*) unregistered for path .example2" actual &&
1039         test_i18ngrep "Cleared directory .init" actual &&
1040         git submodule deinit . >actual &&
1041         test_i18ngrep ! "Submodule .example. (.*) unregistered for path .init" actual &&
1042         test_i18ngrep ! "Submodule .example2. (.*) unregistered for path .example2" actual &&
1043         test_i18ngrep "Cleared directory .init" actual &&
1044         git submodule deinit --all >actual &&
1045         test_i18ngrep ! "Submodule .example. (.*) unregistered for path .init" actual &&
1046         test_i18ngrep ! "Submodule .example2. (.*) unregistered for path .example2" actual &&
1047         test_i18ngrep "Cleared directory .init" actual &&
1048         rmdir init example2
1049 '
1050
1051 test_expect_success 'submodule deinit fails when submodule has a .git directory even when forced' '
1052         git submodule update --init &&
1053         (
1054                 cd init &&
1055                 rm .git &&
1056                 cp -R ../.git/modules/example .git &&
1057                 GIT_WORK_TREE=. git config --unset core.worktree
1058         ) &&
1059         test_must_fail git submodule deinit init &&
1060         test_must_fail git submodule deinit -f init &&
1061         test -d init/.git &&
1062         test -n "$(git config --get-regexp "submodule\.example\.")"
1063 '
1064
1065 test_expect_success 'submodule with UTF-8 name' '
1066         svname=$(printf "\303\245 \303\244\303\266") &&
1067         mkdir "$svname" &&
1068         (
1069                 cd "$svname" &&
1070                 git init &&
1071                 >sub &&
1072                 git add sub &&
1073                 git commit -m "init sub"
1074         ) &&
1075         git submodule add ./"$svname" &&
1076         git submodule >&2 &&
1077         test -n "$(git submodule | grep "$svname")"
1078 '
1079
1080 test_expect_success 'submodule add clone shallow submodule' '
1081         mkdir super &&
1082         pwd=$(pwd) &&
1083         (
1084                 cd super &&
1085                 git init &&
1086                 git submodule add --depth=1 file://"$pwd"/example2 submodule &&
1087                 (
1088                         cd submodule &&
1089                         test 1 = $(git log --oneline | wc -l)
1090                 )
1091         )
1092 '
1093
1094 test_expect_success 'submodule helper list is not confused by common prefixes' '
1095         mkdir -p dir1/b &&
1096         (
1097                 cd dir1/b &&
1098                 git init &&
1099                 echo hi >testfile2 &&
1100                 git add . &&
1101                 git commit -m "test1"
1102         ) &&
1103         mkdir -p dir2/b &&
1104         (
1105                 cd dir2/b &&
1106                 git init &&
1107                 echo hello >testfile1 &&
1108                 git add .  &&
1109                 git commit -m "test2"
1110         ) &&
1111         git submodule add /dir1/b dir1/b &&
1112         git submodule add /dir2/b dir2/b &&
1113         git commit -m "first submodule commit" &&
1114         git submodule--helper list dir1/b |cut -c51- >actual &&
1115         echo "dir1/b" >expect &&
1116         test_cmp expect actual
1117 '
1118
1119
1120 test_done