dfe1a17df9
As discussed in [1] there's a regression in the "pu" branch now because a new test implicitly assumed that a previous test guarded by a prerequisite had been run. Add a "GIT_TEST_FAIL_PREREQS" special test setup where we'll skip (nearly) all tests guarded by prerequisites, allowing us to easily emulate those platform where we don't run these tests. As noted in the documentation I'm adding I'm whitelisting the SYMLINKS prerequisite for now. A lot of tests started failing if we lied about not supporting symlinks. It's also unlikely that we'll have a failing test due to a hard dependency on symlinks without that being the obvious cause, so for now it's not worth the effort to make it work. 1. https://public-inbox.org/git/nycvar.QRO.7.76.6.1905131531000.44@tvgsbejvaqbjf.bet/ Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
456 lines
11 KiB
Bash
Executable File
456 lines
11 KiB
Bash
Executable File
#!/bin/sh
|
|
|
|
test_description='merging with submodules'
|
|
|
|
. ./test-lib.sh
|
|
|
|
#
|
|
# history
|
|
#
|
|
# a --- c
|
|
# / \ /
|
|
# root X
|
|
# \ / \
|
|
# b --- d
|
|
#
|
|
|
|
test_expect_success setup '
|
|
|
|
mkdir sub &&
|
|
(cd sub &&
|
|
git init &&
|
|
echo original > file &&
|
|
git add file &&
|
|
test_tick &&
|
|
git commit -m sub-root) &&
|
|
git add sub &&
|
|
test_tick &&
|
|
git commit -m root &&
|
|
|
|
git checkout -b a master &&
|
|
(cd sub &&
|
|
echo A > file &&
|
|
git add file &&
|
|
test_tick &&
|
|
git commit -m sub-a) &&
|
|
git add sub &&
|
|
test_tick &&
|
|
git commit -m a &&
|
|
|
|
git checkout -b b master &&
|
|
(cd sub &&
|
|
echo B > file &&
|
|
git add file &&
|
|
test_tick &&
|
|
git commit -m sub-b) &&
|
|
git add sub &&
|
|
test_tick &&
|
|
git commit -m b &&
|
|
|
|
git checkout -b c a &&
|
|
git merge -s ours b &&
|
|
|
|
git checkout -b d b &&
|
|
git merge -s ours a
|
|
'
|
|
|
|
# History setup
|
|
#
|
|
# b
|
|
# / \
|
|
# init -- a d
|
|
# \ \ /
|
|
# g c
|
|
#
|
|
# a in the main repository records to sub-a in the submodule and
|
|
# analogous b and c. d should be automatically found by merging c into
|
|
# b in the main repository.
|
|
test_expect_success 'setup for merge search' '
|
|
mkdir merge-search &&
|
|
(cd merge-search &&
|
|
git init &&
|
|
mkdir sub &&
|
|
(cd sub &&
|
|
git init &&
|
|
echo "file-a" > file-a &&
|
|
git add file-a &&
|
|
git commit -m "sub-a" &&
|
|
git branch sub-a) &&
|
|
git commit --allow-empty -m init &&
|
|
git branch init &&
|
|
git add sub &&
|
|
git commit -m "a" &&
|
|
git branch a &&
|
|
|
|
git checkout -b b &&
|
|
(cd sub &&
|
|
git checkout -b sub-b &&
|
|
echo "file-b" > file-b &&
|
|
git add file-b &&
|
|
git commit -m "sub-b") &&
|
|
git commit -a -m "b" &&
|
|
|
|
git checkout -b c a &&
|
|
(cd sub &&
|
|
git checkout -b sub-c sub-a &&
|
|
echo "file-c" > file-c &&
|
|
git add file-c &&
|
|
git commit -m "sub-c") &&
|
|
git commit -a -m "c" &&
|
|
|
|
git checkout -b d a &&
|
|
(cd sub &&
|
|
git checkout -b sub-d sub-b &&
|
|
git merge sub-c) &&
|
|
git commit -a -m "d" &&
|
|
git branch test b &&
|
|
|
|
git checkout -b g init &&
|
|
(cd sub &&
|
|
git checkout -b sub-g sub-c) &&
|
|
git add sub &&
|
|
git commit -a -m "g")
|
|
'
|
|
|
|
test_expect_success 'merge with one side as a fast-forward of the other' '
|
|
(cd merge-search &&
|
|
git checkout -b test-forward b &&
|
|
git merge d &&
|
|
git ls-tree test-forward sub | cut -f1 | cut -f3 -d" " > actual &&
|
|
(cd sub &&
|
|
git rev-parse sub-d > ../expect) &&
|
|
test_cmp expect actual)
|
|
'
|
|
|
|
test_expect_success 'merging should conflict for non fast-forward' '
|
|
(cd merge-search &&
|
|
git checkout -b test-nonforward b &&
|
|
(cd sub &&
|
|
git rev-parse sub-d > ../expect) &&
|
|
test_must_fail git merge c 2> actual &&
|
|
grep $(cat expect) actual > /dev/null &&
|
|
git reset --hard)
|
|
'
|
|
|
|
test_expect_success 'merging should fail for ambiguous common parent' '
|
|
(cd merge-search &&
|
|
git checkout -b test-ambiguous b &&
|
|
(cd sub &&
|
|
git checkout -b ambiguous sub-b &&
|
|
git merge sub-c &&
|
|
git rev-parse sub-d > ../expect1 &&
|
|
git rev-parse ambiguous > ../expect2) &&
|
|
test_must_fail git merge c 2> actual &&
|
|
grep $(cat expect1) actual > /dev/null &&
|
|
grep $(cat expect2) actual > /dev/null &&
|
|
git reset --hard)
|
|
'
|
|
|
|
# in a situation like this
|
|
#
|
|
# submodule tree:
|
|
#
|
|
# sub-a --- sub-b --- sub-d
|
|
#
|
|
# main tree:
|
|
#
|
|
# e (sub-a)
|
|
# /
|
|
# bb (sub-b)
|
|
# \
|
|
# f (sub-d)
|
|
#
|
|
# A merge between e and f should fail because one of the submodule
|
|
# commits (sub-a) does not descend from the submodule merge-base (sub-b).
|
|
#
|
|
test_expect_success 'merging should fail for changes that are backwards' '
|
|
(cd merge-search &&
|
|
git checkout -b bb a &&
|
|
(cd sub &&
|
|
git checkout sub-b) &&
|
|
git commit -a -m "bb" &&
|
|
|
|
git checkout -b e bb &&
|
|
(cd sub &&
|
|
git checkout sub-a) &&
|
|
git commit -a -m "e" &&
|
|
|
|
git checkout -b f bb &&
|
|
(cd sub &&
|
|
git checkout sub-d) &&
|
|
git commit -a -m "f" &&
|
|
|
|
git checkout -b test-backward e &&
|
|
test_must_fail git merge f)
|
|
'
|
|
|
|
|
|
# Check that the conflicting submodule is detected when it is
|
|
# in the common ancestor. status should be 'U00...00"
|
|
test_expect_success 'git submodule status should display the merge conflict properly with merge base' '
|
|
(cd merge-search &&
|
|
cat >.gitmodules <<EOF &&
|
|
[submodule "sub"]
|
|
path = sub
|
|
url = $TRASH_DIRECTORY/sub
|
|
EOF
|
|
cat >expect <<EOF &&
|
|
U0000000000000000000000000000000000000000 sub
|
|
EOF
|
|
git submodule status > actual &&
|
|
test_cmp expect actual &&
|
|
git reset --hard)
|
|
'
|
|
|
|
# Check that the conflicting submodule is detected when it is
|
|
# not in the common ancestor. status should be 'U00...00"
|
|
test_expect_success 'git submodule status should display the merge conflict properly without merge-base' '
|
|
(cd merge-search &&
|
|
git checkout -b test-no-merge-base g &&
|
|
test_must_fail git merge b &&
|
|
cat >.gitmodules <<EOF &&
|
|
[submodule "sub"]
|
|
path = sub
|
|
url = $TRASH_DIRECTORY/sub
|
|
EOF
|
|
cat >expect <<EOF &&
|
|
U0000000000000000000000000000000000000000 sub
|
|
EOF
|
|
git submodule status > actual &&
|
|
test_cmp expect actual &&
|
|
git reset --hard)
|
|
'
|
|
|
|
|
|
test_expect_success 'merging with a modify/modify conflict between merge bases' '
|
|
git reset --hard HEAD &&
|
|
git checkout -b test2 c &&
|
|
git merge d
|
|
'
|
|
|
|
# canonical criss-cross history in top and submodule
|
|
test_expect_success 'setup for recursive merge with submodule' '
|
|
mkdir merge-recursive &&
|
|
(cd merge-recursive &&
|
|
git init &&
|
|
mkdir sub &&
|
|
(cd sub &&
|
|
git init &&
|
|
test_commit a &&
|
|
git checkout -b sub-b master &&
|
|
test_commit b &&
|
|
git checkout -b sub-c master &&
|
|
test_commit c &&
|
|
git checkout -b sub-bc sub-b &&
|
|
git merge sub-c &&
|
|
git checkout -b sub-cb sub-c &&
|
|
git merge sub-b &&
|
|
git checkout master) &&
|
|
git add sub &&
|
|
git commit -m a &&
|
|
git checkout -b top-b master &&
|
|
(cd sub && git checkout sub-b) &&
|
|
git add sub &&
|
|
git commit -m b &&
|
|
git checkout -b top-c master &&
|
|
(cd sub && git checkout sub-c) &&
|
|
git add sub &&
|
|
git commit -m c &&
|
|
git checkout -b top-bc top-b &&
|
|
git merge -s ours --no-commit top-c &&
|
|
(cd sub && git checkout sub-bc) &&
|
|
git add sub &&
|
|
git commit -m bc &&
|
|
git checkout -b top-cb top-c &&
|
|
git merge -s ours --no-commit top-b &&
|
|
(cd sub && git checkout sub-cb) &&
|
|
git add sub &&
|
|
git commit -m cb)
|
|
'
|
|
|
|
# merge should leave submodule unmerged in index
|
|
test_expect_success 'recursive merge with submodule' '
|
|
(cd merge-recursive &&
|
|
test_must_fail git merge top-bc &&
|
|
echo "160000 $(git rev-parse top-cb:sub) 2 sub" > expect2 &&
|
|
echo "160000 $(git rev-parse top-bc:sub) 3 sub" > expect3 &&
|
|
git ls-files -u > actual &&
|
|
grep "$(cat expect2)" actual > /dev/null &&
|
|
grep "$(cat expect3)" actual > /dev/null)
|
|
'
|
|
|
|
# File/submodule conflict
|
|
# Commit O: <empty>
|
|
# Commit A: path (submodule)
|
|
# Commit B: path
|
|
# Expected: path/ is submodule and file contents for B's path are somewhere
|
|
|
|
test_expect_success 'setup file/submodule conflict' '
|
|
test_create_repo file-submodule &&
|
|
(
|
|
cd file-submodule &&
|
|
|
|
git commit --allow-empty -m O &&
|
|
|
|
git branch A &&
|
|
git branch B &&
|
|
|
|
git checkout B &&
|
|
echo content >path &&
|
|
git add path &&
|
|
git commit -m B &&
|
|
|
|
git checkout A &&
|
|
test_create_repo path &&
|
|
test_commit -C path world &&
|
|
git submodule add ./path &&
|
|
git commit -m A
|
|
)
|
|
'
|
|
|
|
test_expect_failure 'file/submodule conflict' '
|
|
test_when_finished "git -C file-submodule reset --hard" &&
|
|
(
|
|
cd file-submodule &&
|
|
|
|
git checkout A^0 &&
|
|
test_must_fail git merge B^0 &&
|
|
|
|
git ls-files -s >out &&
|
|
test_line_count = 3 out &&
|
|
git ls-files -u >out &&
|
|
test_line_count = 2 out &&
|
|
|
|
# path/ is still a submodule
|
|
test_path_is_dir path/.git &&
|
|
|
|
# There is a submodule at "path", so B:path cannot be written
|
|
# there. We expect it to be written somewhere in the same
|
|
# directory, though, so just grep for its content in all
|
|
# files, and ignore "grep: path: Is a directory" message
|
|
echo Checking if contents from B:path showed up anywhere &&
|
|
grep -q content * 2>/dev/null
|
|
)
|
|
'
|
|
|
|
test_expect_success 'file/submodule conflict; merge --abort works afterward' '
|
|
test_when_finished "git -C file-submodule reset --hard" &&
|
|
(
|
|
cd file-submodule &&
|
|
|
|
git checkout A^0 &&
|
|
test_must_fail git merge B^0 >out 2>err &&
|
|
|
|
test_path_is_file .git/MERGE_HEAD &&
|
|
git merge --abort
|
|
)
|
|
'
|
|
|
|
# Directory/submodule conflict
|
|
# Commit O: <empty>
|
|
# Commit A: path (submodule), with sole tracked file named 'world'
|
|
# Commit B1: path/file
|
|
# Commit B2: path/world
|
|
#
|
|
# Expected from merge of A & B1:
|
|
# Contents under path/ from commit B1 are renamed elsewhere; we do not
|
|
# want to write files from one of our tracked directories into a submodule
|
|
#
|
|
# Expected from merge of A & B2:
|
|
# Similar to last merge, but with a slight twist: we don't want paths
|
|
# under the submodule to be treated as untracked or in the way.
|
|
|
|
test_expect_success 'setup directory/submodule conflict' '
|
|
test_create_repo directory-submodule &&
|
|
(
|
|
cd directory-submodule &&
|
|
|
|
git commit --allow-empty -m O &&
|
|
|
|
git branch A &&
|
|
git branch B1 &&
|
|
git branch B2 &&
|
|
|
|
git checkout B1 &&
|
|
mkdir path &&
|
|
echo contents >path/file &&
|
|
git add path/file &&
|
|
git commit -m B1 &&
|
|
|
|
git checkout B2 &&
|
|
mkdir path &&
|
|
echo contents >path/world &&
|
|
git add path/world &&
|
|
git commit -m B2 &&
|
|
|
|
git checkout A &&
|
|
test_create_repo path &&
|
|
test_commit -C path hello world &&
|
|
git submodule add ./path &&
|
|
git commit -m A
|
|
)
|
|
'
|
|
|
|
test_expect_failure 'directory/submodule conflict; keep submodule clean' '
|
|
test_when_finished "git -C directory-submodule reset --hard" &&
|
|
(
|
|
cd directory-submodule &&
|
|
|
|
git checkout A^0 &&
|
|
test_must_fail git merge B1^0 &&
|
|
|
|
git ls-files -s >out &&
|
|
test_line_count = 3 out &&
|
|
git ls-files -u >out &&
|
|
test_line_count = 1 out &&
|
|
|
|
# path/ is still a submodule
|
|
test_path_is_dir path/.git &&
|
|
|
|
echo Checking if contents from B1:path/file showed up &&
|
|
# Would rather use grep -r, but that is GNU extension...
|
|
git ls-files -co | xargs grep -q contents 2>/dev/null &&
|
|
|
|
# However, B1:path/file should NOT have shown up at path/file,
|
|
# because we should not write into the submodule
|
|
test_path_is_missing path/file
|
|
)
|
|
'
|
|
|
|
test_expect_failure !FAIL_PREREQS 'directory/submodule conflict; should not treat submodule files as untracked or in the way' '
|
|
test_when_finished "git -C directory-submodule/path reset --hard" &&
|
|
test_when_finished "git -C directory-submodule reset --hard" &&
|
|
(
|
|
cd directory-submodule &&
|
|
|
|
git checkout A^0 &&
|
|
test_must_fail git merge B2^0 >out 2>err &&
|
|
|
|
# We do not want files within the submodule to prevent the
|
|
# merge from starting; we should not be writing to such paths
|
|
# anyway.
|
|
test_i18ngrep ! "refusing to lose untracked file at" err
|
|
)
|
|
'
|
|
|
|
test_expect_failure 'directory/submodule conflict; merge --abort works afterward' '
|
|
test_when_finished "git -C directory-submodule/path reset --hard" &&
|
|
test_when_finished "git -C directory-submodule reset --hard" &&
|
|
(
|
|
cd directory-submodule &&
|
|
|
|
git checkout A^0 &&
|
|
test_must_fail git merge B2^0 &&
|
|
test_path_is_file .git/MERGE_HEAD &&
|
|
|
|
# merge --abort should succeed, should clear .git/MERGE_HEAD,
|
|
# and should not leave behind any conflicted files
|
|
git merge --abort &&
|
|
test_path_is_missing .git/MERGE_HEAD &&
|
|
git ls-files -u >conflicts &&
|
|
test_must_be_empty conflicts
|
|
)
|
|
'
|
|
|
|
test_done
|