]>
Commit | Line | Data |
---|---|---|
42639d23 JL |
1 | # Create a submodule layout used for all tests below. |
2 | # | |
3 | # The following use cases are covered: | |
4 | # - New submodule (no_submodule => add_sub1) | |
5 | # - Removed submodule (add_sub1 => remove_sub1) | |
6 | # - Updated submodule (add_sub1 => modify_sub1) | |
7 | # - Submodule updated to invalid commit (add_sub1 => invalid_sub1) | |
8 | # - Submodule updated from invalid commit (invalid_sub1 => valid_sub1) | |
9 | # - Submodule replaced by tracked files in directory (add_sub1 => | |
10 | # replace_sub1_with_directory) | |
11 | # - Directory containing tracked files replaced by submodule | |
12 | # (replace_sub1_with_directory => replace_directory_with_sub1) | |
13 | # - Submodule replaced by tracked file with the same name (add_sub1 => | |
14 | # replace_sub1_with_file) | |
15 | # - Tracked file replaced by submodule (replace_sub1_with_file => | |
16 | # replace_file_with_sub1) | |
17 | # | |
18 | # --O-----O | |
19 | # / ^ replace_directory_with_sub1 | |
20 | # / replace_sub1_with_directory | |
21 | # /----O | |
22 | # / ^ | |
23 | # / modify_sub1 | |
24 | # O------O-------O | |
25 | # ^ ^\ ^ | |
26 | # | | \ remove_sub1 | |
27 | # | | -----O-----O | |
28 | # | | \ ^ replace_file_with_sub1 | |
29 | # | | \ replace_sub1_with_file | |
30 | # | add_sub1 --O-----O | |
31 | # no_submodule ^ valid_sub1 | |
32 | # invalid_sub1 | |
33 | # | |
34 | create_lib_submodule_repo () { | |
35 | git init submodule_update_repo && | |
36 | ( | |
37 | cd submodule_update_repo && | |
38 | echo "expect" >>.gitignore && | |
39 | echo "actual" >>.gitignore && | |
40 | echo "x" >file1 && | |
41 | echo "y" >file2 && | |
42 | git add .gitignore file1 file2 && | |
43 | git commit -m "Base" && | |
44 | git branch "no_submodule" && | |
45 | ||
46 | git checkout -b "add_sub1" && | |
47 | git submodule add ./. sub1 && | |
48 | git config -f .gitmodules submodule.sub1.ignore all && | |
49 | git config submodule.sub1.ignore all && | |
50 | git add .gitmodules && | |
51 | git commit -m "Add sub1" && | |
52 | git checkout -b remove_sub1 && | |
53 | git revert HEAD && | |
54 | ||
55 | git checkout -b "modify_sub1" "add_sub1" && | |
56 | git submodule update && | |
57 | ( | |
58 | cd sub1 && | |
59 | git fetch && | |
60 | git checkout -b "modifications" && | |
61 | echo "z" >file2 && | |
62 | echo "x" >file3 && | |
63 | git add file2 file3 && | |
64 | git commit -m "modified file2 and added file3" && | |
65 | git push origin modifications | |
66 | ) && | |
67 | git add sub1 && | |
68 | git commit -m "Modify sub1" && | |
69 | ||
70 | git checkout -b "replace_sub1_with_directory" "add_sub1" && | |
71 | git submodule update && | |
72 | ( | |
73 | cd sub1 && | |
74 | git checkout modifications | |
75 | ) && | |
76 | git rm --cached sub1 && | |
77 | rm sub1/.git* && | |
78 | git config -f .gitmodules --remove-section "submodule.sub1" && | |
79 | git add .gitmodules sub1/* && | |
80 | git commit -m "Replace sub1 with directory" && | |
81 | git checkout -b replace_directory_with_sub1 && | |
82 | git revert HEAD && | |
83 | ||
84 | git checkout -b "replace_sub1_with_file" "add_sub1" && | |
85 | git rm sub1 && | |
86 | echo "content" >sub1 && | |
87 | git add sub1 && | |
88 | git commit -m "Replace sub1 with file" && | |
89 | git checkout -b replace_file_with_sub1 && | |
90 | git revert HEAD && | |
91 | ||
92 | git checkout -b "invalid_sub1" "add_sub1" && | |
93 | git update-index --cacheinfo 160000 0123456789012345678901234567890123456789 sub1 && | |
94 | git commit -m "Invalid sub1 commit" && | |
95 | git checkout -b valid_sub1 && | |
96 | git revert HEAD && | |
97 | git checkout master | |
98 | ) | |
99 | } | |
100 | ||
101 | # Helper function to replace gitfile with .git directory | |
102 | replace_gitfile_with_git_dir () { | |
103 | ( | |
104 | cd "$1" && | |
105 | git_dir="$(git rev-parse --git-dir)" && | |
106 | rm -f .git && | |
107 | cp -R "$git_dir" .git && | |
108 | GIT_WORK_TREE=. git config --unset core.worktree | |
109 | ) | |
110 | } | |
111 | ||
112 | # Test that the .git directory in the submodule is unchanged (except for the | |
113 | # core.worktree setting, which appears only in $GIT_DIR/modules/$1/config). | |
114 | # Call this function before test_submodule_content as the latter might | |
115 | # write the index file leading to false positive index differences. | |
116 | # | |
117 | # Note that this only supports submodules at the root level of the | |
118 | # superproject, with the default name, i.e. same as its path. | |
119 | test_git_directory_is_unchanged () { | |
120 | ( | |
121 | cd ".git/modules/$1" && | |
122 | # does core.worktree point at the right place? | |
123 | test "$(git config core.worktree)" = "../../../$1" && | |
124 | # remove it temporarily before comparing, as | |
125 | # "$1/.git/config" lacks it... | |
126 | git config --unset core.worktree | |
127 | ) && | |
128 | diff -r ".git/modules/$1" "$1/.git" && | |
129 | ( | |
130 | # ... and then restore. | |
131 | cd ".git/modules/$1" && | |
132 | git config core.worktree "../../../$1" | |
133 | ) | |
134 | } | |
135 | ||
136 | # Helper function to be executed at the start of every test below, it sets up | |
137 | # the submodule repo if it doesn't exist and configures the most problematic | |
138 | # settings for diff.ignoreSubmodules. | |
139 | prolog () { | |
140 | (test -d submodule_update_repo || create_lib_submodule_repo) && | |
141 | test_config_global diff.ignoreSubmodules all && | |
142 | test_config diff.ignoreSubmodules all | |
143 | } | |
144 | ||
145 | # Helper function to bring work tree back into the state given by the | |
146 | # commit. This includes trying to populate sub1 accordingly if it exists and | |
147 | # should be updated to an existing commit. | |
148 | reset_work_tree_to () { | |
149 | rm -rf submodule_update && | |
150 | git clone submodule_update_repo submodule_update && | |
151 | ( | |
152 | cd submodule_update && | |
153 | rm -rf sub1 && | |
154 | git checkout -f "$1" && | |
155 | git status -u -s >actual && | |
156 | test_must_be_empty actual && | |
157 | sha1=$(git rev-parse --revs-only HEAD:sub1) && | |
158 | if test -n "$sha1" && | |
159 | test $(cd "sub1" && git rev-parse --verify "$sha1^{commit}") | |
160 | then | |
161 | git submodule update --init --recursive "sub1" | |
162 | fi | |
163 | ) | |
164 | } | |
165 | ||
166 | # Test that the superproject contains the content according to commit "$1" | |
167 | # (the work tree must match the index for everything but submodules but the | |
168 | # index must exactly match the given commit including any submodule SHA-1s). | |
169 | test_superproject_content () { | |
170 | git diff-index --cached "$1" >actual && | |
171 | test_must_be_empty actual && | |
172 | git diff-files --ignore-submodules >actual && | |
173 | test_must_be_empty actual | |
174 | } | |
175 | ||
176 | # Test that the given submodule at path "$1" contains the content according | |
177 | # to the submodule commit recorded in the superproject's commit "$2" | |
178 | test_submodule_content () { | |
179 | if test $# != 2 | |
180 | then | |
181 | echo "test_submodule_content needs two arguments" | |
182 | return 1 | |
183 | fi && | |
184 | submodule="$1" && | |
185 | commit="$2" && | |
186 | test -d "$submodule"/ && | |
187 | if ! test -f "$submodule"/.git && ! test -d "$submodule"/.git | |
188 | then | |
189 | echo "Submodule $submodule is not populated" | |
190 | return 1 | |
191 | fi && | |
192 | sha1=$(git rev-parse --verify "$commit:$submodule") && | |
193 | if test -z "$sha1" | |
194 | then | |
195 | echo "Couldn't retrieve SHA-1 of $submodule for $commit" | |
196 | return 1 | |
197 | fi && | |
198 | ( | |
199 | cd "$submodule" && | |
200 | git status -u -s >actual && | |
201 | test_must_be_empty actual && | |
202 | git diff "$sha1" >actual && | |
203 | test_must_be_empty actual | |
204 | ) | |
205 | } | |
206 | ||
207 | # Test that the following transitions are correctly handled: | |
208 | # - Updated submodule | |
209 | # - New submodule | |
210 | # - Removed submodule | |
211 | # - Directory containing tracked files replaced by submodule | |
212 | # - Submodule replaced by tracked files in directory | |
213 | # - Submodule replaced by tracked file with the same name | |
214 | # - tracked file replaced by submodule | |
215 | # | |
216 | # The default is that submodule contents aren't changed until "git submodule | |
217 | # update" is run. And even then that command doesn't delete the work tree of | |
218 | # a removed submodule. | |
219 | # | |
220 | # Removing a submodule containing a .git directory must fail even when forced | |
221 | # to protect the history! | |
222 | # | |
223 | ||
224 | # Test that submodule contents are currently not updated when switching | |
225 | # between commits that change a submodule. | |
226 | test_submodule_switch () { | |
227 | command="$1" | |
228 | ######################### Appearing submodule ######################### | |
229 | # Switching to a commit letting a submodule appear creates empty dir ... | |
da7fe3fb JL |
230 | if test "$KNOWN_FAILURE_STASH_DOES_IGNORE_SUBMODULE_CHANGES" = 1 |
231 | then | |
232 | # Restoring stash fails to restore submodule index entry | |
233 | RESULT="failure" | |
234 | else | |
235 | RESULT="success" | |
236 | fi | |
237 | test_expect_$RESULT "$command: added submodule creates empty directory" ' | |
42639d23 JL |
238 | prolog && |
239 | reset_work_tree_to no_submodule && | |
240 | ( | |
241 | cd submodule_update && | |
242 | git branch -t add_sub1 origin/add_sub1 && | |
243 | $command add_sub1 && | |
244 | test_superproject_content origin/add_sub1 && | |
245 | test_dir_is_empty sub1 && | |
246 | git submodule update --init --recursive && | |
247 | test_submodule_content sub1 origin/add_sub1 | |
248 | ) | |
249 | ' | |
250 | # ... and doesn't care if it already exists ... | |
da7fe3fb | 251 | test_expect_$RESULT "$command: added submodule leaves existing empty directory alone" ' |
42639d23 JL |
252 | prolog && |
253 | reset_work_tree_to no_submodule && | |
254 | ( | |
255 | cd submodule_update && | |
256 | mkdir sub1 && | |
257 | git branch -t add_sub1 origin/add_sub1 && | |
258 | $command add_sub1 && | |
259 | test_superproject_content origin/add_sub1 && | |
260 | test_dir_is_empty sub1 && | |
261 | git submodule update --init --recursive && | |
262 | test_submodule_content sub1 origin/add_sub1 | |
263 | ) | |
264 | ' | |
265 | # ... unless there is an untracked file in its place. | |
266 | test_expect_success "$command: added submodule doesn't remove untracked unignored file with same name" ' | |
267 | prolog && | |
268 | reset_work_tree_to no_submodule && | |
269 | ( | |
270 | cd submodule_update && | |
271 | git branch -t add_sub1 origin/add_sub1 && | |
272 | >sub1 && | |
273 | test_must_fail $command add_sub1 && | |
274 | test_superproject_content origin/no_submodule && | |
275 | test_must_be_empty sub1 | |
276 | ) | |
277 | ' | |
278 | # Replacing a tracked file with a submodule produces an empty | |
279 | # directory ... | |
da7fe3fb | 280 | test_expect_$RESULT "$command: replace tracked file with submodule creates empty directory" ' |
42639d23 JL |
281 | prolog && |
282 | reset_work_tree_to replace_sub1_with_file && | |
283 | ( | |
284 | cd submodule_update && | |
285 | git branch -t replace_file_with_sub1 origin/replace_file_with_sub1 && | |
286 | $command replace_file_with_sub1 && | |
287 | test_superproject_content origin/replace_file_with_sub1 && | |
288 | test_dir_is_empty sub1 && | |
289 | git submodule update --init --recursive && | |
290 | test_submodule_content sub1 origin/replace_file_with_sub1 | |
291 | ) | |
292 | ' | |
293 | # ... as does removing a directory with tracked files with a | |
294 | # submodule. | |
663ed39a JL |
295 | if test "$KNOWN_FAILURE_NOFF_MERGE_DOESNT_CREATE_EMPTY_SUBMODULE_DIR" = 1 |
296 | then | |
297 | # Non fast-forward merges fail with "Directory sub1 doesn't | |
298 | # exist. sub1" because the empty submodule directory is not | |
299 | # created | |
300 | RESULT="failure" | |
301 | else | |
302 | RESULT="success" | |
303 | fi | |
304 | test_expect_$RESULT "$command: replace directory with submodule" ' | |
42639d23 JL |
305 | prolog && |
306 | reset_work_tree_to replace_sub1_with_directory && | |
307 | ( | |
308 | cd submodule_update && | |
309 | git branch -t replace_directory_with_sub1 origin/replace_directory_with_sub1 && | |
310 | $command replace_directory_with_sub1 && | |
311 | test_superproject_content origin/replace_directory_with_sub1 && | |
312 | test_dir_is_empty sub1 && | |
313 | git submodule update --init --recursive && | |
314 | test_submodule_content sub1 origin/replace_directory_with_sub1 | |
315 | ) | |
316 | ' | |
317 | ||
318 | ######################## Disappearing submodule ####################### | |
319 | # Removing a submodule doesn't remove its work tree ... | |
da7fe3fb JL |
320 | if test "$KNOWN_FAILURE_STASH_DOES_IGNORE_SUBMODULE_CHANGES" = 1 |
321 | then | |
322 | RESULT="failure" | |
323 | else | |
324 | RESULT="success" | |
325 | fi | |
326 | test_expect_$RESULT "$command: removed submodule leaves submodule directory and its contents in place" ' | |
42639d23 JL |
327 | prolog && |
328 | reset_work_tree_to add_sub1 && | |
329 | ( | |
330 | cd submodule_update && | |
331 | git branch -t remove_sub1 origin/remove_sub1 && | |
332 | $command remove_sub1 && | |
333 | test_superproject_content origin/remove_sub1 && | |
334 | test_submodule_content sub1 origin/add_sub1 | |
335 | ) | |
336 | ' | |
337 | # ... especially when it contains a .git directory. | |
da7fe3fb | 338 | test_expect_$RESULT "$command: removed submodule leaves submodule containing a .git directory alone" ' |
42639d23 JL |
339 | prolog && |
340 | reset_work_tree_to add_sub1 && | |
341 | ( | |
342 | cd submodule_update && | |
343 | git branch -t remove_sub1 origin/remove_sub1 && | |
344 | replace_gitfile_with_git_dir sub1 && | |
345 | $command remove_sub1 && | |
346 | test_superproject_content origin/remove_sub1 && | |
347 | test_git_directory_is_unchanged sub1 && | |
348 | test_submodule_content sub1 origin/add_sub1 | |
349 | ) | |
350 | ' | |
351 | # Replacing a submodule with files in a directory must fail as the | |
352 | # submodule work tree isn't removed ... | |
663ed39a JL |
353 | if test "$KNOWN_FAILURE_NOFF_MERGE_ATTEMPTS_TO_MERGE_REMOVED_SUBMODULE_FILES" = 1 |
354 | then | |
355 | # Non fast-forward merges attempt to merge the former | |
356 | # submodule files with the newly checked out ones in the | |
357 | # directory of the same name while it shouldn't. | |
358 | RESULT="failure" | |
359 | else | |
360 | RESULT="success" | |
361 | fi | |
362 | test_expect_$RESULT "$command: replace submodule with a directory must fail" ' | |
42639d23 JL |
363 | prolog && |
364 | reset_work_tree_to add_sub1 && | |
365 | ( | |
366 | cd submodule_update && | |
367 | git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory && | |
368 | test_must_fail $command replace_sub1_with_directory && | |
369 | test_superproject_content origin/add_sub1 && | |
370 | test_submodule_content sub1 origin/add_sub1 | |
371 | ) | |
372 | ' | |
373 | # ... especially when it contains a .git directory. | |
663ed39a | 374 | test_expect_$RESULT "$command: replace submodule containing a .git directory with a directory must fail" ' |
42639d23 JL |
375 | prolog && |
376 | reset_work_tree_to add_sub1 && | |
377 | ( | |
378 | cd submodule_update && | |
379 | git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory && | |
380 | replace_gitfile_with_git_dir sub1 && | |
381 | test_must_fail $command replace_sub1_with_directory && | |
382 | test_superproject_content origin/add_sub1 && | |
383 | test_git_directory_is_unchanged sub1 && | |
384 | test_submodule_content sub1 origin/add_sub1 | |
385 | ) | |
386 | ' | |
387 | # Replacing it with a file must fail as it could throw away any local | |
388 | # work tree changes ... | |
389 | test_expect_failure "$command: replace submodule with a file must fail" ' | |
390 | prolog && | |
391 | reset_work_tree_to add_sub1 && | |
392 | ( | |
393 | cd submodule_update && | |
394 | git branch -t replace_sub1_with_file origin/replace_sub1_with_file && | |
395 | test_must_fail $command replace_sub1_with_file && | |
396 | test_superproject_content origin/add_sub1 && | |
397 | test_submodule_content sub1 origin/add_sub1 | |
398 | ) | |
399 | ' | |
400 | # ... or even destroy unpushed parts of submodule history if that | |
401 | # still uses a .git directory. | |
402 | test_expect_failure "$command: replace submodule containing a .git directory with a file must fail" ' | |
403 | prolog && | |
404 | reset_work_tree_to add_sub1 && | |
405 | ( | |
406 | cd submodule_update && | |
407 | git branch -t replace_sub1_with_file origin/replace_sub1_with_file && | |
408 | replace_gitfile_with_git_dir sub1 && | |
409 | test_must_fail $command replace_sub1_with_file && | |
410 | test_superproject_content origin/add_sub1 && | |
411 | test_git_directory_is_unchanged sub1 && | |
412 | test_submodule_content sub1 origin/add_sub1 | |
413 | ) | |
414 | ' | |
415 | ||
416 | ########################## Modified submodule ######################### | |
417 | # Updating a submodule sha1 doesn't update the submodule's work tree | |
283f56a4 JL |
418 | if test "$KNOWN_FAILURE_CHERRY_PICK_SEES_EMPTY_COMMIT" = 1 |
419 | then | |
420 | # When cherry picking a SHA-1 update for an ignored submodule | |
421 | # the commit incorrectly fails with "The previous cherry-pick | |
422 | # is now empty, possibly due to conflict resolution." | |
423 | RESULT="failure" | |
424 | else | |
425 | RESULT="success" | |
426 | fi | |
427 | test_expect_$RESULT "$command: modified submodule does not update submodule work tree" ' | |
42639d23 JL |
428 | prolog && |
429 | reset_work_tree_to add_sub1 && | |
430 | ( | |
431 | cd submodule_update && | |
432 | git branch -t modify_sub1 origin/modify_sub1 && | |
433 | $command modify_sub1 && | |
434 | test_superproject_content origin/modify_sub1 && | |
435 | test_submodule_content sub1 origin/add_sub1 && | |
436 | git submodule update && | |
437 | test_submodule_content sub1 origin/modify_sub1 | |
438 | ) | |
439 | ' | |
440 | ||
441 | # Updating a submodule to an invalid sha1 doesn't update the | |
442 | # submodule's work tree, subsequent update will fail | |
283f56a4 | 443 | test_expect_$RESULT "$command: modified submodule does not update submodule work tree to invalid commit" ' |
42639d23 JL |
444 | prolog && |
445 | reset_work_tree_to add_sub1 && | |
446 | ( | |
447 | cd submodule_update && | |
448 | git branch -t invalid_sub1 origin/invalid_sub1 && | |
449 | $command invalid_sub1 && | |
450 | test_superproject_content origin/invalid_sub1 && | |
451 | test_submodule_content sub1 origin/add_sub1 && | |
452 | test_must_fail git submodule update && | |
453 | test_submodule_content sub1 origin/add_sub1 | |
454 | ) | |
455 | ' | |
456 | # Updating a submodule from an invalid sha1 doesn't update the | |
457 | # submodule's work tree, subsequent update will succeed | |
283f56a4 | 458 | test_expect_$RESULT "$command: modified submodule does not update submodule work tree from invalid commit" ' |
42639d23 JL |
459 | prolog && |
460 | reset_work_tree_to invalid_sub1 && | |
461 | ( | |
462 | cd submodule_update && | |
463 | git branch -t valid_sub1 origin/valid_sub1 && | |
464 | $command valid_sub1 && | |
465 | test_superproject_content origin/valid_sub1 && | |
466 | test_dir_is_empty sub1 && | |
467 | git submodule update --init --recursive && | |
468 | test_submodule_content sub1 origin/valid_sub1 | |
469 | ) | |
470 | ' | |
471 | } | |
472 | ||
473 | # Test that submodule contents are currently not updated when switching | |
474 | # between commits that change a submodule, but throwing away local changes in | |
475 | # the superproject is allowed. | |
476 | test_submodule_forced_switch () { | |
477 | command="$1" | |
478 | ######################### Appearing submodule ######################### | |
479 | # Switching to a commit letting a submodule appear creates empty dir ... | |
480 | test_expect_success "$command: added submodule creates empty directory" ' | |
481 | prolog && | |
482 | reset_work_tree_to no_submodule && | |
483 | ( | |
484 | cd submodule_update && | |
485 | git branch -t add_sub1 origin/add_sub1 && | |
486 | $command add_sub1 && | |
487 | test_superproject_content origin/add_sub1 && | |
488 | test_dir_is_empty sub1 && | |
489 | git submodule update --init --recursive && | |
490 | test_submodule_content sub1 origin/add_sub1 | |
491 | ) | |
492 | ' | |
493 | # ... and doesn't care if it already exists ... | |
494 | test_expect_success "$command: added submodule leaves existing empty directory alone" ' | |
495 | prolog && | |
496 | reset_work_tree_to no_submodule && | |
497 | ( | |
498 | cd submodule_update && | |
499 | git branch -t add_sub1 origin/add_sub1 && | |
500 | mkdir sub1 && | |
501 | $command add_sub1 && | |
502 | test_superproject_content origin/add_sub1 && | |
503 | test_dir_is_empty sub1 && | |
504 | git submodule update --init --recursive && | |
505 | test_submodule_content sub1 origin/add_sub1 | |
506 | ) | |
507 | ' | |
508 | # ... unless there is an untracked file in its place. | |
509 | test_expect_success "$command: added submodule does remove untracked unignored file with same name when forced" ' | |
510 | prolog && | |
511 | reset_work_tree_to no_submodule && | |
512 | ( | |
513 | cd submodule_update && | |
514 | git branch -t add_sub1 origin/add_sub1 && | |
515 | >sub1 && | |
516 | $command add_sub1 && | |
517 | test_superproject_content origin/add_sub1 && | |
518 | test_dir_is_empty sub1 | |
519 | ) | |
520 | ' | |
521 | # Replacing a tracked file with a submodule produces an empty | |
522 | # directory ... | |
523 | test_expect_success "$command: replace tracked file with submodule creates empty directory" ' | |
524 | prolog && | |
525 | reset_work_tree_to replace_sub1_with_file && | |
526 | ( | |
527 | cd submodule_update && | |
528 | git branch -t replace_file_with_sub1 origin/replace_file_with_sub1 && | |
529 | $command replace_file_with_sub1 && | |
530 | test_superproject_content origin/replace_file_with_sub1 && | |
531 | test_dir_is_empty sub1 && | |
532 | git submodule update --init --recursive && | |
533 | test_submodule_content sub1 origin/replace_file_with_sub1 | |
534 | ) | |
535 | ' | |
536 | # ... as does removing a directory with tracked files with a | |
537 | # submodule. | |
538 | test_expect_success "$command: replace directory with submodule" ' | |
539 | prolog && | |
540 | reset_work_tree_to replace_sub1_with_directory && | |
541 | ( | |
542 | cd submodule_update && | |
543 | git branch -t replace_directory_with_sub1 origin/replace_directory_with_sub1 && | |
544 | $command replace_directory_with_sub1 && | |
545 | test_superproject_content origin/replace_directory_with_sub1 && | |
546 | test_dir_is_empty sub1 && | |
547 | git submodule update --init --recursive && | |
548 | test_submodule_content sub1 origin/replace_directory_with_sub1 | |
549 | ) | |
550 | ' | |
551 | ||
552 | ######################## Disappearing submodule ####################### | |
553 | # Removing a submodule doesn't remove its work tree ... | |
554 | test_expect_success "$command: removed submodule leaves submodule directory and its contents in place" ' | |
555 | prolog && | |
556 | reset_work_tree_to add_sub1 && | |
557 | ( | |
558 | cd submodule_update && | |
559 | git branch -t remove_sub1 origin/remove_sub1 && | |
560 | $command remove_sub1 && | |
561 | test_superproject_content origin/remove_sub1 && | |
562 | test_submodule_content sub1 origin/add_sub1 | |
563 | ) | |
564 | ' | |
565 | # ... especially when it contains a .git directory. | |
566 | test_expect_success "$command: removed submodule leaves submodule containing a .git directory alone" ' | |
567 | prolog && | |
568 | reset_work_tree_to add_sub1 && | |
569 | ( | |
570 | cd submodule_update && | |
571 | git branch -t remove_sub1 origin/remove_sub1 && | |
572 | replace_gitfile_with_git_dir sub1 && | |
573 | $command remove_sub1 && | |
574 | test_superproject_content origin/remove_sub1 && | |
575 | test_git_directory_is_unchanged sub1 && | |
576 | test_submodule_content sub1 origin/add_sub1 | |
577 | ) | |
578 | ' | |
579 | # Replacing a submodule with files in a directory must fail as the | |
580 | # submodule work tree isn't removed ... | |
581 | test_expect_failure "$command: replace submodule with a directory must fail" ' | |
582 | prolog && | |
583 | reset_work_tree_to add_sub1 && | |
584 | ( | |
585 | cd submodule_update && | |
586 | git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory && | |
587 | test_must_fail $command replace_sub1_with_directory && | |
588 | test_superproject_content origin/add_sub1 && | |
589 | test_submodule_content sub1 origin/add_sub1 | |
590 | ) | |
591 | ' | |
592 | # ... especially when it contains a .git directory. | |
593 | test_expect_failure "$command: replace submodule containing a .git directory with a directory must fail" ' | |
594 | prolog && | |
595 | reset_work_tree_to add_sub1 && | |
596 | ( | |
597 | cd submodule_update && | |
598 | git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory && | |
599 | replace_gitfile_with_git_dir sub1 && | |
600 | test_must_fail $command replace_sub1_with_directory && | |
601 | test_superproject_content origin/add_sub1 && | |
602 | test_git_directory_is_unchanged sub1 && | |
603 | test_submodule_content sub1 origin/add_sub1 | |
604 | ) | |
605 | ' | |
606 | # Replacing it with a file must fail as it could throw away any local | |
607 | # work tree changes ... | |
608 | test_expect_failure "$command: replace submodule with a file must fail" ' | |
609 | prolog && | |
610 | reset_work_tree_to add_sub1 && | |
611 | ( | |
612 | cd submodule_update && | |
613 | git branch -t replace_sub1_with_file origin/replace_sub1_with_file && | |
614 | test_must_fail $command replace_sub1_with_file && | |
615 | test_superproject_content origin/add_sub1 && | |
616 | test_submodule_content sub1 origin/add_sub1 | |
617 | ) | |
618 | ' | |
619 | # ... or even destroy unpushed parts of submodule history if that | |
620 | # still uses a .git directory. | |
621 | test_expect_failure "$command: replace submodule containing a .git directory with a file must fail" ' | |
622 | prolog && | |
623 | reset_work_tree_to add_sub1 && | |
624 | ( | |
625 | cd submodule_update && | |
626 | git branch -t replace_sub1_with_file origin/replace_sub1_with_file && | |
627 | replace_gitfile_with_git_dir sub1 && | |
628 | test_must_fail $command replace_sub1_with_file && | |
629 | test_superproject_content origin/add_sub1 && | |
630 | test_git_directory_is_unchanged sub1 && | |
631 | test_submodule_content sub1 origin/add_sub1 | |
632 | ) | |
633 | ' | |
634 | ||
635 | ########################## Modified submodule ######################### | |
636 | # Updating a submodule sha1 doesn't update the submodule's work tree | |
637 | test_expect_success "$command: modified submodule does not update submodule work tree" ' | |
638 | prolog && | |
639 | reset_work_tree_to add_sub1 && | |
640 | ( | |
641 | cd submodule_update && | |
642 | git branch -t modify_sub1 origin/modify_sub1 && | |
643 | $command modify_sub1 && | |
644 | test_superproject_content origin/modify_sub1 && | |
645 | test_submodule_content sub1 origin/add_sub1 && | |
646 | git submodule update && | |
647 | test_submodule_content sub1 origin/modify_sub1 | |
648 | ) | |
649 | ' | |
650 | # Updating a submodule to an invalid sha1 doesn't update the | |
651 | # submodule's work tree, subsequent update will fail | |
652 | test_expect_success "$command: modified submodule does not update submodule work tree to invalid commit" ' | |
653 | prolog && | |
654 | reset_work_tree_to add_sub1 && | |
655 | ( | |
656 | cd submodule_update && | |
657 | git branch -t invalid_sub1 origin/invalid_sub1 && | |
658 | $command invalid_sub1 && | |
659 | test_superproject_content origin/invalid_sub1 && | |
660 | test_submodule_content sub1 origin/add_sub1 && | |
661 | test_must_fail git submodule update && | |
662 | test_submodule_content sub1 origin/add_sub1 | |
663 | ) | |
664 | ' | |
665 | # Updating a submodule from an invalid sha1 doesn't update the | |
666 | # submodule's work tree, subsequent update will succeed | |
667 | test_expect_success "$command: modified submodule does not update submodule work tree from invalid commit" ' | |
668 | prolog && | |
669 | reset_work_tree_to invalid_sub1 && | |
670 | ( | |
671 | cd submodule_update && | |
672 | git branch -t valid_sub1 origin/valid_sub1 && | |
673 | $command valid_sub1 && | |
674 | test_superproject_content origin/valid_sub1 && | |
675 | test_dir_is_empty sub1 && | |
676 | git submodule update --init --recursive && | |
677 | test_submodule_content sub1 origin/valid_sub1 | |
678 | ) | |
679 | ' | |
680 | } |