2010-11-12 12:54:52 +00:00
|
|
|
#!/bin/sh
|
|
|
|
# Copyright (c) 2010, Jens Lehmann
|
|
|
|
|
|
|
|
test_description='Recursive "git fetch" for submodules'
|
|
|
|
|
2021-10-08 21:08:19 +00:00
|
|
|
GIT_TEST_FATAL_REGISTER_SUBMODULE_ODB=1
|
|
|
|
export GIT_TEST_FATAL_REGISTER_SUBMODULE_ODB
|
|
|
|
|
2010-11-12 12:54:52 +00:00
|
|
|
. ./test-lib.sh
|
|
|
|
|
|
|
|
pwd=$(pwd)
|
|
|
|
|
2022-03-08 00:14:25 +00:00
|
|
|
write_expected_sub () {
|
|
|
|
NEW_HEAD=$1 &&
|
2022-03-08 00:14:32 +00:00
|
|
|
SUPER_HEAD=$2 &&
|
2022-03-08 00:14:25 +00:00
|
|
|
cat >"$pwd/expect.err.sub" <<-EOF
|
2022-03-08 00:14:32 +00:00
|
|
|
Fetching submodule submodule${SUPER_HEAD:+ at commit $SUPER_HEAD}
|
2022-03-08 00:14:25 +00:00
|
|
|
From $pwd/submodule
|
|
|
|
OLD_HEAD..$NEW_HEAD sub -> origin/sub
|
|
|
|
EOF
|
|
|
|
}
|
|
|
|
|
2022-03-08 00:14:32 +00:00
|
|
|
write_expected_sub2 () {
|
|
|
|
NEW_HEAD=$1 &&
|
|
|
|
SUPER_HEAD=$2 &&
|
|
|
|
cat >"$pwd/expect.err.sub2" <<-EOF
|
|
|
|
Fetching submodule submodule2${SUPER_HEAD:+ at commit $SUPER_HEAD}
|
|
|
|
From $pwd/submodule2
|
|
|
|
OLD_HEAD..$NEW_HEAD sub2 -> origin/sub2
|
|
|
|
EOF
|
|
|
|
}
|
|
|
|
|
2022-03-08 00:14:25 +00:00
|
|
|
write_expected_deep () {
|
|
|
|
NEW_HEAD=$1 &&
|
2022-03-08 00:14:32 +00:00
|
|
|
SUB_HEAD=$2 &&
|
2022-03-08 00:14:25 +00:00
|
|
|
cat >"$pwd/expect.err.deep" <<-EOF
|
2022-03-08 00:14:32 +00:00
|
|
|
Fetching submodule submodule/subdir/deepsubmodule${SUB_HEAD:+ at commit $SUB_HEAD}
|
2022-03-08 00:14:25 +00:00
|
|
|
From $pwd/deepsubmodule
|
|
|
|
OLD_HEAD..$NEW_HEAD deep -> origin/deep
|
|
|
|
EOF
|
|
|
|
}
|
|
|
|
|
|
|
|
write_expected_super () {
|
|
|
|
NEW_HEAD=$1 &&
|
|
|
|
cat >"$pwd/expect.err.super" <<-EOF
|
|
|
|
From $pwd/.
|
|
|
|
OLD_HEAD..$NEW_HEAD super -> origin/super
|
|
|
|
EOF
|
|
|
|
}
|
|
|
|
|
2022-03-08 00:14:24 +00:00
|
|
|
# For each submodule in the test setup, this creates a commit and writes
|
|
|
|
# a file that contains the expected err if that new commit were fetched.
|
|
|
|
# These output files get concatenated in the right order by
|
|
|
|
# verify_fetch_result().
|
2022-03-08 00:14:26 +00:00
|
|
|
add_submodule_commits () {
|
2010-11-12 12:54:52 +00:00
|
|
|
(
|
|
|
|
cd submodule &&
|
|
|
|
echo new >> subfile &&
|
|
|
|
test_tick &&
|
|
|
|
git add subfile &&
|
|
|
|
git commit -m new subfile &&
|
2022-03-08 00:14:25 +00:00
|
|
|
new_head=$(git rev-parse --short HEAD) &&
|
|
|
|
write_expected_sub $new_head
|
2010-11-12 12:54:52 +00:00
|
|
|
) &&
|
|
|
|
(
|
|
|
|
cd deepsubmodule &&
|
|
|
|
echo new >> deepsubfile &&
|
|
|
|
test_tick &&
|
|
|
|
git add deepsubfile &&
|
|
|
|
git commit -m new deepsubfile &&
|
2022-03-08 00:14:25 +00:00
|
|
|
new_head=$(git rev-parse --short HEAD) &&
|
|
|
|
write_expected_deep $new_head
|
2010-11-12 12:54:52 +00:00
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2022-03-08 00:14:26 +00:00
|
|
|
# For each superproject in the test setup, update its submodule, add the
|
|
|
|
# submodule and create a new commit with the submodule change.
|
|
|
|
#
|
|
|
|
# This requires add_submodule_commits() to be called first, otherwise
|
|
|
|
# the submodules will not have changed and cannot be "git add"-ed.
|
|
|
|
add_superproject_commits () {
|
|
|
|
(
|
|
|
|
cd submodule &&
|
|
|
|
(
|
|
|
|
cd subdir/deepsubmodule &&
|
|
|
|
git fetch &&
|
|
|
|
git checkout -q FETCH_HEAD
|
|
|
|
) &&
|
|
|
|
git add subdir/deepsubmodule &&
|
|
|
|
git commit -m "new deep submodule"
|
|
|
|
) &&
|
|
|
|
git add submodule &&
|
|
|
|
git commit -m "new submodule" &&
|
|
|
|
super_head=$(git rev-parse --short HEAD) &&
|
|
|
|
sub_head=$(git -C submodule rev-parse --short HEAD) &&
|
|
|
|
write_expected_super $super_head &&
|
|
|
|
write_expected_sub $sub_head
|
|
|
|
}
|
|
|
|
|
2022-03-08 00:14:24 +00:00
|
|
|
# Verifies that the expected repositories were fetched. This is done by
|
|
|
|
# concatenating the files expect.err.[super|sub|deep] in the correct
|
|
|
|
# order and comparing it to the actual stderr.
|
|
|
|
#
|
|
|
|
# If a repo should not be fetched in the test, its corresponding
|
|
|
|
# expect.err file should be rm-ed.
|
|
|
|
verify_fetch_result () {
|
|
|
|
ACTUAL_ERR=$1 &&
|
|
|
|
rm -f expect.err.combined &&
|
|
|
|
if test -f expect.err.super
|
|
|
|
then
|
|
|
|
cat expect.err.super >>expect.err.combined
|
|
|
|
fi &&
|
|
|
|
if test -f expect.err.sub
|
|
|
|
then
|
|
|
|
cat expect.err.sub >>expect.err.combined
|
|
|
|
fi &&
|
|
|
|
if test -f expect.err.deep
|
|
|
|
then
|
|
|
|
cat expect.err.deep >>expect.err.combined
|
|
|
|
fi &&
|
2022-03-08 00:14:32 +00:00
|
|
|
if test -f expect.err.sub2
|
|
|
|
then
|
|
|
|
cat expect.err.sub2 >>expect.err.combined
|
|
|
|
fi &&
|
2022-03-08 00:14:25 +00:00
|
|
|
sed -e 's/[0-9a-f][0-9a-f]*\.\./OLD_HEAD\.\./' "$ACTUAL_ERR" >actual.err.cmp &&
|
|
|
|
test_cmp expect.err.combined actual.err.cmp
|
2022-03-08 00:14:24 +00:00
|
|
|
}
|
|
|
|
|
2010-11-12 12:54:52 +00:00
|
|
|
test_expect_success setup '
|
2022-07-29 19:21:06 +00:00
|
|
|
git config --global protocol.file.allow always &&
|
2010-11-12 12:54:52 +00:00
|
|
|
mkdir deepsubmodule &&
|
|
|
|
(
|
|
|
|
cd deepsubmodule &&
|
|
|
|
git init &&
|
|
|
|
echo deepsubcontent > deepsubfile &&
|
|
|
|
git add deepsubfile &&
|
2020-12-04 14:34:21 +00:00
|
|
|
git commit -m new deepsubfile &&
|
|
|
|
git branch -M deep
|
2010-11-12 12:54:52 +00:00
|
|
|
) &&
|
|
|
|
mkdir submodule &&
|
|
|
|
(
|
|
|
|
cd submodule &&
|
|
|
|
git init &&
|
|
|
|
echo subcontent > subfile &&
|
|
|
|
git add subfile &&
|
2011-06-20 18:18:03 +00:00
|
|
|
git submodule add "$pwd/deepsubmodule" subdir/deepsubmodule &&
|
2020-12-04 14:34:21 +00:00
|
|
|
git commit -a -m new &&
|
|
|
|
git branch -M sub
|
2010-11-12 12:54:52 +00:00
|
|
|
) &&
|
|
|
|
git submodule add "$pwd/submodule" submodule &&
|
|
|
|
git commit -am initial &&
|
2020-12-04 14:34:21 +00:00
|
|
|
git branch -M super &&
|
2010-11-12 12:54:52 +00:00
|
|
|
git clone . downstream &&
|
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git submodule update --init --recursive
|
2015-12-16 00:04:06 +00:00
|
|
|
)
|
2010-11-12 12:54:52 +00:00
|
|
|
'
|
|
|
|
|
2020-12-04 14:34:22 +00:00
|
|
|
test_expect_success "fetch --recurse-submodules recurses into submodules" '
|
2022-03-08 00:14:26 +00:00
|
|
|
add_submodule_commits &&
|
2010-11-12 12:54:52 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch --recurse-submodules >../actual.out 2>../actual.err
|
2011-04-12 18:23:23 +00:00
|
|
|
) &&
|
2015-12-16 00:04:06 +00:00
|
|
|
test_must_be_empty actual.out &&
|
2022-03-08 00:14:24 +00:00
|
|
|
verify_fetch_result actual.err
|
2010-11-12 12:54:52 +00:00
|
|
|
'
|
|
|
|
|
2023-03-08 22:22:05 +00:00
|
|
|
test_expect_success "fetch --recurse-submodules honors --no-write-fetch-head" '
|
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git submodule foreach --recursive \
|
|
|
|
sh -c "cd \"\$(git rev-parse --git-dir)\" && rm -f FETCH_HEAD" &&
|
|
|
|
|
|
|
|
git fetch --recurse-submodules --no-write-fetch-head &&
|
|
|
|
|
|
|
|
git submodule foreach --recursive \
|
|
|
|
sh -c "cd \"\$(git rev-parse --git-dir)\" && ! test -f FETCH_HEAD"
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2020-12-04 14:34:22 +00:00
|
|
|
test_expect_success "submodule.recurse option triggers recursive fetch" '
|
2022-03-08 00:14:26 +00:00
|
|
|
add_submodule_commits &&
|
2017-06-01 00:30:50 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git -c submodule.recurse fetch >../actual.out 2>../actual.err
|
|
|
|
) &&
|
|
|
|
test_must_be_empty actual.out &&
|
2022-03-08 00:14:24 +00:00
|
|
|
verify_fetch_result actual.err
|
2017-06-01 00:30:50 +00:00
|
|
|
'
|
|
|
|
|
2020-12-04 14:34:22 +00:00
|
|
|
test_expect_success "fetch --recurse-submodules -j2 has the same output behaviour" '
|
submodule tests: reset "trace.out" between "grep" invocations
Fix test patterns added in 62104ba14af (submodules: allow parallel
fetching, add tests and documentation, 2015-12-15) and
a028a1930c6 (fetching submodules: respect `submodule.fetchJobs` config
option, 2016-02-29).
In the former case we were leaving a trace.out file at the top-level
for any subsequent tests (there are none, currently). Let's clean the
file up instead.
In the latter case we were testing that a given configuration would
result in "N tasks" in the log, but we were grepping through the log
for all previous such tests, when we really meant to clear the logs
between the "grep" invocations.
In practice this resulted in no logic error, as e.g. "--fetch 7" would
not print out a "9 tasks" line, but let's be paranoid and stop
implicitly assuming that that's the case.
This change was originally left out of 51243f9f0f6 (run-command API:
don't fall back on online_cpus(), 2022-10-12), which added the
">trace.out" seen at the end of the context.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Taylor Blau <me@ttaylorr.com>
2022-10-29 02:59:46 +00:00
|
|
|
test_when_finished "rm -f trace.out" &&
|
2022-03-08 00:14:26 +00:00
|
|
|
add_submodule_commits &&
|
2015-12-16 00:04:12 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
2018-02-23 23:39:46 +00:00
|
|
|
GIT_TRACE="$TRASH_DIRECTORY/trace.out" git fetch --recurse-submodules -j2 2>../actual.err
|
2015-12-16 00:04:12 +00:00
|
|
|
) &&
|
|
|
|
test_must_be_empty actual.out &&
|
2022-03-08 00:14:24 +00:00
|
|
|
verify_fetch_result actual.err &&
|
2015-12-16 00:04:12 +00:00
|
|
|
grep "2 tasks" trace.out
|
|
|
|
'
|
|
|
|
|
2010-11-12 12:54:52 +00:00
|
|
|
test_expect_success "fetch alone only fetches superproject" '
|
2022-03-08 00:14:26 +00:00
|
|
|
add_submodule_commits &&
|
2010-11-12 12:54:52 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch >../actual.out 2>../actual.err
|
|
|
|
) &&
|
2018-08-19 21:57:22 +00:00
|
|
|
test_must_be_empty actual.out &&
|
|
|
|
test_must_be_empty actual.err
|
2010-11-12 12:54:52 +00:00
|
|
|
'
|
|
|
|
|
2010-11-10 23:55:41 +00:00
|
|
|
test_expect_success "fetch --no-recurse-submodules only fetches superproject" '
|
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch --no-recurse-submodules >../actual.out 2>../actual.err
|
|
|
|
) &&
|
2018-08-19 21:57:22 +00:00
|
|
|
test_must_be_empty actual.out &&
|
|
|
|
test_must_be_empty actual.err
|
2010-11-10 23:55:41 +00:00
|
|
|
'
|
|
|
|
|
2020-12-04 14:34:22 +00:00
|
|
|
test_expect_success "using fetchRecurseSubmodules=true in .gitmodules recurses into submodules" '
|
2010-11-10 23:55:41 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git config -f .gitmodules submodule.submodule.fetchRecurseSubmodules true &&
|
|
|
|
git fetch >../actual.out 2>../actual.err
|
2011-04-12 18:23:23 +00:00
|
|
|
) &&
|
2015-12-16 00:04:06 +00:00
|
|
|
test_must_be_empty actual.out &&
|
2022-03-08 00:14:24 +00:00
|
|
|
verify_fetch_result actual.err
|
2010-11-10 23:55:41 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "--no-recurse-submodules overrides .gitmodules config" '
|
2022-03-08 00:14:26 +00:00
|
|
|
add_submodule_commits &&
|
2010-11-10 23:55:41 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch --no-recurse-submodules >../actual.out 2>../actual.err
|
|
|
|
) &&
|
2018-08-19 21:57:22 +00:00
|
|
|
test_must_be_empty actual.out &&
|
|
|
|
test_must_be_empty actual.err
|
2010-11-10 23:55:41 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "using fetchRecurseSubmodules=false in .git/config overrides setting in .gitmodules" '
|
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git config submodule.submodule.fetchRecurseSubmodules false &&
|
|
|
|
git fetch >../actual.out 2>../actual.err
|
|
|
|
) &&
|
2018-08-19 21:57:22 +00:00
|
|
|
test_must_be_empty actual.out &&
|
|
|
|
test_must_be_empty actual.err
|
2010-11-10 23:55:41 +00:00
|
|
|
'
|
|
|
|
|
2020-12-04 14:34:22 +00:00
|
|
|
test_expect_success "--recurse-submodules overrides fetchRecurseSubmodules setting from .git/config" '
|
2010-11-10 23:55:41 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch --recurse-submodules >../actual.out 2>../actual.err &&
|
2011-01-31 16:51:25 +00:00
|
|
|
git config --unset -f .gitmodules submodule.submodule.fetchRecurseSubmodules &&
|
2010-11-10 23:55:41 +00:00
|
|
|
git config --unset submodule.submodule.fetchRecurseSubmodules
|
2011-04-12 18:23:23 +00:00
|
|
|
) &&
|
2015-12-16 00:04:06 +00:00
|
|
|
test_must_be_empty actual.out &&
|
2022-03-08 00:14:24 +00:00
|
|
|
verify_fetch_result actual.err
|
2010-11-10 23:55:41 +00:00
|
|
|
'
|
|
|
|
|
2010-11-12 12:54:52 +00:00
|
|
|
test_expect_success "--quiet propagates to submodules" '
|
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch --recurse-submodules --quiet >../actual.out 2>../actual.err
|
|
|
|
) &&
|
2018-08-19 21:57:22 +00:00
|
|
|
test_must_be_empty actual.out &&
|
|
|
|
test_must_be_empty actual.err
|
2010-11-12 12:54:52 +00:00
|
|
|
'
|
|
|
|
|
2015-12-16 00:04:12 +00:00
|
|
|
test_expect_success "--quiet propagates to parallel submodules" '
|
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch --recurse-submodules -j 2 --quiet >../actual.out 2>../actual.err
|
|
|
|
) &&
|
2018-08-19 21:57:22 +00:00
|
|
|
test_must_be_empty actual.out &&
|
|
|
|
test_must_be_empty actual.err
|
2015-12-16 00:04:12 +00:00
|
|
|
'
|
|
|
|
|
2020-12-04 14:34:22 +00:00
|
|
|
test_expect_success "--dry-run propagates to submodules" '
|
2022-03-08 00:14:26 +00:00
|
|
|
add_submodule_commits &&
|
2010-11-12 12:54:52 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch --recurse-submodules --dry-run >../actual.out 2>../actual.err
|
2011-04-12 18:23:23 +00:00
|
|
|
) &&
|
2015-12-16 00:04:06 +00:00
|
|
|
test_must_be_empty actual.out &&
|
2022-03-08 00:14:24 +00:00
|
|
|
verify_fetch_result actual.err
|
2011-02-22 23:41:52 +00:00
|
|
|
'
|
|
|
|
|
2020-12-04 14:34:22 +00:00
|
|
|
test_expect_success "Without --dry-run propagates to submodules" '
|
2010-11-12 12:54:52 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch --recurse-submodules >../actual.out 2>../actual.err
|
2011-04-12 18:23:23 +00:00
|
|
|
) &&
|
2015-12-16 00:04:06 +00:00
|
|
|
test_must_be_empty actual.out &&
|
2022-03-08 00:14:24 +00:00
|
|
|
verify_fetch_result actual.err
|
2010-11-12 12:54:52 +00:00
|
|
|
'
|
|
|
|
|
2020-12-04 14:34:22 +00:00
|
|
|
test_expect_success "recurseSubmodules=true propagates into submodules" '
|
2022-03-08 00:14:26 +00:00
|
|
|
add_submodule_commits &&
|
2010-11-10 23:55:02 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
2017-08-17 10:36:13 +00:00
|
|
|
git config fetch.recurseSubmodules true &&
|
2010-11-10 23:55:02 +00:00
|
|
|
git fetch >../actual.out 2>../actual.err
|
2011-04-12 18:23:23 +00:00
|
|
|
) &&
|
2015-12-16 00:04:06 +00:00
|
|
|
test_must_be_empty actual.out &&
|
2022-03-08 00:14:24 +00:00
|
|
|
verify_fetch_result actual.err
|
2010-11-10 23:55:02 +00:00
|
|
|
'
|
|
|
|
|
2020-12-04 14:34:22 +00:00
|
|
|
test_expect_success "--recurse-submodules overrides config in submodule" '
|
2022-03-08 00:14:26 +00:00
|
|
|
add_submodule_commits &&
|
2010-11-10 23:55:02 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
(
|
|
|
|
cd submodule &&
|
|
|
|
git config fetch.recurseSubmodules false
|
|
|
|
) &&
|
|
|
|
git fetch --recurse-submodules >../actual.out 2>../actual.err
|
2011-04-12 18:23:23 +00:00
|
|
|
) &&
|
2015-12-16 00:04:06 +00:00
|
|
|
test_must_be_empty actual.out &&
|
2022-03-08 00:14:24 +00:00
|
|
|
verify_fetch_result actual.err
|
2010-11-10 23:55:02 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "--no-recurse-submodules overrides config setting" '
|
2022-03-08 00:14:26 +00:00
|
|
|
add_submodule_commits &&
|
2010-11-10 23:55:02 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
2017-08-17 10:36:13 +00:00
|
|
|
git config fetch.recurseSubmodules true &&
|
2010-11-10 23:55:02 +00:00
|
|
|
git fetch --no-recurse-submodules >../actual.out 2>../actual.err
|
|
|
|
) &&
|
2018-08-19 21:57:22 +00:00
|
|
|
test_must_be_empty actual.out &&
|
|
|
|
test_must_be_empty actual.err
|
2010-11-10 23:55:02 +00:00
|
|
|
'
|
|
|
|
|
2020-12-04 14:34:22 +00:00
|
|
|
test_expect_success "Recursion doesn't happen when no new commits are fetched in the superproject" '
|
2011-03-06 22:10:46 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
(
|
|
|
|
cd submodule &&
|
|
|
|
git config --unset fetch.recurseSubmodules
|
|
|
|
) &&
|
2017-08-17 10:36:13 +00:00
|
|
|
git config --unset fetch.recurseSubmodules &&
|
2011-03-06 22:10:46 +00:00
|
|
|
git fetch >../actual.out 2>../actual.err
|
|
|
|
) &&
|
2018-08-19 21:57:22 +00:00
|
|
|
test_must_be_empty actual.out &&
|
|
|
|
test_must_be_empty actual.err
|
2011-03-06 22:10:46 +00:00
|
|
|
'
|
|
|
|
|
2020-12-04 14:34:22 +00:00
|
|
|
test_expect_success "Recursion stops when no new submodule commits are fetched" '
|
2011-03-06 22:10:46 +00:00
|
|
|
git add submodule &&
|
|
|
|
git commit -m "new submodule" &&
|
2022-03-08 00:14:25 +00:00
|
|
|
new_head=$(git rev-parse --short HEAD) &&
|
|
|
|
write_expected_super $new_head &&
|
2022-03-08 00:14:24 +00:00
|
|
|
rm expect.err.deep &&
|
2011-03-06 22:10:46 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch >../actual.out 2>../actual.err
|
|
|
|
) &&
|
2022-03-08 00:14:24 +00:00
|
|
|
verify_fetch_result actual.err &&
|
2015-12-16 00:04:06 +00:00
|
|
|
test_must_be_empty actual.out
|
2011-03-06 22:10:46 +00:00
|
|
|
'
|
|
|
|
|
2020-12-04 14:34:22 +00:00
|
|
|
test_expect_success "Recursion doesn't happen when new superproject commits don't change any submodules" '
|
2022-03-08 00:14:26 +00:00
|
|
|
add_submodule_commits &&
|
2011-03-06 22:10:46 +00:00
|
|
|
echo a > file &&
|
|
|
|
git add file &&
|
|
|
|
git commit -m "new file" &&
|
2022-03-08 00:14:25 +00:00
|
|
|
new_head=$(git rev-parse --short HEAD) &&
|
|
|
|
write_expected_super $new_head &&
|
2022-03-08 00:14:24 +00:00
|
|
|
rm expect.err.sub &&
|
|
|
|
rm expect.err.deep &&
|
2011-03-06 22:10:46 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch >../actual.out 2>../actual.err
|
|
|
|
) &&
|
2018-08-19 21:57:22 +00:00
|
|
|
test_must_be_empty actual.out &&
|
2022-03-08 00:14:24 +00:00
|
|
|
verify_fetch_result actual.err
|
2011-03-06 22:10:46 +00:00
|
|
|
'
|
|
|
|
|
2020-12-04 14:34:22 +00:00
|
|
|
test_expect_success "Recursion picks up config in submodule" '
|
2011-03-06 22:10:46 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch --recurse-submodules &&
|
|
|
|
(
|
|
|
|
cd submodule &&
|
|
|
|
git config fetch.recurseSubmodules true
|
|
|
|
)
|
|
|
|
) &&
|
2022-03-08 00:14:26 +00:00
|
|
|
add_submodule_commits &&
|
2011-03-06 22:10:46 +00:00
|
|
|
git add submodule &&
|
|
|
|
git commit -m "new submodule" &&
|
2022-03-08 00:14:25 +00:00
|
|
|
new_head=$(git rev-parse --short HEAD) &&
|
|
|
|
write_expected_super $new_head &&
|
2011-03-06 22:10:46 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch >../actual.out 2>../actual.err &&
|
|
|
|
(
|
|
|
|
cd submodule &&
|
|
|
|
git config --unset fetch.recurseSubmodules
|
|
|
|
)
|
|
|
|
) &&
|
2022-03-08 00:14:24 +00:00
|
|
|
verify_fetch_result actual.err &&
|
2015-12-16 00:04:06 +00:00
|
|
|
test_must_be_empty actual.out
|
2011-03-06 22:10:46 +00:00
|
|
|
'
|
|
|
|
|
2020-12-04 14:34:22 +00:00
|
|
|
test_expect_success "Recursion picks up all submodules when necessary" '
|
2022-03-08 00:14:26 +00:00
|
|
|
add_submodule_commits &&
|
|
|
|
add_superproject_commits &&
|
2011-03-06 22:10:46 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch >../actual.out 2>../actual.err
|
|
|
|
) &&
|
2022-03-08 00:14:24 +00:00
|
|
|
verify_fetch_result actual.err &&
|
2015-12-16 00:04:06 +00:00
|
|
|
test_must_be_empty actual.out
|
2011-03-06 22:10:46 +00:00
|
|
|
'
|
|
|
|
|
2020-12-04 14:34:22 +00:00
|
|
|
test_expect_success "'--recurse-submodules=on-demand' doesn't recurse when no new commits are fetched in the superproject (and ignores config)" '
|
2022-03-08 00:14:26 +00:00
|
|
|
add_submodule_commits &&
|
2011-03-06 22:11:21 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git config fetch.recurseSubmodules true &&
|
|
|
|
git fetch --recurse-submodules=on-demand >../actual.out 2>../actual.err &&
|
|
|
|
git config --unset fetch.recurseSubmodules
|
|
|
|
) &&
|
2018-08-19 21:57:22 +00:00
|
|
|
test_must_be_empty actual.out &&
|
|
|
|
test_must_be_empty actual.err
|
2011-03-06 22:11:21 +00:00
|
|
|
'
|
|
|
|
|
2020-12-04 14:34:22 +00:00
|
|
|
test_expect_success "'--recurse-submodules=on-demand' recurses as deep as necessary (and ignores config)" '
|
2022-03-08 00:14:26 +00:00
|
|
|
add_submodule_commits &&
|
|
|
|
add_superproject_commits &&
|
2011-03-06 22:11:21 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git config fetch.recurseSubmodules false &&
|
|
|
|
(
|
|
|
|
cd submodule &&
|
2011-06-20 18:18:03 +00:00
|
|
|
git config -f .gitmodules submodule.subdir/deepsubmodule.fetchRecursive false
|
2011-03-06 22:11:21 +00:00
|
|
|
) &&
|
|
|
|
git fetch --recurse-submodules=on-demand >../actual.out 2>../actual.err &&
|
2018-07-02 00:24:01 +00:00
|
|
|
git config --unset fetch.recurseSubmodules &&
|
2011-03-06 22:11:21 +00:00
|
|
|
(
|
|
|
|
cd submodule &&
|
2011-06-20 18:18:03 +00:00
|
|
|
git config --unset -f .gitmodules submodule.subdir/deepsubmodule.fetchRecursive
|
2011-03-06 22:11:21 +00:00
|
|
|
)
|
|
|
|
) &&
|
2015-12-16 00:04:06 +00:00
|
|
|
test_must_be_empty actual.out &&
|
2022-03-08 00:14:24 +00:00
|
|
|
verify_fetch_result actual.err
|
2011-03-06 22:11:21 +00:00
|
|
|
'
|
|
|
|
|
2022-03-08 00:14:32 +00:00
|
|
|
# These tests verify that we can fetch submodules that aren't in the
|
|
|
|
# index.
|
|
|
|
#
|
|
|
|
# First, test the simple case where the index is empty and we only fetch
|
|
|
|
# submodules that are not in the index.
|
|
|
|
test_expect_success 'setup downstream branch without submodules' '
|
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git checkout --recurse-submodules -b no-submodules &&
|
|
|
|
git rm .gitmodules &&
|
|
|
|
git rm submodule &&
|
|
|
|
git commit -m "no submodules" &&
|
|
|
|
git checkout --recurse-submodules super
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "'--recurse-submodules=on-demand' should fetch submodule commits if the submodule is changed but the index has no submodules" '
|
|
|
|
add_submodule_commits &&
|
|
|
|
add_superproject_commits &&
|
|
|
|
# Fetch the new superproject commit
|
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git switch --recurse-submodules no-submodules &&
|
|
|
|
git fetch --recurse-submodules=on-demand >../actual.out 2>../actual.err
|
|
|
|
) &&
|
|
|
|
super_head=$(git rev-parse --short HEAD) &&
|
|
|
|
sub_head=$(git -C submodule rev-parse --short HEAD) &&
|
|
|
|
deep_head=$(git -C submodule/subdir/deepsubmodule rev-parse --short HEAD) &&
|
|
|
|
|
|
|
|
# assert that these are fetched from commits, not the index
|
|
|
|
write_expected_sub $sub_head $super_head &&
|
|
|
|
write_expected_deep $deep_head $sub_head &&
|
|
|
|
|
|
|
|
test_must_be_empty actual.out &&
|
|
|
|
verify_fetch_result actual.err
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "'--recurse-submodules' should fetch submodule commits if the submodule is changed but the index has no submodules" '
|
|
|
|
add_submodule_commits &&
|
|
|
|
add_superproject_commits &&
|
|
|
|
# Fetch the new superproject commit
|
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git switch --recurse-submodules no-submodules &&
|
|
|
|
git fetch --recurse-submodules >../actual.out 2>../actual.err
|
|
|
|
) &&
|
|
|
|
super_head=$(git rev-parse --short HEAD) &&
|
|
|
|
sub_head=$(git -C submodule rev-parse --short HEAD) &&
|
|
|
|
deep_head=$(git -C submodule/subdir/deepsubmodule rev-parse --short HEAD) &&
|
|
|
|
|
|
|
|
# assert that these are fetched from commits, not the index
|
|
|
|
write_expected_sub $sub_head $super_head &&
|
|
|
|
write_expected_deep $deep_head $sub_head &&
|
|
|
|
|
|
|
|
test_must_be_empty actual.out &&
|
|
|
|
verify_fetch_result actual.err
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "'--recurse-submodules' should ignore changed, inactive submodules" '
|
|
|
|
add_submodule_commits &&
|
|
|
|
add_superproject_commits &&
|
|
|
|
|
|
|
|
# Fetch the new superproject commit
|
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git switch --recurse-submodules no-submodules &&
|
|
|
|
git -c submodule.submodule.active=false fetch --recurse-submodules >../actual.out 2>../actual.err
|
|
|
|
) &&
|
|
|
|
test_must_be_empty actual.out &&
|
|
|
|
super_head=$(git rev-parse --short HEAD) &&
|
|
|
|
write_expected_super $super_head &&
|
|
|
|
# Neither should be fetched because the submodule is inactive
|
|
|
|
rm expect.err.sub &&
|
|
|
|
rm expect.err.deep &&
|
|
|
|
verify_fetch_result actual.err
|
|
|
|
'
|
|
|
|
|
|
|
|
# Now that we know we can fetch submodules that are not in the index,
|
|
|
|
# test that we can fetch index and non-index submodules in the same
|
|
|
|
# operation.
|
|
|
|
test_expect_success 'setup downstream branch with other submodule' '
|
|
|
|
mkdir submodule2 &&
|
|
|
|
(
|
|
|
|
cd submodule2 &&
|
|
|
|
git init &&
|
|
|
|
echo sub2content >sub2file &&
|
|
|
|
git add sub2file &&
|
|
|
|
git commit -a -m new &&
|
|
|
|
git branch -M sub2
|
|
|
|
) &&
|
|
|
|
git checkout -b super-sub2-only &&
|
|
|
|
git submodule add "$pwd/submodule2" submodule2 &&
|
|
|
|
git commit -m "add sub2" &&
|
|
|
|
git checkout super &&
|
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch --recurse-submodules origin &&
|
|
|
|
git checkout super-sub2-only &&
|
|
|
|
# Explicitly run "git submodule update" because sub2 is new
|
|
|
|
# and has not been cloned.
|
|
|
|
git submodule update --init &&
|
|
|
|
git checkout --recurse-submodules super
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "'--recurse-submodules' should fetch submodule commits in changed submodules and the index" '
|
|
|
|
test_when_finished "rm expect.err.sub2" &&
|
|
|
|
# Create new commit in origin/super
|
|
|
|
add_submodule_commits &&
|
|
|
|
add_superproject_commits &&
|
|
|
|
|
|
|
|
# Create new commit in origin/super-sub2-only
|
|
|
|
git checkout super-sub2-only &&
|
|
|
|
(
|
|
|
|
cd submodule2 &&
|
|
|
|
test_commit --no-tag foo
|
|
|
|
) &&
|
|
|
|
git add submodule2 &&
|
|
|
|
git commit -m "new submodule2" &&
|
|
|
|
|
|
|
|
git checkout super &&
|
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch --recurse-submodules >../actual.out 2>../actual.err
|
|
|
|
) &&
|
|
|
|
test_must_be_empty actual.out &&
|
|
|
|
sub2_head=$(git -C submodule2 rev-parse --short HEAD) &&
|
|
|
|
super_head=$(git rev-parse --short super) &&
|
|
|
|
super_sub2_only_head=$(git rev-parse --short super-sub2-only) &&
|
|
|
|
write_expected_sub2 $sub2_head $super_sub2_only_head &&
|
|
|
|
|
|
|
|
# write_expected_super cannot handle >1 branch. Since this is a
|
|
|
|
# one-off, construct expect.err.super manually.
|
|
|
|
cat >"$pwd/expect.err.super" <<-EOF &&
|
|
|
|
From $pwd/.
|
|
|
|
OLD_HEAD..$super_head super -> origin/super
|
|
|
|
OLD_HEAD..$super_sub2_only_head super-sub2-only -> origin/super-sub2-only
|
|
|
|
EOF
|
|
|
|
verify_fetch_result actual.err
|
|
|
|
'
|
|
|
|
|
2020-12-04 14:34:22 +00:00
|
|
|
test_expect_success "'--recurse-submodules=on-demand' stops when no new submodule commits are found in the superproject (and ignores config)" '
|
2022-03-08 00:14:26 +00:00
|
|
|
add_submodule_commits &&
|
2011-03-06 22:11:21 +00:00
|
|
|
echo a >> file &&
|
|
|
|
git add file &&
|
|
|
|
git commit -m "new file" &&
|
2022-03-08 00:14:25 +00:00
|
|
|
new_head=$(git rev-parse --short HEAD) &&
|
|
|
|
write_expected_super $new_head &&
|
2022-03-08 00:14:24 +00:00
|
|
|
rm expect.err.sub &&
|
|
|
|
rm expect.err.deep &&
|
2011-03-06 22:11:21 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch --recurse-submodules=on-demand >../actual.out 2>../actual.err
|
|
|
|
) &&
|
2018-08-19 21:57:22 +00:00
|
|
|
test_must_be_empty actual.out &&
|
2022-03-08 00:14:24 +00:00
|
|
|
verify_fetch_result actual.err
|
2011-03-06 22:11:21 +00:00
|
|
|
'
|
|
|
|
|
2020-12-04 14:34:22 +00:00
|
|
|
test_expect_success "'fetch.recurseSubmodules=on-demand' overrides global config" '
|
2011-03-06 22:11:48 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch --recurse-submodules
|
|
|
|
) &&
|
2022-03-08 00:14:26 +00:00
|
|
|
add_submodule_commits &&
|
2011-03-06 22:11:48 +00:00
|
|
|
git config --global fetch.recurseSubmodules false &&
|
|
|
|
git add submodule &&
|
|
|
|
git commit -m "new submodule" &&
|
2022-03-08 00:14:25 +00:00
|
|
|
new_head=$(git rev-parse --short HEAD) &&
|
|
|
|
write_expected_super $new_head &&
|
2022-03-08 00:14:24 +00:00
|
|
|
rm expect.err.deep &&
|
2011-03-06 22:11:48 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git config fetch.recurseSubmodules on-demand &&
|
|
|
|
git fetch >../actual.out 2>../actual.err
|
|
|
|
) &&
|
|
|
|
git config --global --unset fetch.recurseSubmodules &&
|
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git config --unset fetch.recurseSubmodules
|
|
|
|
) &&
|
2015-12-16 00:04:06 +00:00
|
|
|
test_must_be_empty actual.out &&
|
2022-03-08 00:14:24 +00:00
|
|
|
verify_fetch_result actual.err
|
2011-03-06 22:11:48 +00:00
|
|
|
'
|
|
|
|
|
2020-12-04 14:34:22 +00:00
|
|
|
test_expect_success "'submodule.<sub>.fetchRecurseSubmodules=on-demand' overrides fetch.recurseSubmodules" '
|
2011-03-06 22:12:19 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch --recurse-submodules
|
|
|
|
) &&
|
2022-03-08 00:14:26 +00:00
|
|
|
add_submodule_commits &&
|
2011-03-06 22:12:19 +00:00
|
|
|
git config fetch.recurseSubmodules false &&
|
|
|
|
git add submodule &&
|
|
|
|
git commit -m "new submodule" &&
|
2022-03-08 00:14:25 +00:00
|
|
|
new_head=$(git rev-parse --short HEAD) &&
|
|
|
|
write_expected_super $new_head &&
|
2022-03-08 00:14:24 +00:00
|
|
|
rm expect.err.deep &&
|
2011-03-06 22:12:19 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git config submodule.submodule.fetchRecurseSubmodules on-demand &&
|
|
|
|
git fetch >../actual.out 2>../actual.err
|
|
|
|
) &&
|
|
|
|
git config --unset fetch.recurseSubmodules &&
|
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git config --unset submodule.submodule.fetchRecurseSubmodules
|
|
|
|
) &&
|
2015-12-16 00:04:06 +00:00
|
|
|
test_must_be_empty actual.out &&
|
2022-03-08 00:14:24 +00:00
|
|
|
verify_fetch_result actual.err
|
2011-03-06 22:12:19 +00:00
|
|
|
'
|
|
|
|
|
2020-12-04 14:34:22 +00:00
|
|
|
test_expect_success "don't fetch submodule when newly recorded commits are already present" '
|
2011-03-06 22:12:58 +00:00
|
|
|
(
|
|
|
|
cd submodule &&
|
|
|
|
git checkout -q HEAD^^
|
|
|
|
) &&
|
|
|
|
git add submodule &&
|
|
|
|
git commit -m "submodule rewound" &&
|
2022-03-08 00:14:25 +00:00
|
|
|
new_head=$(git rev-parse --short HEAD) &&
|
|
|
|
write_expected_super $new_head &&
|
2022-03-08 00:14:24 +00:00
|
|
|
rm expect.err.sub &&
|
|
|
|
# This file does not exist, but rm -f for readability
|
|
|
|
rm -f expect.err.deep &&
|
2011-03-06 22:12:58 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch >../actual.out 2>../actual.err
|
|
|
|
) &&
|
2018-08-19 21:57:22 +00:00
|
|
|
test_must_be_empty actual.out &&
|
2022-03-08 00:14:24 +00:00
|
|
|
verify_fetch_result actual.err &&
|
2017-10-06 22:30:47 +00:00
|
|
|
(
|
|
|
|
cd submodule &&
|
2020-12-04 14:34:21 +00:00
|
|
|
git checkout -q sub
|
2017-10-06 22:30:47 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2020-12-04 14:34:22 +00:00
|
|
|
test_expect_success "'fetch.recurseSubmodules=on-demand' works also without .gitmodules entry" '
|
2017-10-06 22:30:47 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch --recurse-submodules
|
|
|
|
) &&
|
2022-03-08 00:14:26 +00:00
|
|
|
add_submodule_commits &&
|
2017-10-06 22:30:47 +00:00
|
|
|
git add submodule &&
|
|
|
|
git rm .gitmodules &&
|
|
|
|
git commit -m "new submodule without .gitmodules" &&
|
2022-03-08 00:14:25 +00:00
|
|
|
new_head=$(git rev-parse --short HEAD) &&
|
|
|
|
write_expected_super $new_head &&
|
2022-03-08 00:14:24 +00:00
|
|
|
rm expect.err.deep &&
|
2017-10-06 22:30:47 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
rm .gitmodules &&
|
|
|
|
git config fetch.recurseSubmodules on-demand &&
|
|
|
|
# fake submodule configuration to avoid skipping submodule handling
|
|
|
|
git config -f .gitmodules submodule.fake.path fake &&
|
|
|
|
git config -f .gitmodules submodule.fake.url fakeurl &&
|
|
|
|
git add .gitmodules &&
|
|
|
|
git config --unset submodule.submodule.url &&
|
|
|
|
git fetch >../actual.out 2>../actual.err &&
|
|
|
|
# cleanup
|
|
|
|
git config --unset fetch.recurseSubmodules &&
|
|
|
|
git reset --hard
|
|
|
|
) &&
|
tests: use 'test_must_be_empty' instead of 'test_cmp <empty> <out>'
Using 'test_must_be_empty' is shorter and more idiomatic than
>empty &&
test_cmp empty out
as it saves the creation of an empty file. Furthermore, sometimes the
expected empty file doesn't have such a descriptive name like 'empty',
and its creation is far away from the place where it's finally used
for comparison (e.g. in 't7600-merge.sh', where two expected empty
files are created in the 'setup' test, but are used only about 500
lines later).
These cases were found by instrumenting 'test_cmp' to error out the
test script when it's used to compare empty files, and then converted
manually.
Note that even after this patch there still remain a lot of cases
where we use 'test_cmp' to check empty files:
- Sometimes the expected output is not hard-coded in the test, but
'test_cmp' is used to ensure that two similar git commands produce
the same output, and that output happens to be empty, e.g. the
test 'submodule update --merge - ignores --merge for new
submodules' in 't7406-submodule-update.sh'.
- Repetitive common tasks, including preparing the expected results
and running 'test_cmp', are often extracted into a helper
function, and some of this helper's callsites expect no output.
- For the same reason as above, the whole 'test_expect_success'
block is within a helper function, e.g. in 't3070-wildmatch.sh'.
- Or 'test_cmp' is invoked in a loop, e.g. the test 'cvs update
(-p)' in 't9400-git-cvsserver-server.sh'.
Signed-off-by: SZEDER Gábor <szeder.dev@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-19 21:57:25 +00:00
|
|
|
test_must_be_empty actual.out &&
|
2022-03-08 00:14:24 +00:00
|
|
|
verify_fetch_result actual.err &&
|
2017-10-06 22:30:47 +00:00
|
|
|
git checkout HEAD^ -- .gitmodules &&
|
|
|
|
git add .gitmodules &&
|
|
|
|
git commit -m "new submodule restored .gitmodules"
|
2011-03-06 22:12:58 +00:00
|
|
|
'
|
|
|
|
|
2016-03-01 02:07:13 +00:00
|
|
|
test_expect_success 'fetching submodules respects parallel settings' '
|
|
|
|
git config fetch.recurseSubmodules true &&
|
submodule tests: reset "trace.out" between "grep" invocations
Fix test patterns added in 62104ba14af (submodules: allow parallel
fetching, add tests and documentation, 2015-12-15) and
a028a1930c6 (fetching submodules: respect `submodule.fetchJobs` config
option, 2016-02-29).
In the former case we were leaving a trace.out file at the top-level
for any subsequent tests (there are none, currently). Let's clean the
file up instead.
In the latter case we were testing that a given configuration would
result in "N tasks" in the log, but we were grepping through the log
for all previous such tests, when we really meant to clear the logs
between the "grep" invocations.
In practice this resulted in no logic error, as e.g. "--fetch 7" would
not print out a "9 tasks" line, but let's be paranoid and stop
implicitly assuming that that's the case.
This change was originally left out of 51243f9f0f6 (run-command API:
don't fall back on online_cpus(), 2022-10-12), which added the
">trace.out" seen at the end of the context.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Taylor Blau <me@ttaylorr.com>
2022-10-29 02:59:46 +00:00
|
|
|
test_when_finished "rm -f downstream/trace.out" &&
|
2016-03-01 02:07:13 +00:00
|
|
|
(
|
|
|
|
cd downstream &&
|
2018-12-13 19:02:48 +00:00
|
|
|
GIT_TRACE=$(pwd)/trace.out git fetch &&
|
|
|
|
grep "1 tasks" trace.out &&
|
submodule tests: reset "trace.out" between "grep" invocations
Fix test patterns added in 62104ba14af (submodules: allow parallel
fetching, add tests and documentation, 2015-12-15) and
a028a1930c6 (fetching submodules: respect `submodule.fetchJobs` config
option, 2016-02-29).
In the former case we were leaving a trace.out file at the top-level
for any subsequent tests (there are none, currently). Let's clean the
file up instead.
In the latter case we were testing that a given configuration would
result in "N tasks" in the log, but we were grepping through the log
for all previous such tests, when we really meant to clear the logs
between the "grep" invocations.
In practice this resulted in no logic error, as e.g. "--fetch 7" would
not print out a "9 tasks" line, but let's be paranoid and stop
implicitly assuming that that's the case.
This change was originally left out of 51243f9f0f6 (run-command API:
don't fall back on online_cpus(), 2022-10-12), which added the
">trace.out" seen at the end of the context.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Taylor Blau <me@ttaylorr.com>
2022-10-29 02:59:46 +00:00
|
|
|
>trace.out &&
|
|
|
|
|
2016-03-01 02:07:13 +00:00
|
|
|
GIT_TRACE=$(pwd)/trace.out git fetch --jobs 7 &&
|
|
|
|
grep "7 tasks" trace.out &&
|
submodule tests: reset "trace.out" between "grep" invocations
Fix test patterns added in 62104ba14af (submodules: allow parallel
fetching, add tests and documentation, 2015-12-15) and
a028a1930c6 (fetching submodules: respect `submodule.fetchJobs` config
option, 2016-02-29).
In the former case we were leaving a trace.out file at the top-level
for any subsequent tests (there are none, currently). Let's clean the
file up instead.
In the latter case we were testing that a given configuration would
result in "N tasks" in the log, but we were grepping through the log
for all previous such tests, when we really meant to clear the logs
between the "grep" invocations.
In practice this resulted in no logic error, as e.g. "--fetch 7" would
not print out a "9 tasks" line, but let's be paranoid and stop
implicitly assuming that that's the case.
This change was originally left out of 51243f9f0f6 (run-command API:
don't fall back on online_cpus(), 2022-10-12), which added the
">trace.out" seen at the end of the context.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Taylor Blau <me@ttaylorr.com>
2022-10-29 02:59:46 +00:00
|
|
|
>trace.out &&
|
|
|
|
|
2016-03-01 02:07:13 +00:00
|
|
|
git config submodule.fetchJobs 8 &&
|
|
|
|
GIT_TRACE=$(pwd)/trace.out git fetch &&
|
|
|
|
grep "8 tasks" trace.out &&
|
submodule tests: reset "trace.out" between "grep" invocations
Fix test patterns added in 62104ba14af (submodules: allow parallel
fetching, add tests and documentation, 2015-12-15) and
a028a1930c6 (fetching submodules: respect `submodule.fetchJobs` config
option, 2016-02-29).
In the former case we were leaving a trace.out file at the top-level
for any subsequent tests (there are none, currently). Let's clean the
file up instead.
In the latter case we were testing that a given configuration would
result in "N tasks" in the log, but we were grepping through the log
for all previous such tests, when we really meant to clear the logs
between the "grep" invocations.
In practice this resulted in no logic error, as e.g. "--fetch 7" would
not print out a "9 tasks" line, but let's be paranoid and stop
implicitly assuming that that's the case.
This change was originally left out of 51243f9f0f6 (run-command API:
don't fall back on online_cpus(), 2022-10-12), which added the
">trace.out" seen at the end of the context.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Taylor Blau <me@ttaylorr.com>
2022-10-29 02:59:46 +00:00
|
|
|
>trace.out &&
|
|
|
|
|
2016-03-01 02:07:13 +00:00
|
|
|
GIT_TRACE=$(pwd)/trace.out git fetch --jobs 9 &&
|
2022-10-12 21:02:24 +00:00
|
|
|
grep "9 tasks" trace.out &&
|
|
|
|
>trace.out &&
|
|
|
|
|
|
|
|
GIT_TRACE=$(pwd)/trace.out git -c submodule.fetchJobs=0 fetch &&
|
|
|
|
grep "preparing to run up to [0-9]* tasks" trace.out &&
|
|
|
|
! grep "up to 0 tasks" trace.out &&
|
|
|
|
>trace.out
|
2016-03-01 02:07:13 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
submodule: avoid auto-discovery in prepare_submodule_repo_env()
The function is used to set up the environment variable used in a
subprocess we spawn in a submodule directory. The callers set up a
child_process structure, find the working tree path of one submodule
and set .dir field to it, and then use start_command() API to spawn
the subprocess like "status", "fetch", etc.
When this happens, we expect that the ".git" (either a directory or
a gitfile that points at the real location) in the current working
directory of the subprocess MUST be the repository for the submodule.
If this ".git" thing is a corrupt repository, however, because
prepare_submodule_repo_env() unsets GIT_DIR and GIT_WORK_TREE, the
subprocess will see ".git", thinks it is not a repository, and
attempt to find one by going up, likely to end up in finding the
repository of the superproject. In some codepaths, this will cause
a command run with the "--recurse-submodules" option to recurse
forever.
By exporting GIT_DIR=.git, disable the auto-discovery logic in the
subprocess, which would instead stop it and report an error.
The test illustrates existing problems in a few callsites of this
function. Without this fix, "git fetch --recurse-submodules", "git
status" and "git diff" keep recursing forever.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-09-01 20:51:48 +00:00
|
|
|
test_expect_success 'fetching submodule into a broken repository' '
|
|
|
|
# Prepare src and src/sub nested in it
|
|
|
|
git init src &&
|
|
|
|
(
|
|
|
|
cd src &&
|
|
|
|
git init sub &&
|
|
|
|
git -C sub commit --allow-empty -m "initial in sub" &&
|
|
|
|
git submodule add -- ./sub sub &&
|
|
|
|
git commit -m "initial in top"
|
|
|
|
) &&
|
|
|
|
|
|
|
|
# Clone the old-fashoned way
|
|
|
|
git clone src dst &&
|
|
|
|
git -C dst clone ../src/sub sub &&
|
|
|
|
|
|
|
|
# Make sure that old-fashoned layout is still supported
|
|
|
|
git -C dst status &&
|
|
|
|
|
|
|
|
# "diff" would find no change
|
|
|
|
git -C dst diff --exit-code &&
|
|
|
|
|
|
|
|
# Recursive-fetch works fine
|
|
|
|
git -C dst fetch --recurse-submodules &&
|
|
|
|
|
|
|
|
# Break the receiving submodule
|
2023-11-02 08:46:45 +00:00
|
|
|
test-tool -C dst/sub ref-store main delete-refs REF_NO_DEREF msg HEAD &&
|
submodule: avoid auto-discovery in prepare_submodule_repo_env()
The function is used to set up the environment variable used in a
subprocess we spawn in a submodule directory. The callers set up a
child_process structure, find the working tree path of one submodule
and set .dir field to it, and then use start_command() API to spawn
the subprocess like "status", "fetch", etc.
When this happens, we expect that the ".git" (either a directory or
a gitfile that points at the real location) in the current working
directory of the subprocess MUST be the repository for the submodule.
If this ".git" thing is a corrupt repository, however, because
prepare_submodule_repo_env() unsets GIT_DIR and GIT_WORK_TREE, the
subprocess will see ".git", thinks it is not a repository, and
attempt to find one by going up, likely to end up in finding the
repository of the superproject. In some codepaths, this will cause
a command run with the "--recurse-submodules" option to recurse
forever.
By exporting GIT_DIR=.git, disable the auto-discovery logic in the
subprocess, which would instead stop it and report an error.
The test illustrates existing problems in a few callsites of this
function. Without this fix, "git fetch --recurse-submodules", "git
status" and "git diff" keep recursing forever.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-09-01 20:51:48 +00:00
|
|
|
|
|
|
|
# NOTE: without the fix the following tests will recurse forever!
|
|
|
|
# They should terminate with an error.
|
|
|
|
|
|
|
|
test_must_fail git -C dst status &&
|
|
|
|
test_must_fail git -C dst diff &&
|
|
|
|
test_must_fail git -C dst fetch --recurse-submodules
|
|
|
|
'
|
|
|
|
|
2017-10-16 13:58:27 +00:00
|
|
|
test_expect_success "fetch new commits when submodule got renamed" '
|
|
|
|
git clone . downstream_rename &&
|
|
|
|
(
|
|
|
|
cd downstream_rename &&
|
2018-06-14 17:37:30 +00:00
|
|
|
git submodule update --init --recursive &&
|
2017-10-16 13:58:27 +00:00
|
|
|
git checkout -b rename &&
|
|
|
|
git mv submodule submodule_renamed &&
|
|
|
|
(
|
|
|
|
cd submodule_renamed &&
|
|
|
|
git checkout -b rename_sub &&
|
|
|
|
echo a >a &&
|
|
|
|
git add a &&
|
|
|
|
git commit -ma &&
|
|
|
|
git push origin rename_sub &&
|
|
|
|
git rev-parse HEAD >../../expect
|
|
|
|
) &&
|
|
|
|
git add submodule_renamed &&
|
|
|
|
git commit -m "update renamed submodule" &&
|
|
|
|
git push origin rename
|
|
|
|
) &&
|
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch --recurse-submodules=on-demand &&
|
|
|
|
(
|
|
|
|
cd submodule &&
|
|
|
|
git rev-parse origin/rename_sub >../../actual
|
|
|
|
)
|
|
|
|
) &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2018-12-06 21:26:55 +00:00
|
|
|
test_expect_success "fetch new submodule commits on-demand outside standard refspec" '
|
|
|
|
# add a second submodule and ensure it is around in downstream first
|
|
|
|
git clone submodule sub1 &&
|
|
|
|
git submodule add ./sub1 &&
|
|
|
|
git commit -m "adding a second submodule" &&
|
|
|
|
git -C downstream pull &&
|
|
|
|
git -C downstream submodule update --init --recursive &&
|
|
|
|
|
|
|
|
git checkout --detach &&
|
|
|
|
|
|
|
|
C=$(git -C submodule commit-tree -m "new change outside refs/heads" HEAD^{tree}) &&
|
|
|
|
git -C submodule update-ref refs/changes/1 $C &&
|
|
|
|
git update-index --cacheinfo 160000 $C submodule &&
|
|
|
|
test_tick &&
|
|
|
|
|
|
|
|
D=$(git -C sub1 commit-tree -m "new change outside refs/heads" HEAD^{tree}) &&
|
|
|
|
git -C sub1 update-ref refs/changes/2 $D &&
|
|
|
|
git update-index --cacheinfo 160000 $D sub1 &&
|
|
|
|
|
|
|
|
git commit -m "updated submodules outside of refs/heads" &&
|
|
|
|
E=$(git rev-parse HEAD) &&
|
|
|
|
git update-ref refs/changes/3 $E &&
|
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch --recurse-submodules origin refs/changes/3:refs/heads/my_branch &&
|
|
|
|
git -C submodule cat-file -t $C &&
|
|
|
|
git -C sub1 cat-file -t $D &&
|
|
|
|
git checkout --recurse-submodules FETCH_HEAD
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'fetch new submodule commit on-demand in FETCH_HEAD' '
|
|
|
|
# depends on the previous test for setup
|
|
|
|
|
|
|
|
C=$(git -C submodule commit-tree -m "another change outside refs/heads" HEAD^{tree}) &&
|
|
|
|
git -C submodule update-ref refs/changes/4 $C &&
|
|
|
|
git update-index --cacheinfo 160000 $C submodule &&
|
|
|
|
test_tick &&
|
|
|
|
|
|
|
|
D=$(git -C sub1 commit-tree -m "another change outside refs/heads" HEAD^{tree}) &&
|
|
|
|
git -C sub1 update-ref refs/changes/5 $D &&
|
|
|
|
git update-index --cacheinfo 160000 $D sub1 &&
|
|
|
|
|
|
|
|
git commit -m "updated submodules outside of refs/heads" &&
|
|
|
|
E=$(git rev-parse HEAD) &&
|
|
|
|
git update-ref refs/changes/6 $E &&
|
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch --recurse-submodules origin refs/changes/6 &&
|
|
|
|
git -C submodule cat-file -t $C &&
|
|
|
|
git -C sub1 cat-file -t $D &&
|
|
|
|
git checkout --recurse-submodules FETCH_HEAD
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'fetch new submodule commits on-demand without .gitmodules entry' '
|
|
|
|
# depends on the previous test for setup
|
|
|
|
|
|
|
|
git config -f .gitmodules --remove-section submodule.sub1 &&
|
|
|
|
git add .gitmodules &&
|
|
|
|
git commit -m "delete gitmodules file" &&
|
2020-12-04 14:34:21 +00:00
|
|
|
git checkout -B super &&
|
2018-12-06 21:26:55 +00:00
|
|
|
git -C downstream fetch &&
|
2020-12-04 14:34:21 +00:00
|
|
|
git -C downstream checkout origin/super &&
|
2018-12-06 21:26:55 +00:00
|
|
|
|
|
|
|
C=$(git -C submodule commit-tree -m "yet another change outside refs/heads" HEAD^{tree}) &&
|
|
|
|
git -C submodule update-ref refs/changes/7 $C &&
|
|
|
|
git update-index --cacheinfo 160000 $C submodule &&
|
|
|
|
test_tick &&
|
|
|
|
|
|
|
|
D=$(git -C sub1 commit-tree -m "yet another change outside refs/heads" HEAD^{tree}) &&
|
|
|
|
git -C sub1 update-ref refs/changes/8 $D &&
|
|
|
|
git update-index --cacheinfo 160000 $D sub1 &&
|
|
|
|
|
|
|
|
git commit -m "updated submodules outside of refs/heads" &&
|
|
|
|
E=$(git rev-parse HEAD) &&
|
|
|
|
git update-ref refs/changes/9 $E &&
|
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch --recurse-submodules origin refs/changes/9 &&
|
|
|
|
git -C submodule cat-file -t $C &&
|
|
|
|
git -C sub1 cat-file -t $D &&
|
|
|
|
git checkout --recurse-submodules FETCH_HEAD
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'fetch new submodule commit intermittently referenced by superproject' '
|
|
|
|
# depends on the previous test for setup
|
|
|
|
|
|
|
|
D=$(git -C sub1 commit-tree -m "change 10 outside refs/heads" HEAD^{tree}) &&
|
|
|
|
E=$(git -C sub1 commit-tree -m "change 11 outside refs/heads" HEAD^{tree}) &&
|
|
|
|
F=$(git -C sub1 commit-tree -m "change 12 outside refs/heads" HEAD^{tree}) &&
|
|
|
|
|
|
|
|
git -C sub1 update-ref refs/changes/10 $D &&
|
|
|
|
git update-index --cacheinfo 160000 $D sub1 &&
|
|
|
|
git commit -m "updated submodules outside of refs/heads" &&
|
|
|
|
|
|
|
|
git -C sub1 update-ref refs/changes/11 $E &&
|
|
|
|
git update-index --cacheinfo 160000 $E sub1 &&
|
|
|
|
git commit -m "updated submodules outside of refs/heads" &&
|
|
|
|
|
|
|
|
git -C sub1 update-ref refs/changes/12 $F &&
|
|
|
|
git update-index --cacheinfo 160000 $F sub1 &&
|
|
|
|
git commit -m "updated submodules outside of refs/heads" &&
|
|
|
|
|
|
|
|
G=$(git rev-parse HEAD) &&
|
|
|
|
git update-ref refs/changes/13 $G &&
|
|
|
|
(
|
|
|
|
cd downstream &&
|
|
|
|
git fetch --recurse-submodules origin refs/changes/13 &&
|
|
|
|
|
|
|
|
git -C sub1 cat-file -t $D &&
|
|
|
|
git -C sub1 cat-file -t $E &&
|
|
|
|
git -C sub1 cat-file -t $F
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
submodules: fix of regression on fetching of non-init subsub-repo
A regression has been introduced by a62387b (submodule.c: fetch in
submodules git directory instead of in worktree, 2018-11-28).
The scenario in which it triggers is when one has a repository with a
submodule inside a submodule like this:
superproject/middle_repo/inner_repo
Person A and B have both a clone of it, while Person B is not working
with the inner_repo and thus does not have it initialized in his working
copy.
Now person A introduces a change to the inner_repo and propagates it
through the middle_repo and the superproject.
Once person A pushed the changes and person B wants to fetch them using
"git fetch" at the superproject level, B's git call will return with
error saying:
Could not access submodule 'inner_repo'
Errors during submodule fetch:
middle_repo
Expectation is that in this case the inner submodule will be recognized
as uninitialized submodule and skipped by the git fetch command.
This used to work correctly before 'a62387b (submodule.c: fetch in
submodules git directory instead of in worktree, 2018-11-28)'.
Starting with a62387b the code wants to evaluate "is_empty_dir()" inside
.git/modules for a directory only existing in the worktree, delivering
then of course wrong return value.
This patch ensures is_empty_dir() is getting the correct path of the
uninitialized submodule by concatenation of the actual worktree and the
name of the uninitialized submodule.
The first attempt to fix this regression, in 1b7ac4e6d4 (submodules:
fix of regression on fetching of non-init subsub-repo, 2020-11-12), by
simply reverting a62387b, resulted in an infinite loop of submodule
fetches in the simpler case of a recursive fetch of a superproject with
uninitialized submodules, and so this commit was reverted in 7091499bc0
(Revert "submodules: fix of regression on fetching of non-init
subsub-repo", 2020-12-02).
To prevent future breakages, also add a regression test for this
scenario.
Signed-off-by: Peter Kaestle <peter.kaestle@nokia.com>
CC: Junio C Hamano <gitster@pobox.com>
CC: Philippe Blain <levraiphilippeblain@gmail.com>
CC: Ralf Thielow <ralf.thielow@gmail.com>
CC: Eric Sunshine <sunshine@sunshineco.us>
Reviewed-by: Philippe Blain <levraiphilippeblain@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-12-09 10:58:44 +00:00
|
|
|
add_commit_push () {
|
|
|
|
dir="$1" &&
|
|
|
|
msg="$2" &&
|
|
|
|
shift 2 &&
|
|
|
|
git -C "$dir" add "$@" &&
|
|
|
|
git -C "$dir" commit -a -m "$msg" &&
|
|
|
|
git -C "$dir" push
|
|
|
|
}
|
|
|
|
|
|
|
|
compare_refs_in_dir () {
|
|
|
|
fail= &&
|
|
|
|
if test "x$1" = 'x!'
|
|
|
|
then
|
|
|
|
fail='!' &&
|
|
|
|
shift
|
|
|
|
fi &&
|
|
|
|
git -C "$1" rev-parse --verify "$2" >expect &&
|
|
|
|
git -C "$3" rev-parse --verify "$4" >actual &&
|
|
|
|
eval $fail test_cmp expect actual
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
test_expect_success 'setup nested submodule fetch test' '
|
|
|
|
# does not depend on any previous test setups
|
|
|
|
|
|
|
|
for repo in outer middle inner
|
|
|
|
do
|
|
|
|
git init --bare $repo &&
|
|
|
|
git clone $repo ${repo}_content &&
|
|
|
|
echo "$repo" >"${repo}_content/file" &&
|
|
|
|
add_commit_push ${repo}_content "initial" file ||
|
|
|
|
return 1
|
|
|
|
done &&
|
|
|
|
|
|
|
|
git clone outer A &&
|
|
|
|
git -C A submodule add "$pwd/middle" &&
|
|
|
|
git -C A/middle/ submodule add "$pwd/inner" &&
|
|
|
|
add_commit_push A/middle/ "adding inner sub" .gitmodules inner &&
|
|
|
|
add_commit_push A/ "adding middle sub" .gitmodules middle &&
|
|
|
|
|
|
|
|
git clone outer B &&
|
|
|
|
git -C B/ submodule update --init middle &&
|
|
|
|
|
|
|
|
compare_refs_in_dir A HEAD B HEAD &&
|
|
|
|
compare_refs_in_dir A/middle HEAD B/middle HEAD &&
|
|
|
|
test_path_is_file B/file &&
|
|
|
|
test_path_is_file B/middle/file &&
|
|
|
|
test_path_is_missing B/middle/inner/file &&
|
|
|
|
|
|
|
|
echo "change on inner repo of A" >"A/middle/inner/file" &&
|
|
|
|
add_commit_push A/middle/inner "change on inner" file &&
|
|
|
|
add_commit_push A/middle "change on inner" inner &&
|
|
|
|
add_commit_push A "change on inner" middle
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'fetching a superproject containing an uninitialized sub/sub project' '
|
|
|
|
# depends on previous test for setup
|
|
|
|
|
|
|
|
git -C B/ fetch &&
|
|
|
|
compare_refs_in_dir A origin/HEAD B origin/HEAD
|
|
|
|
'
|
|
|
|
|
|
|
|
fetch_with_recursion_abort () {
|
|
|
|
# In a regression the following git call will run into infinite recursion.
|
|
|
|
# To handle that, we connect the sed command to the git call by a pipe
|
|
|
|
# so that sed can kill the infinite recursion when detected.
|
|
|
|
# The recursion creates git output like:
|
|
|
|
# Fetching submodule sub
|
|
|
|
# Fetching submodule sub/sub <-- [1]
|
|
|
|
# Fetching submodule sub/sub/sub
|
|
|
|
# ...
|
|
|
|
# [1] sed will stop reading and cause git to eventually stop and die
|
|
|
|
|
|
|
|
git -C "$1" fetch --recurse-submodules 2>&1 |
|
|
|
|
sed "/Fetching submodule $2[^$]/q" >out &&
|
|
|
|
! grep "Fetching submodule $2[^$]" out
|
|
|
|
}
|
|
|
|
|
|
|
|
test_expect_success 'setup recursive fetch with uninit submodule' '
|
|
|
|
# does not depend on any previous test setups
|
|
|
|
|
|
|
|
test_create_repo super &&
|
|
|
|
test_commit -C super initial &&
|
|
|
|
test_create_repo sub &&
|
|
|
|
test_commit -C sub initial &&
|
|
|
|
git -C sub rev-parse HEAD >expect &&
|
|
|
|
|
|
|
|
git -C super submodule add ../sub &&
|
|
|
|
git -C super commit -m "add sub" &&
|
|
|
|
|
|
|
|
git clone super superclone &&
|
|
|
|
git -C superclone submodule status >out &&
|
|
|
|
sed -e "s/^-//" -e "s/ sub.*$//" out >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'recursive fetch with uninit submodule' '
|
|
|
|
# depends on previous test for setup
|
|
|
|
|
|
|
|
fetch_with_recursion_abort superclone sub &&
|
|
|
|
git -C superclone submodule status >out &&
|
|
|
|
sed -e "s/^-//" -e "s/ sub$//" out >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'recursive fetch after deinit a submodule' '
|
|
|
|
# depends on previous test for setup
|
|
|
|
|
|
|
|
git -C superclone submodule update --init sub &&
|
|
|
|
git -C superclone submodule deinit -f sub &&
|
|
|
|
|
|
|
|
fetch_with_recursion_abort superclone sub &&
|
|
|
|
git -C superclone submodule status >out &&
|
|
|
|
sed -e "s/^-//" -e "s/ sub$//" out >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2022-03-08 00:14:32 +00:00
|
|
|
test_expect_success 'setup repo with upstreams that share a submodule name' '
|
|
|
|
mkdir same-name-1 &&
|
|
|
|
(
|
|
|
|
cd same-name-1 &&
|
|
|
|
git init -b main &&
|
|
|
|
test_commit --no-tag a
|
|
|
|
) &&
|
|
|
|
git clone same-name-1 same-name-2 &&
|
|
|
|
# same-name-1 and same-name-2 both add a submodule with the
|
|
|
|
# name "submodule"
|
|
|
|
(
|
|
|
|
cd same-name-1 &&
|
|
|
|
mkdir submodule &&
|
|
|
|
git -C submodule init -b main &&
|
|
|
|
test_commit -C submodule --no-tag a1 &&
|
|
|
|
git submodule add "$pwd/same-name-1/submodule" &&
|
|
|
|
git add submodule &&
|
|
|
|
git commit -m "super-a1"
|
|
|
|
) &&
|
|
|
|
(
|
|
|
|
cd same-name-2 &&
|
|
|
|
mkdir submodule &&
|
|
|
|
git -C submodule init -b main &&
|
|
|
|
test_commit -C submodule --no-tag a2 &&
|
|
|
|
git submodule add "$pwd/same-name-2/submodule" &&
|
|
|
|
git add submodule &&
|
|
|
|
git commit -m "super-a2"
|
|
|
|
) &&
|
|
|
|
git clone same-name-1 -o same-name-1 same-name-downstream &&
|
|
|
|
(
|
|
|
|
cd same-name-downstream &&
|
|
|
|
git remote add same-name-2 ../same-name-2 &&
|
|
|
|
git fetch --all &&
|
|
|
|
# init downstream with same-name-1
|
|
|
|
git submodule update --init
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'fetch --recurse-submodules updates name-conflicted, populated submodule' '
|
|
|
|
test_when_finished "git -C same-name-downstream checkout main" &&
|
|
|
|
(
|
|
|
|
cd same-name-1 &&
|
|
|
|
test_commit -C submodule --no-tag b1 &&
|
|
|
|
git add submodule &&
|
|
|
|
git commit -m "super-b1"
|
|
|
|
) &&
|
|
|
|
(
|
|
|
|
cd same-name-2 &&
|
|
|
|
test_commit -C submodule --no-tag b2 &&
|
|
|
|
git add submodule &&
|
|
|
|
git commit -m "super-b2"
|
|
|
|
) &&
|
|
|
|
(
|
|
|
|
cd same-name-downstream &&
|
|
|
|
# even though the .gitmodules is correct, we cannot
|
|
|
|
# fetch from same-name-2
|
|
|
|
git checkout same-name-2/main &&
|
|
|
|
git fetch --recurse-submodules same-name-1 &&
|
|
|
|
test_must_fail git fetch --recurse-submodules same-name-2
|
|
|
|
) &&
|
|
|
|
super_head1=$(git -C same-name-1 rev-parse HEAD) &&
|
|
|
|
git -C same-name-downstream cat-file -e $super_head1 &&
|
|
|
|
|
|
|
|
super_head2=$(git -C same-name-2 rev-parse HEAD) &&
|
|
|
|
git -C same-name-downstream cat-file -e $super_head2 &&
|
|
|
|
|
|
|
|
sub_head1=$(git -C same-name-1/submodule rev-parse HEAD) &&
|
|
|
|
git -C same-name-downstream/submodule cat-file -e $sub_head1 &&
|
|
|
|
|
|
|
|
sub_head2=$(git -C same-name-2/submodule rev-parse HEAD) &&
|
|
|
|
test_must_fail git -C same-name-downstream/submodule cat-file -e $sub_head2
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'fetch --recurse-submodules updates name-conflicted, unpopulated submodule' '
|
|
|
|
(
|
|
|
|
cd same-name-1 &&
|
|
|
|
test_commit -C submodule --no-tag c1 &&
|
|
|
|
git add submodule &&
|
|
|
|
git commit -m "super-c1"
|
|
|
|
) &&
|
|
|
|
(
|
|
|
|
cd same-name-2 &&
|
|
|
|
test_commit -C submodule --no-tag c2 &&
|
|
|
|
git add submodule &&
|
|
|
|
git commit -m "super-c2"
|
|
|
|
) &&
|
|
|
|
(
|
|
|
|
cd same-name-downstream &&
|
|
|
|
git checkout main &&
|
|
|
|
git rm .gitmodules &&
|
|
|
|
git rm submodule &&
|
|
|
|
git commit -m "no submodules" &&
|
|
|
|
git fetch --recurse-submodules same-name-1
|
|
|
|
) &&
|
|
|
|
head1=$(git -C same-name-1/submodule rev-parse HEAD) &&
|
|
|
|
head2=$(git -C same-name-2/submodule rev-parse HEAD) &&
|
|
|
|
(
|
|
|
|
cd same-name-downstream/.git/modules/submodule &&
|
|
|
|
# The submodule has core.worktree pointing to the "git
|
|
|
|
# rm"-ed directory, overwrite the invalid value. See
|
|
|
|
# comment in get_fetch_task_from_changed() for more
|
|
|
|
# information.
|
|
|
|
git --work-tree=. cat-file -e $head1 &&
|
|
|
|
test_must_fail git --work-tree=. cat-file -e $head2
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
fetch: do not run a redundant fetch from submodule
When 7dce19d3 (fetch/pull: Add the --recurse-submodules option,
2010-11-12) introduced the "--recurse-submodule" option, the
approach taken was to perform fetches in submodules only once, after
all the main fetching (it may usually be a fetch from a single
remote, but it could be fetching from a group of remotes using
fetch_multiple()) succeeded. Later we added "--all" to fetch from
all defined remotes, which complicated things even more.
If your project has a submodule, and you try to run "git fetch
--recurse-submodule --all", you'd see a fetch for the top-level,
which invokes another fetch for the submodule, followed by another
fetch for the same submodule. All but the last fetch for the
submodule come from a "git fetch --recurse-submodules" subprocess
that is spawned via the fetch_multiple() interface for the remotes,
and the last fetch comes from the code at the end.
Because recursive fetching from submodules is done in each fetch for
the top-level in fetch_multiple(), the last fetch in the submodule
is redundant. It only matters when fetch_one() interacts with a
single remote at the top-level.
While we are at it, there is one optimization that exists in dealing
with a group of remote, but is missing when "--all" is used. In the
former, when the group turns out to be a group of one, instead of
spawning "git fetch" as a subprocess via the fetch_multiple()
interface, we use the normal fetch_one() code path. Do the same
when handing "--all", if it turns out that we have only one remote
defined.
Reviewed-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-05-16 23:53:40 +00:00
|
|
|
test_expect_success 'fetch --all with --recurse-submodules' '
|
|
|
|
test_when_finished "rm -fr src_clone" &&
|
|
|
|
git clone --recurse-submodules src src_clone &&
|
|
|
|
(
|
|
|
|
cd src_clone &&
|
|
|
|
git config submodule.recurse true &&
|
|
|
|
git config fetch.parallel 0 &&
|
|
|
|
git fetch --all 2>../fetch-log
|
|
|
|
) &&
|
|
|
|
grep "^Fetching submodule sub$" fetch-log >fetch-subs &&
|
|
|
|
test_line_count = 1 fetch-subs
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'fetch --all with --recurse-submodules with multiple' '
|
|
|
|
test_when_finished "rm -fr src_clone" &&
|
|
|
|
git clone --recurse-submodules src src_clone &&
|
|
|
|
(
|
|
|
|
cd src_clone &&
|
|
|
|
git remote add secondary ../src &&
|
|
|
|
git config submodule.recurse true &&
|
|
|
|
git config fetch.parallel 0 &&
|
|
|
|
git fetch --all 2>../fetch-log
|
|
|
|
) &&
|
|
|
|
grep "Fetching submodule sub" fetch-log >fetch-subs &&
|
|
|
|
test_line_count = 2 fetch-subs
|
|
|
|
'
|
|
|
|
|
2023-05-10 12:34:02 +00:00
|
|
|
test_expect_success "fetch --all with --no-recurse-submodules only fetches superproject" '
|
|
|
|
test_when_finished "rm -rf src_clone" &&
|
|
|
|
|
|
|
|
git clone --recurse-submodules src src_clone &&
|
|
|
|
(
|
|
|
|
cd src_clone &&
|
|
|
|
git remote add secondary ../src &&
|
|
|
|
git config submodule.recurse true &&
|
|
|
|
git fetch --all --no-recurse-submodules 2>../fetch-log
|
|
|
|
) &&
|
|
|
|
! grep "Fetching submodule" fetch-log
|
|
|
|
'
|
|
|
|
|
2010-11-12 12:54:52 +00:00
|
|
|
test_done
|