2007-06-02 01:27:42 +00:00
|
|
|
#!/bin/sh
|
|
|
|
#
|
|
|
|
# Copyright (c) 2007 Lars Hjemli
|
|
|
|
#
|
|
|
|
|
|
|
|
test_description='Basic porcelain support for submodules
|
|
|
|
|
|
|
|
This test tries to verify basic sanity of the init, update and status
|
2008-09-03 08:59:33 +00:00
|
|
|
subcommands of git submodule.
|
2007-06-02 01:27:42 +00:00
|
|
|
'
|
|
|
|
|
2020-11-18 23:44:39 +00:00
|
|
|
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main
|
tests: mark tests relying on the current default for `init.defaultBranch`
In addition to the manual adjustment to let the `linux-gcc` CI job run
the test suite with `master` and then with `main`, this patch makes sure
that GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME is set in all test scripts
that currently rely on the initial branch name being `master by default.
To determine which test scripts to mark up, the first step was to
force-set the default branch name to `master` in
- all test scripts that contain the keyword `master`,
- t4211, which expects `t/t4211/history.export` with a hard-coded ref to
initialize the default branch,
- t5560 because it sources `t/t556x_common` which uses `master`,
- t8002 and t8012 because both source `t/annotate-tests.sh` which also
uses `master`)
This trick was performed by this command:
$ sed -i '/^ *\. \.\/\(test-lib\|lib-\(bash\|cvs\|git-svn\)\|gitweb-lib\)\.sh$/i\
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=master\
export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME\
' $(git grep -l master t/t[0-9]*.sh) \
t/t4211*.sh t/t5560*.sh t/t8002*.sh t/t8012*.sh
After that, careful, manual inspection revealed that some of the test
scripts containing the needle `master` do not actually rely on a
specific default branch name: either they mention `master` only in a
comment, or they initialize that branch specificially, or they do not
actually refer to the current default branch. Therefore, the
aforementioned modification was undone in those test scripts thusly:
$ git checkout HEAD -- \
t/t0027-auto-crlf.sh t/t0060-path-utils.sh \
t/t1011-read-tree-sparse-checkout.sh \
t/t1305-config-include.sh t/t1309-early-config.sh \
t/t1402-check-ref-format.sh t/t1450-fsck.sh \
t/t2024-checkout-dwim.sh \
t/t2106-update-index-assume-unchanged.sh \
t/t3040-subprojects-basic.sh t/t3301-notes.sh \
t/t3308-notes-merge.sh t/t3423-rebase-reword.sh \
t/t3436-rebase-more-options.sh \
t/t4015-diff-whitespace.sh t/t4257-am-interactive.sh \
t/t5323-pack-redundant.sh t/t5401-update-hooks.sh \
t/t5511-refspec.sh t/t5526-fetch-submodules.sh \
t/t5529-push-errors.sh t/t5530-upload-pack-error.sh \
t/t5548-push-porcelain.sh \
t/t5552-skipping-fetch-negotiator.sh \
t/t5572-pull-submodule.sh t/t5608-clone-2gb.sh \
t/t5614-clone-submodules-shallow.sh \
t/t7508-status.sh t/t7606-merge-custom.sh \
t/t9302-fast-import-unpack-limit.sh
We excluded one set of test scripts in these commands, though: the range
of `git p4` tests. The reason? `git p4` stores the (foreign) remote
branch in the branch called `p4/master`, which is obviously not the
default branch. Manual analysis revealed that only five of these tests
actually require a specific default branch name to pass; They were
modified thusly:
$ sed -i '/^ *\. \.\/lib-git-p4\.sh$/i\
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=master\
export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME\
' t/t980[0167]*.sh t/t9811*.sh
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-11-18 23:44:19 +00:00
|
|
|
export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME
|
|
|
|
|
2007-06-02 01:27:42 +00:00
|
|
|
. ./test-lib.sh
|
|
|
|
|
2022-07-29 19:21:40 +00:00
|
|
|
test_expect_success 'setup - enable local submodules' '
|
|
|
|
git config --global protocol.file.allow always
|
|
|
|
'
|
|
|
|
|
submodule tests: test usage behavior
Test what exit code and output we emit on "git submodule -h", how we
handle "--" when no subcommand is specified, and how the top-level
"--recursive" option is handled.
For "-h" this doesn't make sense, but let's test for it so that any
subsequent eventual behavior change will become clear.
For "--" this follows up on 68cabbfda36 (submodule: document default
behavior, 2019-02-15) and tests that "status" doesn't support
the "--" delimiter. There's no intrinsically good reason not to
support that. We behave this way due to edge cases in
git-submodule.sh's implementation, but as with "-h" let's assert our
current long-standing behavior for now.
For "--recursive" the exclusion of it from the top-level appears to
have been an omission in 15fc56a8536 (git submodule foreach: Add
--recursive to recurse into nested submodules, 2009-08-19), there
doesn't seem to be a reason not to support it alongside "--quiet" and
"--cached", but let's likewise assert our existing behavior for now.
I.e. as long as "status" is optional it would make sense to support
all of its options when it's omitted, but we only do that with
"--quiet" and "--cached", and curiously omit "--recursive".
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Reviewed-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-08-31 23:17:43 +00:00
|
|
|
test_expect_success 'submodule usage: -h' '
|
|
|
|
git submodule -h >out 2>err &&
|
|
|
|
grep "^usage: git submodule" out &&
|
|
|
|
test_must_be_empty err
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'submodule usage: --recursive' '
|
|
|
|
test_expect_code 1 git submodule --recursive >out 2>err &&
|
|
|
|
grep "^usage: git submodule" err &&
|
|
|
|
test_must_be_empty out
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'submodule usage: status --' '
|
|
|
|
test_expect_code 1 git submodule -- &&
|
|
|
|
test_expect_code 1 git submodule --end-of-options
|
|
|
|
'
|
|
|
|
|
|
|
|
for opt in '--quiet' '--cached'
|
|
|
|
do
|
|
|
|
test_expect_success "submodule usage: status $opt" '
|
|
|
|
git submodule $opt &&
|
|
|
|
git submodule status $opt &&
|
|
|
|
git submodule $opt status
|
|
|
|
'
|
|
|
|
done
|
|
|
|
|
2016-05-05 19:52:32 +00:00
|
|
|
test_expect_success 'submodule deinit works on empty repository' '
|
|
|
|
git submodule deinit --all
|
|
|
|
'
|
|
|
|
|
2010-04-10 05:38:37 +00:00
|
|
|
test_expect_success 'setup - initial commit' '
|
|
|
|
>t &&
|
2008-09-03 08:59:33 +00:00
|
|
|
git add t &&
|
|
|
|
git commit -m "initial commit" &&
|
2010-04-10 05:38:37 +00:00
|
|
|
git branch initial
|
|
|
|
'
|
|
|
|
|
2016-04-28 20:02:45 +00:00
|
|
|
test_expect_success 'submodule init aborts on missing .gitmodules file' '
|
|
|
|
test_when_finished "git update-index --remove sub" &&
|
|
|
|
git update-index --add --cacheinfo 160000,$(git rev-parse HEAD),sub &&
|
|
|
|
# missing the .gitmodules file here
|
|
|
|
test_must_fail git submodule init 2>actual &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "No url found for submodule path" actual
|
2016-04-28 20:02:45 +00:00
|
|
|
'
|
|
|
|
|
2016-04-28 20:02:46 +00:00
|
|
|
test_expect_success 'submodule update aborts on missing .gitmodules file' '
|
|
|
|
test_when_finished "git update-index --remove sub" &&
|
|
|
|
git update-index --add --cacheinfo 160000,$(git rev-parse HEAD),sub &&
|
|
|
|
# missing the .gitmodules file here
|
|
|
|
git submodule update sub 2>actual &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "Submodule path .sub. not initialized" actual
|
2016-04-28 20:02:46 +00:00
|
|
|
'
|
|
|
|
|
2017-04-25 00:57:47 +00:00
|
|
|
test_expect_success 'submodule update aborts on missing gitmodules url' '
|
|
|
|
test_when_finished "git update-index --remove sub" &&
|
|
|
|
git update-index --add --cacheinfo 160000,$(git rev-parse HEAD),sub &&
|
|
|
|
test_when_finished "rm -f .gitmodules" &&
|
|
|
|
git config -f .gitmodules submodule.s.path sub &&
|
|
|
|
test_must_fail git submodule init
|
|
|
|
'
|
|
|
|
|
2019-04-09 23:07:35 +00:00
|
|
|
test_expect_success 'add aborts on repository with no commits' '
|
|
|
|
cat >expect <<-\EOF &&
|
2021-07-10 07:47:59 +00:00
|
|
|
fatal: '"'repo-no-commits'"' does not have a commit checked out
|
2019-04-09 23:07:35 +00:00
|
|
|
EOF
|
|
|
|
git init repo-no-commits &&
|
|
|
|
test_must_fail git submodule add ../a ./repo-no-commits 2>actual &&
|
2021-02-11 01:53:53 +00:00
|
|
|
test_cmp expect actual
|
2019-04-09 23:07:35 +00:00
|
|
|
'
|
|
|
|
|
2020-02-02 23:32:44 +00:00
|
|
|
test_expect_success 'status should ignore inner git repo when not added' '
|
|
|
|
rm -fr inner &&
|
|
|
|
mkdir inner &&
|
|
|
|
(
|
|
|
|
cd inner &&
|
|
|
|
git init &&
|
|
|
|
>t &&
|
|
|
|
git add t &&
|
|
|
|
git commit -m "initial"
|
|
|
|
) &&
|
|
|
|
test_must_fail git submodule status inner 2>output.err &&
|
|
|
|
rm -fr inner &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "^error: .*did not match any file(s) known to git" output.err
|
2020-02-02 23:32:44 +00:00
|
|
|
'
|
|
|
|
|
2010-04-10 05:38:37 +00:00
|
|
|
test_expect_success 'setup - repository in init subdirectory' '
|
2008-01-15 11:13:55 +00:00
|
|
|
mkdir init &&
|
2010-04-10 05:38:37 +00:00
|
|
|
(
|
|
|
|
cd init &&
|
|
|
|
git init &&
|
|
|
|
echo a >a &&
|
|
|
|
git add a &&
|
|
|
|
git commit -m "submodule commit 1" &&
|
|
|
|
git tag -a -m "rev-1" rev-1
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'setup - commit with gitlink' '
|
2007-06-02 01:27:42 +00:00
|
|
|
echo a >a &&
|
|
|
|
echo z >z &&
|
2008-01-15 11:13:55 +00:00
|
|
|
git add a init z &&
|
2010-04-10 05:38:37 +00:00
|
|
|
git commit -m "super commit 1"
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'setup - hide init subdirectory' '
|
|
|
|
mv init .subrepo
|
|
|
|
'
|
|
|
|
|
2010-04-10 05:39:04 +00:00
|
|
|
test_expect_success 'setup - repository to add submodules to' '
|
2010-07-05 17:33:03 +00:00
|
|
|
git init addtest &&
|
|
|
|
git init addtest-ignore
|
2010-04-10 05:39:04 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
# The 'submodule add' tests need some repository to add as a submodule.
|
2011-07-30 15:05:54 +00:00
|
|
|
# The trash directory is a good one as any. We need to canonicalize
|
|
|
|
# the name, though, as some tests compare it to the absolute path git
|
|
|
|
# generates, which will expand symbolic links.
|
|
|
|
submodurl=$(pwd -P)
|
2010-04-10 05:39:04 +00:00
|
|
|
|
|
|
|
listbranches() {
|
|
|
|
git for-each-ref --format='%(refname)' 'refs/heads/*'
|
|
|
|
}
|
|
|
|
|
|
|
|
inspect() {
|
|
|
|
dir=$1 &&
|
|
|
|
dotdot="${2:-..}" &&
|
|
|
|
|
2009-03-03 15:08:20 +00:00
|
|
|
(
|
2010-04-10 05:39:04 +00:00
|
|
|
cd "$dir" &&
|
|
|
|
listbranches >"$dotdot/heads" &&
|
|
|
|
{ git symbolic-ref HEAD || :; } >"$dotdot/head" &&
|
2010-04-10 05:39:41 +00:00
|
|
|
git rev-parse HEAD >"$dotdot/head-sha1" &&
|
2010-04-10 05:39:04 +00:00
|
|
|
git update-index --refresh &&
|
|
|
|
git diff-files --exit-code &&
|
|
|
|
git clean -n -d -x >"$dotdot/untracked"
|
2009-03-03 15:08:20 +00:00
|
|
|
)
|
2010-04-10 05:39:04 +00:00
|
|
|
}
|
2009-03-03 15:08:20 +00:00
|
|
|
|
|
|
|
test_expect_success 'submodule add' '
|
2020-11-18 23:44:39 +00:00
|
|
|
echo "refs/heads/main" >expect &&
|
2010-04-10 05:39:04 +00:00
|
|
|
|
2009-03-03 15:08:20 +00:00
|
|
|
(
|
|
|
|
cd addtest &&
|
2011-07-26 21:39:03 +00:00
|
|
|
git submodule add -q "$submodurl" submod >actual &&
|
2013-06-09 18:29:20 +00:00
|
|
|
test_must_be_empty actual &&
|
2012-03-04 21:14:30 +00:00
|
|
|
echo "gitdir: ../.git/modules/submod" >expect &&
|
|
|
|
test_cmp expect submod/.git &&
|
2012-03-04 21:15:08 +00:00
|
|
|
(
|
|
|
|
cd submod &&
|
|
|
|
git config core.worktree >actual &&
|
|
|
|
echo "../../../submod" >expect &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
rm -f actual expect
|
|
|
|
) &&
|
2009-03-03 15:08:20 +00:00
|
|
|
git submodule init
|
2010-04-10 05:39:04 +00:00
|
|
|
) &&
|
|
|
|
|
|
|
|
rm -f heads head untracked &&
|
|
|
|
inspect addtest/submod ../.. &&
|
|
|
|
test_cmp expect heads &&
|
|
|
|
test_cmp expect head &&
|
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 untracked
|
2009-03-03 15:08:20 +00:00
|
|
|
'
|
|
|
|
|
2022-08-31 23:17:44 +00:00
|
|
|
test_expect_success !WINDOWS 'submodule add (absolute path)' '
|
|
|
|
test_when_finished "git reset --hard" &&
|
|
|
|
git submodule add "$submodurl" "$submodurl/add-abs"
|
|
|
|
'
|
|
|
|
|
2018-06-18 23:41:48 +00:00
|
|
|
test_expect_success 'setup parent and one repository' '
|
|
|
|
test_create_repo parent &&
|
|
|
|
test_commit -C parent one
|
|
|
|
'
|
2018-05-03 10:53:45 +00:00
|
|
|
|
|
|
|
test_expect_success 'redirected submodule add does not show progress' '
|
|
|
|
git -C addtest submodule add "file://$submodurl/parent" submod-redirected \
|
|
|
|
2>err &&
|
|
|
|
! grep % err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep ! "Checking connectivity" err
|
2018-05-03 10:53:45 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'redirected submodule add --progress does show progress' '
|
|
|
|
git -C addtest submodule add --progress "file://$submodurl/parent" \
|
|
|
|
submod-redirected-progress 2>err && \
|
|
|
|
grep % err
|
|
|
|
'
|
|
|
|
|
2010-07-17 15:11:43 +00:00
|
|
|
test_expect_success 'submodule add to .gitignored path fails' '
|
2010-07-05 17:33:03 +00:00
|
|
|
(
|
|
|
|
cd addtest-ignore &&
|
2010-07-17 15:11:43 +00:00
|
|
|
cat <<-\EOF >expect &&
|
submodule add: show 'add --dry-run' stderr when aborting
Unless --force is specified, 'submodule add' checks if the destination
path is ignored by calling 'git add --dry-run --ignore-missing', and,
if that call fails, aborts with a custom "path is ignored" message (a
slight variant of what 'git add' shows). Aborting early rather than
letting the downstream 'git add' call fail is done so that the command
exits before cloning into the destination path. However, in rare
cases where the dry-run call fails for a reason other than the path
being ignored---for example, due to a preexisting index.lock
file---displaying the "ignored path" error message hides the real
source of the failure.
Instead of displaying the tailored "ignored path" message, let's
report the standard error from the dry run to give the caller more
accurate information about failures that are not due to an ignored
path.
For the ignored path case, this leads to the following change in the
error message:
The following [-path is-]{+paths are+} ignored by one of your .gitignore files:
<destination path>
Use -f if you really want to add [-it.-]{+them.+}
The new phrasing is a bit awkward, because 'submodule add' is only
dealing with one destination path. Alternatively, we could continue
to use the tailored message when the exit code is 1 (the expected
status for a failure due to an ignored path) and relay the standard
error for all other non-zero exits. That, however, risks hiding the
message of unrelated failures that share an exit code of 1, so it
doesn't seem worth doing just to avoid a clunkier, but still clear,
error message.
Signed-off-by: Kyle Meyer <kyle@kyleam.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-01-08 00:31:21 +00:00
|
|
|
The following paths are ignored by one of your .gitignore files:
|
2010-07-17 15:11:43 +00:00
|
|
|
submod
|
2020-02-14 20:54:19 +00:00
|
|
|
hint: Use -f if you really want to add them.
|
2024-03-30 14:07:27 +00:00
|
|
|
hint: Disable this message with "git config advice.addIgnoredFile false"
|
2010-07-17 15:11:43 +00:00
|
|
|
EOF
|
2010-07-05 17:33:03 +00:00
|
|
|
# Does not use test_commit due to the ignore
|
|
|
|
echo "*" > .gitignore &&
|
|
|
|
git add --force .gitignore &&
|
|
|
|
git commit -m"Ignore everything" &&
|
2010-07-17 15:11:43 +00:00
|
|
|
! git submodule add "$submodurl" submod >actual 2>&1 &&
|
2021-02-11 01:53:53 +00:00
|
|
|
test_cmp expect actual
|
2010-07-17 15:11:43 +00:00
|
|
|
)
|
|
|
|
'
|
2010-07-05 17:33:03 +00:00
|
|
|
|
2010-07-17 15:11:43 +00:00
|
|
|
test_expect_success 'submodule add to .gitignored path with --force' '
|
|
|
|
(
|
|
|
|
cd addtest-ignore &&
|
|
|
|
git submodule add --force "$submodurl" submod
|
|
|
|
)
|
2010-07-05 17:33:03 +00:00
|
|
|
'
|
|
|
|
|
2021-07-06 18:19:34 +00:00
|
|
|
test_expect_success 'submodule add to path with tracked content fails' '
|
|
|
|
(
|
|
|
|
cd addtest &&
|
2021-07-10 07:47:59 +00:00
|
|
|
echo "fatal: '\''dir-tracked'\'' already exists in the index" >expect &&
|
2021-07-06 18:19:34 +00:00
|
|
|
mkdir dir-tracked &&
|
|
|
|
test_commit foo dir-tracked/bar &&
|
|
|
|
test_must_fail git submodule add "$submodurl" dir-tracked >actual 2>&1 &&
|
|
|
|
test_cmp expect actual
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2016-10-06 19:37:24 +00:00
|
|
|
test_expect_success 'submodule add to reconfigure existing submodule with --force' '
|
|
|
|
(
|
|
|
|
cd addtest-ignore &&
|
t7400: fix broken "submodule add/reconfigure --force" test
This test has been dysfunctional since it was added by 619acfc78c
(submodule add: extend force flag to add existing repos, 2016-10-06),
however, two problems early in the test went unnoticed due to a broken
&&-chain later in the test.
First, it tries configuring the submodule with repository "bogus-url",
however, "git submodule add" insists that the repository be either an
absolute URL or a relative pathname requiring prefix "./" or "../" (this
is true even with --force), but "bogus-url" does not meet those
criteria, thus the command fails.
Second, it then tries configuring a submodule with a path which is
.gitignore'd, which is disallowed. This restriction can be overridden
with --force, but the test neglects to use that option.
Fix both problems, as well as the broken &&-chain behind which they hid.
Reviewed-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Eric Sunshine <sunshine@sunshineco.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-07-02 00:23:51 +00:00
|
|
|
bogus_url="$(pwd)/bogus-url" &&
|
|
|
|
git submodule add --force "$bogus_url" submod &&
|
|
|
|
git submodule add --force -b initial "$submodurl" submod-branch &&
|
|
|
|
test "$bogus_url" = "$(git config -f .gitmodules submodule.submod.url)" &&
|
|
|
|
test "$bogus_url" = "$(git config submodule.submod.url)" &&
|
2016-10-06 19:37:24 +00:00
|
|
|
# Restore the url
|
t7400: fix broken "submodule add/reconfigure --force" test
This test has been dysfunctional since it was added by 619acfc78c
(submodule add: extend force flag to add existing repos, 2016-10-06),
however, two problems early in the test went unnoticed due to a broken
&&-chain later in the test.
First, it tries configuring the submodule with repository "bogus-url",
however, "git submodule add" insists that the repository be either an
absolute URL or a relative pathname requiring prefix "./" or "../" (this
is true even with --force), but "bogus-url" does not meet those
criteria, thus the command fails.
Second, it then tries configuring a submodule with a path which is
.gitignore'd, which is disallowed. This restriction can be overridden
with --force, but the test neglects to use that option.
Fix both problems, as well as the broken &&-chain behind which they hid.
Reviewed-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Eric Sunshine <sunshine@sunshineco.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-07-02 00:23:51 +00:00
|
|
|
git submodule add --force "$submodurl" submod &&
|
2016-10-06 19:37:24 +00:00
|
|
|
test "$submodurl" = "$(git config -f .gitmodules submodule.submod.url)" &&
|
|
|
|
test "$submodurl" = "$(git config submodule.submod.url)"
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
submodule add: show 'add --dry-run' stderr when aborting
Unless --force is specified, 'submodule add' checks if the destination
path is ignored by calling 'git add --dry-run --ignore-missing', and,
if that call fails, aborts with a custom "path is ignored" message (a
slight variant of what 'git add' shows). Aborting early rather than
letting the downstream 'git add' call fail is done so that the command
exits before cloning into the destination path. However, in rare
cases where the dry-run call fails for a reason other than the path
being ignored---for example, due to a preexisting index.lock
file---displaying the "ignored path" error message hides the real
source of the failure.
Instead of displaying the tailored "ignored path" message, let's
report the standard error from the dry run to give the caller more
accurate information about failures that are not due to an ignored
path.
For the ignored path case, this leads to the following change in the
error message:
The following [-path is-]{+paths are+} ignored by one of your .gitignore files:
<destination path>
Use -f if you really want to add [-it.-]{+them.+}
The new phrasing is a bit awkward, because 'submodule add' is only
dealing with one destination path. Alternatively, we could continue
to use the tailored message when the exit code is 1 (the expected
status for a failure due to an ignored path) and relay the standard
error for all other non-zero exits. That, however, risks hiding the
message of unrelated failures that share an exit code of 1, so it
doesn't seem worth doing just to avoid a clunkier, but still clear,
error message.
Signed-off-by: Kyle Meyer <kyle@kyleam.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-01-08 00:31:21 +00:00
|
|
|
test_expect_success 'submodule add relays add --dry-run stderr' '
|
|
|
|
test_when_finished "rm -rf addtest/.git/index.lock" &&
|
|
|
|
(
|
|
|
|
cd addtest &&
|
|
|
|
: >.git/index.lock &&
|
|
|
|
! git submodule add "$submodurl" sub-while-locked 2>output.err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "^fatal: .*index\.lock" output.err &&
|
submodule add: show 'add --dry-run' stderr when aborting
Unless --force is specified, 'submodule add' checks if the destination
path is ignored by calling 'git add --dry-run --ignore-missing', and,
if that call fails, aborts with a custom "path is ignored" message (a
slight variant of what 'git add' shows). Aborting early rather than
letting the downstream 'git add' call fail is done so that the command
exits before cloning into the destination path. However, in rare
cases where the dry-run call fails for a reason other than the path
being ignored---for example, due to a preexisting index.lock
file---displaying the "ignored path" error message hides the real
source of the failure.
Instead of displaying the tailored "ignored path" message, let's
report the standard error from the dry run to give the caller more
accurate information about failures that are not due to an ignored
path.
For the ignored path case, this leads to the following change in the
error message:
The following [-path is-]{+paths are+} ignored by one of your .gitignore files:
<destination path>
Use -f if you really want to add [-it.-]{+them.+}
The new phrasing is a bit awkward, because 'submodule add' is only
dealing with one destination path. Alternatively, we could continue
to use the tailored message when the exit code is 1 (the expected
status for a failure due to an ignored path) and relay the standard
error for all other non-zero exits. That, however, risks hiding the
message of unrelated failures that share an exit code of 1, so it
doesn't seem worth doing just to avoid a clunkier, but still clear,
error message.
Signed-off-by: Kyle Meyer <kyle@kyleam.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-01-08 00:31:21 +00:00
|
|
|
test_path_is_missing sub-while-locked
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2009-04-19 03:42:07 +00:00
|
|
|
test_expect_success 'submodule add --branch' '
|
2010-04-10 05:39:04 +00:00
|
|
|
echo "refs/heads/initial" >expect-head &&
|
|
|
|
cat <<-\EOF >expect-heads &&
|
|
|
|
refs/heads/initial
|
2020-11-18 23:44:39 +00:00
|
|
|
refs/heads/main
|
2010-04-10 05:39:04 +00:00
|
|
|
EOF
|
|
|
|
|
2009-04-19 03:42:07 +00:00
|
|
|
(
|
|
|
|
cd addtest &&
|
|
|
|
git submodule add -b initial "$submodurl" submod-branch &&
|
2012-12-19 16:03:33 +00:00
|
|
|
test "initial" = "$(git config -f .gitmodules submodule.submod-branch.branch)" &&
|
2010-04-10 05:39:04 +00:00
|
|
|
git submodule init
|
|
|
|
) &&
|
|
|
|
|
|
|
|
rm -f heads head untracked &&
|
|
|
|
inspect addtest/submod-branch ../.. &&
|
|
|
|
test_cmp expect-heads heads &&
|
|
|
|
test_cmp expect-head head &&
|
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 untracked
|
2009-04-19 03:42:07 +00:00
|
|
|
'
|
|
|
|
|
2009-03-03 15:08:21 +00:00
|
|
|
test_expect_success 'submodule add with ./ in path' '
|
2020-11-18 23:44:39 +00:00
|
|
|
echo "refs/heads/main" >expect &&
|
2010-04-10 05:39:04 +00:00
|
|
|
|
2009-03-03 15:08:20 +00:00
|
|
|
(
|
|
|
|
cd addtest &&
|
|
|
|
git submodule add "$submodurl" ././dotsubmod/./frotz/./ &&
|
|
|
|
git submodule init
|
2010-04-10 05:39:04 +00:00
|
|
|
) &&
|
|
|
|
|
|
|
|
rm -f heads head untracked &&
|
|
|
|
inspect addtest/dotsubmod/frotz ../../.. &&
|
|
|
|
test_cmp expect heads &&
|
|
|
|
test_cmp expect head &&
|
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 untracked
|
2009-03-03 15:08:20 +00:00
|
|
|
'
|
|
|
|
|
2015-01-30 15:14:03 +00:00
|
|
|
test_expect_success 'submodule add with /././ in path' '
|
2020-11-18 23:44:39 +00:00
|
|
|
echo "refs/heads/main" >expect &&
|
2015-01-30 15:14:03 +00:00
|
|
|
|
|
|
|
(
|
|
|
|
cd addtest &&
|
|
|
|
git submodule add "$submodurl" dotslashdotsubmod/././frotz/./ &&
|
|
|
|
git submodule init
|
|
|
|
) &&
|
|
|
|
|
|
|
|
rm -f heads head untracked &&
|
|
|
|
inspect addtest/dotslashdotsubmod/frotz ../../.. &&
|
|
|
|
test_cmp expect heads &&
|
|
|
|
test_cmp expect head &&
|
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 untracked
|
2015-01-30 15:14:03 +00:00
|
|
|
'
|
2009-03-03 15:08:20 +00:00
|
|
|
|
2009-03-03 15:08:21 +00:00
|
|
|
test_expect_success 'submodule add with // in path' '
|
2020-11-18 23:44:39 +00:00
|
|
|
echo "refs/heads/main" >expect &&
|
2010-04-10 05:39:04 +00:00
|
|
|
|
2009-03-03 15:08:20 +00:00
|
|
|
(
|
|
|
|
cd addtest &&
|
|
|
|
git submodule add "$submodurl" slashslashsubmod///frotz// &&
|
|
|
|
git submodule init
|
2010-04-10 05:39:04 +00:00
|
|
|
) &&
|
|
|
|
|
|
|
|
rm -f heads head untracked &&
|
|
|
|
inspect addtest/slashslashsubmod/frotz ../../.. &&
|
|
|
|
test_cmp expect heads &&
|
|
|
|
test_cmp expect head &&
|
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 untracked
|
2009-03-03 15:08:20 +00:00
|
|
|
'
|
|
|
|
|
2009-03-03 15:08:21 +00:00
|
|
|
test_expect_success 'submodule add with /.. in path' '
|
2020-11-18 23:44:39 +00:00
|
|
|
echo "refs/heads/main" >expect &&
|
2010-04-10 05:39:04 +00:00
|
|
|
|
2009-03-03 15:08:20 +00:00
|
|
|
(
|
|
|
|
cd addtest &&
|
|
|
|
git submodule add "$submodurl" dotdotsubmod/../realsubmod/frotz/.. &&
|
|
|
|
git submodule init
|
2010-04-10 05:39:04 +00:00
|
|
|
) &&
|
|
|
|
|
|
|
|
rm -f heads head untracked &&
|
|
|
|
inspect addtest/realsubmod ../.. &&
|
|
|
|
test_cmp expect heads &&
|
|
|
|
test_cmp expect head &&
|
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 untracked
|
2009-03-03 15:08:20 +00:00
|
|
|
'
|
|
|
|
|
2009-03-03 15:08:21 +00:00
|
|
|
test_expect_success 'submodule add with ./, /.. and // in path' '
|
2020-11-18 23:44:39 +00:00
|
|
|
echo "refs/heads/main" >expect &&
|
2010-04-10 05:39:04 +00:00
|
|
|
|
2009-03-03 15:08:20 +00:00
|
|
|
(
|
|
|
|
cd addtest &&
|
|
|
|
git submodule add "$submodurl" dot/dotslashsubmod/./../..////realsubmod2/a/b/c/d/../../../../frotz//.. &&
|
|
|
|
git submodule init
|
2010-04-10 05:39:04 +00:00
|
|
|
) &&
|
|
|
|
|
|
|
|
rm -f heads head untracked &&
|
|
|
|
inspect addtest/realsubmod2 ../.. &&
|
|
|
|
test_cmp expect heads &&
|
|
|
|
test_cmp expect head &&
|
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 untracked
|
2009-03-03 15:08:20 +00:00
|
|
|
'
|
|
|
|
|
t7400: add !CYGWIN prerequisite to 'add with \\ in path'
Commit cf9e55f494 ("submodule: prevent backslash expantion in submodule
names", 07-04-2017) added a test which creates a git repository with
some backslash characters in the name. On windows, where the backslash
character is a directory separator, it is not possible to create a
repository with the name 'sub\with\backslash'. (The NTFS filesystem would
probably allow it, but the win32 api does not). The MinGW and Git for
Windows versions of git actually create a repository called 'backslash'
in the sub-directory 'sub/with'.
On cygwin, however, due to the slightly schizophrenic treatment of the
backslash character by cygwin-git, this test fails at the 'git init'
stage. The git-init command does not recognise the directory separators
in the input path (eg. is_dir_sep('\\') is false), so it does not
attempt to create the leading directories 'sub/with'. (The call to
mkdir('sub\\with\\backslash') actually does recognise the directory
separators, but fails because the 'sub/with' directory doesn't exist).
In order to suppress the test failure (for now), add the !CYGWIN test
prerequisite.
Signed-off-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-04-30 17:29:30 +00:00
|
|
|
test_expect_success !CYGWIN 'submodule add with \\ in path' '
|
2017-04-07 17:23:06 +00:00
|
|
|
test_when_finished "rm -rf parent sub\\with\\backslash" &&
|
|
|
|
|
|
|
|
# Initialize a repo with a backslash in its name
|
|
|
|
git init sub\\with\\backslash &&
|
|
|
|
touch sub\\with\\backslash/empty.file &&
|
|
|
|
git -C sub\\with\\backslash add empty.file &&
|
|
|
|
git -C sub\\with\\backslash commit -m "Added empty.file" &&
|
|
|
|
|
|
|
|
# Add that repository as a submodule
|
|
|
|
git init parent &&
|
|
|
|
git -C parent submodule add ../sub\\with\\backslash
|
|
|
|
'
|
|
|
|
|
2013-06-16 14:18:18 +00:00
|
|
|
test_expect_success 'submodule add in subdirectory' '
|
2020-11-18 23:44:39 +00:00
|
|
|
echo "refs/heads/main" >expect &&
|
2013-06-16 14:18:18 +00:00
|
|
|
|
|
|
|
mkdir addtest/sub &&
|
|
|
|
(
|
|
|
|
cd addtest/sub &&
|
|
|
|
git submodule add "$submodurl" ../realsubmod3 &&
|
|
|
|
git submodule init
|
|
|
|
) &&
|
|
|
|
|
|
|
|
rm -f heads head untracked &&
|
|
|
|
inspect addtest/realsubmod3 ../.. &&
|
|
|
|
test_cmp expect heads &&
|
|
|
|
test_cmp expect head &&
|
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 untracked
|
2013-06-16 14:18:18 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'submodule add in subdirectory with relative path should fail' '
|
|
|
|
(
|
|
|
|
cd addtest/sub &&
|
|
|
|
test_must_fail git submodule add ../../ submod3 2>../../output.err
|
|
|
|
) &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep toplevel output.err
|
2013-06-16 14:18:18 +00:00
|
|
|
'
|
|
|
|
|
2010-04-10 05:39:41 +00:00
|
|
|
test_expect_success 'setup - add an example entry to .gitmodules' '
|
2014-03-20 23:17:01 +00:00
|
|
|
git config --file=.gitmodules submodule.example.url git://example.com/init.git
|
2010-04-10 05:39:41 +00:00
|
|
|
'
|
|
|
|
|
2007-06-11 19:12:24 +00:00
|
|
|
test_expect_success 'status should fail for unmapped paths' '
|
2010-04-10 05:39:41 +00:00
|
|
|
test_must_fail git submodule status
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'setup - map path in .gitmodules' '
|
|
|
|
cat <<\EOF >expect &&
|
|
|
|
[submodule "example"]
|
|
|
|
url = git://example.com/init.git
|
|
|
|
path = init
|
|
|
|
EOF
|
|
|
|
|
2014-03-20 23:17:01 +00:00
|
|
|
git config --file=.gitmodules submodule.example.path init &&
|
2010-04-10 05:39:41 +00:00
|
|
|
|
|
|
|
test_cmp expect .gitmodules
|
2007-06-02 01:27:42 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'status should only print one line' '
|
2010-04-10 05:39:41 +00:00
|
|
|
git submodule status >lines &&
|
2012-04-11 11:24:01 +00:00
|
|
|
test_line_count = 1 lines
|
2010-04-10 05:39:41 +00:00
|
|
|
'
|
|
|
|
|
2019-11-25 04:15:44 +00:00
|
|
|
test_expect_success 'status from subdirectory should have the same SHA1' '
|
|
|
|
test_when_finished "rmdir addtest/subdir" &&
|
|
|
|
(
|
|
|
|
cd addtest &&
|
|
|
|
mkdir subdir &&
|
|
|
|
git submodule status >output &&
|
|
|
|
awk "{print \$1}" <output >expect &&
|
|
|
|
cd subdir &&
|
|
|
|
git submodule status >../output &&
|
|
|
|
awk "{print \$1}" <../output >../actual &&
|
|
|
|
test_cmp ../expect ../actual &&
|
|
|
|
git -C ../submod checkout HEAD^ &&
|
|
|
|
git submodule status >../output &&
|
|
|
|
awk "{print \$1}" <../output >../actual2 &&
|
|
|
|
cd .. &&
|
|
|
|
git submodule status >output &&
|
|
|
|
awk "{print \$1}" <output >expect2 &&
|
|
|
|
test_cmp expect2 actual2 &&
|
|
|
|
! test_cmp actual actual2
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2010-04-10 05:39:41 +00:00
|
|
|
test_expect_success 'setup - fetch commit name from submodule' '
|
|
|
|
rev1=$(cd .subrepo && git rev-parse HEAD) &&
|
|
|
|
printf "rev1: %s\n" "$rev1" &&
|
|
|
|
test -n "$rev1"
|
2007-06-02 01:27:42 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'status should initially be "missing"' '
|
2010-04-10 05:39:41 +00:00
|
|
|
git submodule status >lines &&
|
|
|
|
grep "^-$rev1" lines
|
2007-06-02 01:27:42 +00:00
|
|
|
'
|
|
|
|
|
2007-06-06 09:13:02 +00:00
|
|
|
test_expect_success 'init should register submodule url in .git/config' '
|
2010-04-10 05:39:41 +00:00
|
|
|
echo git://example.com/init.git >expect &&
|
|
|
|
|
2008-09-03 08:59:33 +00:00
|
|
|
git submodule init &&
|
2010-04-10 05:39:41 +00:00
|
|
|
git config submodule.example.url >url &&
|
|
|
|
git config submodule.example.url ./.subrepo &&
|
|
|
|
|
|
|
|
test_cmp expect url
|
2007-06-06 09:13:02 +00:00
|
|
|
'
|
|
|
|
|
2020-01-24 10:34:04 +00:00
|
|
|
test_expect_success 'status should still be "missing" after initializing' '
|
2020-01-24 10:34:03 +00:00
|
|
|
rm -fr init &&
|
|
|
|
mkdir init &&
|
|
|
|
git submodule status >lines &&
|
|
|
|
rm -fr init &&
|
|
|
|
grep "^-$rev1" lines
|
|
|
|
'
|
|
|
|
|
2012-08-14 20:35:27 +00:00
|
|
|
test_failure_with_unknown_submodule () {
|
|
|
|
test_must_fail git submodule $1 no-such-submodule 2>output.err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "^error: .*no-such-submodule" output.err
|
2012-08-14 20:35:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
test_expect_success 'init should fail with unknown submodule' '
|
|
|
|
test_failure_with_unknown_submodule init
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'update should fail with unknown submodule' '
|
|
|
|
test_failure_with_unknown_submodule update
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'status should fail with unknown submodule' '
|
|
|
|
test_failure_with_unknown_submodule status
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'sync should fail with unknown submodule' '
|
|
|
|
test_failure_with_unknown_submodule sync
|
|
|
|
'
|
|
|
|
|
2007-06-06 09:13:02 +00:00
|
|
|
test_expect_success 'update should fail when path is used by a file' '
|
2010-04-10 05:39:41 +00:00
|
|
|
echo hello >expect &&
|
|
|
|
|
2008-01-15 11:13:55 +00:00
|
|
|
echo "hello" >init &&
|
2010-04-10 05:39:41 +00:00
|
|
|
test_must_fail git submodule update &&
|
|
|
|
|
|
|
|
test_cmp expect init
|
2007-06-02 01:27:42 +00:00
|
|
|
'
|
|
|
|
|
2007-06-06 09:13:02 +00:00
|
|
|
test_expect_success 'update should fail when path is used by a nonempty directory' '
|
2010-04-10 05:39:41 +00:00
|
|
|
echo hello >expect &&
|
|
|
|
|
|
|
|
rm -fr init &&
|
2008-01-15 11:13:55 +00:00
|
|
|
mkdir init &&
|
|
|
|
echo "hello" >init/a &&
|
2010-04-10 05:39:41 +00:00
|
|
|
|
|
|
|
test_must_fail git submodule update &&
|
|
|
|
|
|
|
|
test_cmp expect init/a
|
2007-06-02 01:27:42 +00:00
|
|
|
'
|
|
|
|
|
2007-06-06 09:13:02 +00:00
|
|
|
test_expect_success 'update should work when path is an empty dir' '
|
2010-04-10 05:39:41 +00:00
|
|
|
rm -fr init &&
|
|
|
|
rm -f head-sha1 &&
|
|
|
|
echo "$rev1" >expect &&
|
|
|
|
|
2008-01-15 11:13:55 +00:00
|
|
|
mkdir init &&
|
2011-07-26 21:39:03 +00:00
|
|
|
git submodule update -q >update.out &&
|
2013-06-09 18:29:20 +00:00
|
|
|
test_must_be_empty update.out &&
|
2010-04-10 05:39:41 +00:00
|
|
|
|
|
|
|
inspect init &&
|
|
|
|
test_cmp expect head-sha1
|
2007-06-02 01:27:42 +00:00
|
|
|
'
|
|
|
|
|
2007-06-06 09:13:02 +00:00
|
|
|
test_expect_success 'status should be "up-to-date" after update' '
|
2010-04-10 05:39:41 +00:00
|
|
|
git submodule status >list &&
|
|
|
|
grep "^ $rev1" list
|
2007-06-02 01:27:42 +00:00
|
|
|
'
|
|
|
|
|
2013-06-16 14:18:18 +00:00
|
|
|
test_expect_success 'status "up-to-date" from subdirectory' '
|
|
|
|
mkdir -p sub &&
|
|
|
|
(
|
|
|
|
cd sub &&
|
|
|
|
git submodule status >../list
|
|
|
|
) &&
|
|
|
|
grep "^ $rev1" list &&
|
|
|
|
grep "\\.\\./init" list
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'status "up-to-date" from subdirectory with path' '
|
|
|
|
mkdir -p sub &&
|
|
|
|
(
|
|
|
|
cd sub &&
|
|
|
|
git submodule status ../init >../list
|
|
|
|
) &&
|
|
|
|
grep "^ $rev1" list &&
|
|
|
|
grep "\\.\\./init" list
|
|
|
|
'
|
|
|
|
|
2007-06-02 01:27:42 +00:00
|
|
|
test_expect_success 'status should be "modified" after submodule commit' '
|
2010-04-10 05:39:41 +00:00
|
|
|
(
|
|
|
|
cd init &&
|
|
|
|
echo b >b &&
|
|
|
|
git add b &&
|
|
|
|
git commit -m "submodule commit 2"
|
|
|
|
) &&
|
|
|
|
|
|
|
|
rev2=$(cd init && git rev-parse HEAD) &&
|
|
|
|
test -n "$rev2" &&
|
|
|
|
git submodule status >list &&
|
|
|
|
|
|
|
|
grep "^+$rev2" list
|
2007-06-02 01:27:42 +00:00
|
|
|
'
|
|
|
|
|
2022-11-08 14:10:33 +00:00
|
|
|
test_expect_success '"submodule --cached" command forms should be identical' '
|
|
|
|
git submodule status --cached >expect &&
|
|
|
|
|
|
|
|
git submodule --cached >actual &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
git submodule --cached status >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2007-06-02 01:27:42 +00:00
|
|
|
test_expect_success 'the --cached sha1 should be rev1' '
|
2010-04-10 05:39:41 +00:00
|
|
|
git submodule --cached status >list &&
|
|
|
|
grep "^+$rev1" list
|
2007-06-02 01:27:42 +00:00
|
|
|
'
|
|
|
|
|
2007-09-08 10:30:22 +00:00
|
|
|
test_expect_success 'git diff should report the SHA1 of the new submodule commit' '
|
2010-04-10 05:39:41 +00:00
|
|
|
git diff >diff &&
|
|
|
|
grep "^+Subproject commit $rev2" diff
|
2007-09-08 10:30:22 +00:00
|
|
|
'
|
|
|
|
|
2007-06-02 01:27:42 +00:00
|
|
|
test_expect_success 'update should checkout rev1' '
|
2010-04-10 05:39:41 +00:00
|
|
|
rm -f head-sha1 &&
|
|
|
|
echo "$rev1" >expect &&
|
|
|
|
|
2008-09-03 08:59:33 +00:00
|
|
|
git submodule update init &&
|
2010-04-10 05:39:41 +00:00
|
|
|
inspect init &&
|
|
|
|
|
|
|
|
test_cmp expect head-sha1
|
2007-06-02 01:27:42 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'status should be "up-to-date" after update' '
|
2010-04-10 05:39:41 +00:00
|
|
|
git submodule status >list &&
|
|
|
|
grep "^ $rev1" list
|
2007-06-02 01:27:42 +00:00
|
|
|
'
|
|
|
|
|
2007-07-17 18:28:28 +00:00
|
|
|
test_expect_success 'checkout superproject with subproject already present' '
|
2008-09-03 08:59:33 +00:00
|
|
|
git checkout initial &&
|
2020-11-18 23:44:39 +00:00
|
|
|
git checkout main
|
2007-07-17 18:28:28 +00:00
|
|
|
'
|
|
|
|
|
2007-08-15 17:22:09 +00:00
|
|
|
test_expect_success 'apply submodule diff' '
|
|
|
|
git branch second &&
|
|
|
|
(
|
2008-01-15 11:13:55 +00:00
|
|
|
cd init &&
|
2007-08-15 17:22:09 +00:00
|
|
|
echo s >s &&
|
|
|
|
git add s &&
|
|
|
|
git commit -m "change subproject"
|
|
|
|
) &&
|
2008-01-15 11:13:55 +00:00
|
|
|
git update-index --add init &&
|
2008-09-03 08:59:33 +00:00
|
|
|
git commit -m "change init" &&
|
|
|
|
git format-patch -1 --stdout >P.diff &&
|
2007-08-15 17:22:09 +00:00
|
|
|
git checkout second &&
|
|
|
|
git apply --index P.diff &&
|
2010-04-10 05:39:41 +00:00
|
|
|
|
2020-11-18 23:44:39 +00:00
|
|
|
git diff --cached main >staged &&
|
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 staged
|
2007-08-15 17:22:09 +00:00
|
|
|
'
|
|
|
|
|
2008-05-16 10:23:03 +00:00
|
|
|
test_expect_success 'update --init' '
|
|
|
|
mv init init2 &&
|
|
|
|
git config -f .gitmodules submodule.example.url "$(pwd)/init2" &&
|
2010-04-10 05:39:41 +00:00
|
|
|
git config --remove-section submodule.example &&
|
|
|
|
test_must_fail git config submodule.example.url &&
|
|
|
|
|
2016-03-01 02:07:14 +00:00
|
|
|
git submodule update init 2> update.out &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "not initialized" update.out &&
|
2011-08-15 21:17:46 +00:00
|
|
|
test_must_fail git rev-parse --resolve-git-dir init/.git &&
|
2010-04-10 05:39:41 +00:00
|
|
|
|
2008-05-16 10:23:03 +00:00
|
|
|
git submodule update --init init &&
|
2011-08-15 21:17:46 +00:00
|
|
|
git rev-parse --resolve-git-dir init/.git
|
2008-05-16 10:23:03 +00:00
|
|
|
'
|
|
|
|
|
2013-06-16 14:18:18 +00:00
|
|
|
test_expect_success 'update --init from subdirectory' '
|
|
|
|
mv init init2 &&
|
|
|
|
git config -f .gitmodules submodule.example.url "$(pwd)/init2" &&
|
|
|
|
git config --remove-section submodule.example &&
|
|
|
|
test_must_fail git config submodule.example.url &&
|
|
|
|
|
|
|
|
mkdir -p sub &&
|
|
|
|
(
|
|
|
|
cd sub &&
|
2016-03-01 02:07:14 +00:00
|
|
|
git submodule update ../init 2>update.out &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "not initialized" update.out &&
|
2013-06-16 14:18:18 +00:00
|
|
|
test_must_fail git rev-parse --resolve-git-dir ../init/.git &&
|
|
|
|
|
|
|
|
git submodule update --init ../init
|
|
|
|
) &&
|
|
|
|
git rev-parse --resolve-git-dir init/.git
|
|
|
|
'
|
|
|
|
|
2009-01-02 18:08:40 +00:00
|
|
|
test_expect_success 'do not add files from a submodule' '
|
|
|
|
|
|
|
|
git reset --hard &&
|
|
|
|
test_must_fail git add init/a
|
|
|
|
|
|
|
|
'
|
|
|
|
|
2013-09-12 19:25:01 +00:00
|
|
|
test_expect_success 'gracefully add/reset submodule with a trailing slash' '
|
2009-01-02 18:08:40 +00:00
|
|
|
|
|
|
|
git reset --hard &&
|
|
|
|
git commit -m "commit subproject" init &&
|
|
|
|
(cd init &&
|
|
|
|
echo b > a) &&
|
|
|
|
git add init/ &&
|
|
|
|
git diff --exit-code --cached init &&
|
|
|
|
commit=$(cd init &&
|
|
|
|
git commit -m update a >/dev/null &&
|
|
|
|
git rev-parse HEAD) &&
|
|
|
|
git add init/ &&
|
|
|
|
test_must_fail git diff --exit-code --cached init &&
|
|
|
|
test $commit = $(git ls-files --stage |
|
2013-09-12 19:25:01 +00:00
|
|
|
sed -n "s/^160000 \([^ ]*\).*/\1/p") &&
|
|
|
|
git reset init/ &&
|
|
|
|
git diff --exit-code --cached init
|
2009-01-02 18:08:40 +00:00
|
|
|
|
|
|
|
'
|
|
|
|
|
2009-02-07 13:43:03 +00:00
|
|
|
test_expect_success 'ls-files gracefully handles trailing slash' '
|
|
|
|
|
|
|
|
test "init" = "$(git ls-files init/)"
|
|
|
|
|
|
|
|
'
|
|
|
|
|
2010-01-11 02:59:54 +00:00
|
|
|
test_expect_success 'moving to a commit without submodule does not leave empty dir' '
|
|
|
|
rm -rf init &&
|
|
|
|
mkdir init &&
|
|
|
|
git reset --hard &&
|
|
|
|
git checkout initial &&
|
|
|
|
test ! -d init &&
|
|
|
|
git checkout second
|
|
|
|
'
|
|
|
|
|
2012-09-22 11:27:59 +00:00
|
|
|
test_expect_success 'submodule <invalid-subcommand> fails' '
|
|
|
|
test_must_fail git submodule no-such-subcommand
|
2009-02-07 13:43:15 +00:00
|
|
|
'
|
|
|
|
|
2009-09-22 15:10:12 +00:00
|
|
|
test_expect_success 'add submodules without specifying an explicit path' '
|
|
|
|
mkdir repo &&
|
2010-09-07 01:42:54 +00:00
|
|
|
(
|
|
|
|
cd repo &&
|
|
|
|
git init &&
|
|
|
|
echo r >r &&
|
|
|
|
git add r &&
|
|
|
|
git commit -m "repo commit 1"
|
2010-09-06 18:39:54 +00:00
|
|
|
) &&
|
2009-09-22 15:10:12 +00:00
|
|
|
git clone --bare repo/ bare.git &&
|
2010-12-04 23:27:35 +00:00
|
|
|
(
|
|
|
|
cd addtest &&
|
|
|
|
git submodule add "$submodurl/repo" &&
|
|
|
|
git config -f .gitmodules submodule.repo.path repo &&
|
|
|
|
git submodule add "$submodurl/bare.git" &&
|
|
|
|
git config -f .gitmodules submodule.bare.path bare
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'add should fail when path is used by a file' '
|
|
|
|
(
|
|
|
|
cd addtest &&
|
|
|
|
touch file &&
|
|
|
|
test_must_fail git submodule add "$submodurl/repo" file
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'add should fail when path is used by an existing directory' '
|
|
|
|
(
|
|
|
|
cd addtest &&
|
|
|
|
mkdir empty-dir &&
|
|
|
|
test_must_fail git submodule add "$submodurl/repo" empty-dir
|
|
|
|
)
|
2009-09-22 15:10:12 +00:00
|
|
|
'
|
|
|
|
|
2011-06-06 19:58:04 +00:00
|
|
|
test_expect_success 'use superproject as upstream when path is relative and no url is set there' '
|
2011-06-06 19:57:01 +00:00
|
|
|
(
|
|
|
|
cd addtest &&
|
2011-06-06 19:58:04 +00:00
|
|
|
git submodule add ../repo relative &&
|
|
|
|
test "$(git config -f .gitmodules submodule.relative.url)" = ../repo &&
|
|
|
|
git submodule sync relative &&
|
|
|
|
test "$(git config submodule.relative.url)" = "$submodurl/repo"
|
2011-06-06 19:57:01 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2011-01-10 10:37:26 +00:00
|
|
|
test_expect_success 'set up for relative path tests' '
|
|
|
|
mkdir reltest &&
|
|
|
|
(
|
|
|
|
cd reltest &&
|
|
|
|
git init &&
|
|
|
|
mkdir sub &&
|
|
|
|
(
|
|
|
|
cd sub &&
|
|
|
|
git init &&
|
|
|
|
test_commit foo
|
|
|
|
) &&
|
|
|
|
git add sub &&
|
|
|
|
git config -f .gitmodules submodule.sub.path sub &&
|
|
|
|
git config -f .gitmodules submodule.sub.url ../subrepo &&
|
2012-06-03 09:46:47 +00:00
|
|
|
cp .git/config pristine-.git-config &&
|
|
|
|
cp .gitmodules pristine-.gitmodules
|
2011-01-10 10:37:26 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2012-06-03 09:46:47 +00:00
|
|
|
test_expect_success '../subrepo works with URL - ssh://hostname/repo' '
|
2011-01-10 10:37:26 +00:00
|
|
|
(
|
|
|
|
cd reltest &&
|
|
|
|
cp pristine-.git-config .git/config &&
|
2012-06-03 09:46:47 +00:00
|
|
|
cp pristine-.gitmodules .gitmodules &&
|
2011-01-10 10:37:26 +00:00
|
|
|
git config remote.origin.url ssh://hostname/repo &&
|
|
|
|
git submodule init &&
|
|
|
|
test "$(git config submodule.sub.url)" = ssh://hostname/subrepo
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2012-06-03 09:46:47 +00:00
|
|
|
test_expect_success '../subrepo works with port-qualified URL - ssh://hostname:22/repo' '
|
|
|
|
(
|
|
|
|
cd reltest &&
|
|
|
|
cp pristine-.git-config .git/config &&
|
|
|
|
cp pristine-.gitmodules .gitmodules &&
|
|
|
|
git config remote.origin.url ssh://hostname:22/repo &&
|
|
|
|
git submodule init &&
|
|
|
|
test "$(git config submodule.sub.url)" = ssh://hostname:22/subrepo
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2012-06-14 12:10:27 +00:00
|
|
|
# About the choice of the path in the next test:
|
|
|
|
# - double-slash side-steps path mangling issues on Windows
|
|
|
|
# - it is still an absolute local path
|
|
|
|
# - there cannot be a server with a blank in its name just in case the
|
|
|
|
# path is used erroneously to access a //server/share style path
|
|
|
|
test_expect_success '../subrepo path works with local path - //somewhere else/repo' '
|
2012-06-03 09:46:47 +00:00
|
|
|
(
|
|
|
|
cd reltest &&
|
|
|
|
cp pristine-.git-config .git/config &&
|
|
|
|
cp pristine-.gitmodules .gitmodules &&
|
2012-06-14 12:10:27 +00:00
|
|
|
git config remote.origin.url "//somewhere else/repo" &&
|
2012-06-03 09:46:47 +00:00
|
|
|
git submodule init &&
|
2012-06-14 12:10:27 +00:00
|
|
|
test "$(git config submodule.sub.url)" = "//somewhere else/subrepo"
|
2012-06-03 09:46:47 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '../subrepo works with file URL - file:///tmp/repo' '
|
|
|
|
(
|
|
|
|
cd reltest &&
|
|
|
|
cp pristine-.git-config .git/config &&
|
|
|
|
cp pristine-.gitmodules .gitmodules &&
|
|
|
|
git config remote.origin.url file:///tmp/repo &&
|
|
|
|
git submodule init &&
|
|
|
|
test "$(git config submodule.sub.url)" = file:///tmp/subrepo
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '../subrepo works with helper URL- helper:://hostname/repo' '
|
|
|
|
(
|
|
|
|
cd reltest &&
|
|
|
|
cp pristine-.git-config .git/config &&
|
|
|
|
cp pristine-.gitmodules .gitmodules &&
|
|
|
|
git config remote.origin.url helper:://hostname/repo &&
|
|
|
|
git submodule init &&
|
|
|
|
test "$(git config submodule.sub.url)" = helper:://hostname/subrepo
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '../subrepo works with scp-style URL - user@host:repo' '
|
2011-01-10 10:37:26 +00:00
|
|
|
(
|
|
|
|
cd reltest &&
|
|
|
|
cp pristine-.git-config .git/config &&
|
|
|
|
git config remote.origin.url user@host:repo &&
|
|
|
|
git submodule init &&
|
|
|
|
test "$(git config submodule.sub.url)" = user@host:subrepo
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2012-06-03 09:46:47 +00:00
|
|
|
test_expect_success '../subrepo works with scp-style URL - user@host:path/to/repo' '
|
|
|
|
(
|
|
|
|
cd reltest &&
|
|
|
|
cp pristine-.git-config .git/config &&
|
|
|
|
cp pristine-.gitmodules .gitmodules &&
|
|
|
|
git config remote.origin.url user@host:path/to/repo &&
|
|
|
|
git submodule init &&
|
|
|
|
test "$(git config submodule.sub.url)" = user@host:path/to/subrepo
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2012-06-06 11:57:30 +00:00
|
|
|
test_expect_success '../subrepo works with relative local path - foo' '
|
2012-06-03 09:46:48 +00:00
|
|
|
(
|
|
|
|
cd reltest &&
|
|
|
|
cp pristine-.git-config .git/config &&
|
|
|
|
cp pristine-.gitmodules .gitmodules &&
|
|
|
|
git config remote.origin.url foo &&
|
|
|
|
# actual: fails with an error
|
|
|
|
git submodule init &&
|
|
|
|
test "$(git config submodule.sub.url)" = subrepo
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2012-06-03 09:46:47 +00:00
|
|
|
test_expect_success '../subrepo works with relative local path - foo/bar' '
|
|
|
|
(
|
|
|
|
cd reltest &&
|
|
|
|
cp pristine-.git-config .git/config &&
|
|
|
|
cp pristine-.gitmodules .gitmodules &&
|
|
|
|
git config remote.origin.url foo/bar &&
|
|
|
|
git submodule init &&
|
|
|
|
test "$(git config submodule.sub.url)" = foo/subrepo
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2012-06-06 11:57:30 +00:00
|
|
|
test_expect_success '../subrepo works with relative local path - ./foo' '
|
2012-06-03 09:46:48 +00:00
|
|
|
(
|
|
|
|
cd reltest &&
|
|
|
|
cp pristine-.git-config .git/config &&
|
|
|
|
cp pristine-.gitmodules .gitmodules &&
|
|
|
|
git config remote.origin.url ./foo &&
|
|
|
|
git submodule init &&
|
|
|
|
test "$(git config submodule.sub.url)" = subrepo
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2012-06-06 11:57:30 +00:00
|
|
|
test_expect_success '../subrepo works with relative local path - ./foo/bar' '
|
2012-06-03 09:46:48 +00:00
|
|
|
(
|
|
|
|
cd reltest &&
|
|
|
|
cp pristine-.git-config .git/config &&
|
|
|
|
cp pristine-.gitmodules .gitmodules &&
|
|
|
|
git config remote.origin.url ./foo/bar &&
|
|
|
|
git submodule init &&
|
|
|
|
test "$(git config submodule.sub.url)" = foo/subrepo
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2012-06-03 09:46:47 +00:00
|
|
|
test_expect_success '../subrepo works with relative local path - ../foo' '
|
|
|
|
(
|
|
|
|
cd reltest &&
|
|
|
|
cp pristine-.git-config .git/config &&
|
|
|
|
cp pristine-.gitmodules .gitmodules &&
|
|
|
|
git config remote.origin.url ../foo &&
|
|
|
|
git submodule init &&
|
|
|
|
test "$(git config submodule.sub.url)" = ../subrepo
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '../subrepo works with relative local path - ../foo/bar' '
|
|
|
|
(
|
|
|
|
cd reltest &&
|
|
|
|
cp pristine-.git-config .git/config &&
|
|
|
|
cp pristine-.gitmodules .gitmodules &&
|
|
|
|
git config remote.origin.url ../foo/bar &&
|
|
|
|
git submodule init &&
|
|
|
|
test "$(git config submodule.sub.url)" = ../foo/subrepo
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '../bar/a/b/c works with relative local path - ../foo/bar.git' '
|
|
|
|
(
|
|
|
|
cd reltest &&
|
|
|
|
cp pristine-.git-config .git/config &&
|
|
|
|
cp pristine-.gitmodules .gitmodules &&
|
|
|
|
mkdir -p a/b/c &&
|
2019-04-09 23:07:35 +00:00
|
|
|
(cd a/b/c && git init && test_commit msg) &&
|
2012-06-03 09:46:47 +00:00
|
|
|
git config remote.origin.url ../foo/bar.git &&
|
|
|
|
git submodule add ../bar/a/b/c ./a/b/c &&
|
|
|
|
git submodule init &&
|
|
|
|
test "$(git config submodule.a/b/c.url)" = ../foo/bar/a/b/c
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2012-03-04 21:15:08 +00:00
|
|
|
test_expect_success 'moving the superproject does not break submodules' '
|
|
|
|
(
|
|
|
|
cd addtest &&
|
|
|
|
git submodule status >expect
|
2015-03-20 10:07:15 +00:00
|
|
|
) &&
|
2012-03-04 21:15:08 +00:00
|
|
|
mv addtest addtest2 &&
|
|
|
|
(
|
|
|
|
cd addtest2 &&
|
|
|
|
git submodule status >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2018-03-28 21:14:08 +00:00
|
|
|
test_expect_success 'moving the submodule does not break the superproject' '
|
|
|
|
(
|
|
|
|
cd addtest2 &&
|
|
|
|
git submodule status
|
|
|
|
) >actual &&
|
|
|
|
sed -e "s/^ \([^ ]* repo\) .*/-\1/" <actual >expect &&
|
|
|
|
mv addtest2/repo addtest2/repo.bak &&
|
|
|
|
test_when_finished "mv addtest2/repo.bak addtest2/repo" &&
|
|
|
|
(
|
|
|
|
cd addtest2 &&
|
|
|
|
git submodule status
|
|
|
|
) >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2012-09-29 23:05:58 +00:00
|
|
|
test_expect_success 'submodule add --name allows to replace a submodule with another at the same path' '
|
|
|
|
(
|
|
|
|
cd addtest2 &&
|
|
|
|
(
|
|
|
|
cd repo &&
|
|
|
|
echo "$submodurl/repo" >expect &&
|
|
|
|
git config remote.origin.url >actual &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
echo "gitdir: ../.git/modules/repo" >expect &&
|
|
|
|
test_cmp expect .git
|
|
|
|
) &&
|
|
|
|
rm -rf repo &&
|
|
|
|
git rm repo &&
|
|
|
|
git submodule add -q --name repo_new "$submodurl/bare.git" repo >actual &&
|
2013-06-09 18:29:20 +00:00
|
|
|
test_must_be_empty actual &&
|
2012-09-29 23:05:58 +00:00
|
|
|
echo "gitdir: ../.git/modules/submod" >expect &&
|
|
|
|
test_cmp expect submod/.git &&
|
|
|
|
(
|
|
|
|
cd repo &&
|
|
|
|
echo "$submodurl/bare.git" >expect &&
|
|
|
|
git config remote.origin.url >actual &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
echo "gitdir: ../.git/modules/repo_new" >expect &&
|
|
|
|
test_cmp expect .git
|
|
|
|
) &&
|
|
|
|
echo "repo" >expect &&
|
2013-08-06 19:15:25 +00:00
|
|
|
test_must_fail git config -f .gitmodules submodule.repo.path &&
|
2012-09-29 23:05:58 +00:00
|
|
|
git config -f .gitmodules submodule.repo_new.path >actual &&
|
2020-03-22 21:14:22 +00:00
|
|
|
test_cmp expect actual &&
|
2012-09-29 23:05:58 +00:00
|
|
|
echo "$submodurl/repo" >expect &&
|
2013-08-06 19:15:25 +00:00
|
|
|
test_must_fail git config -f .gitmodules submodule.repo.url &&
|
2012-09-29 23:05:58 +00:00
|
|
|
echo "$submodurl/bare.git" >expect &&
|
|
|
|
git config -f .gitmodules submodule.repo_new.url >actual &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
echo "$submodurl/repo" >expect &&
|
|
|
|
git config submodule.repo.url >actual &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
echo "$submodurl/bare.git" >expect &&
|
|
|
|
git config submodule.repo_new.url >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2016-04-01 00:17:28 +00:00
|
|
|
test_expect_success 'recursive relative submodules stay relative' '
|
2016-03-31 21:04:36 +00:00
|
|
|
test_when_finished "rm -rf super clone2 subsub sub3" &&
|
|
|
|
mkdir subsub &&
|
|
|
|
(
|
|
|
|
cd subsub &&
|
|
|
|
git init &&
|
|
|
|
>t &&
|
|
|
|
git add t &&
|
|
|
|
git commit -m "initial commit"
|
|
|
|
) &&
|
|
|
|
mkdir sub3 &&
|
|
|
|
(
|
|
|
|
cd sub3 &&
|
|
|
|
git init &&
|
|
|
|
>t &&
|
|
|
|
git add t &&
|
|
|
|
git commit -m "initial commit" &&
|
|
|
|
git submodule add ../subsub dirdir/subsub &&
|
|
|
|
git commit -m "add submodule subsub"
|
|
|
|
) &&
|
|
|
|
mkdir super &&
|
|
|
|
(
|
|
|
|
cd super &&
|
|
|
|
git init &&
|
|
|
|
>t &&
|
|
|
|
git add t &&
|
|
|
|
git commit -m "initial commit" &&
|
|
|
|
git submodule add ../sub3 &&
|
|
|
|
git commit -m "add submodule sub"
|
|
|
|
) &&
|
|
|
|
git clone super clone2 &&
|
|
|
|
(
|
|
|
|
cd clone2 &&
|
|
|
|
git submodule update --init --recursive &&
|
|
|
|
echo "gitdir: ../.git/modules/sub3" >./sub3/.git_expect &&
|
|
|
|
echo "gitdir: ../../../.git/modules/sub3/modules/dirdir/subsub" >./sub3/dirdir/subsub/.git_expect
|
|
|
|
) &&
|
|
|
|
test_cmp clone2/sub3/.git_expect clone2/sub3/.git &&
|
|
|
|
test_cmp clone2/sub3/dirdir/subsub/.git_expect clone2/sub3/dirdir/subsub/.git
|
2012-09-29 23:05:58 +00:00
|
|
|
'
|
|
|
|
|
2012-09-30 21:01:29 +00:00
|
|
|
test_expect_success 'submodule add with an existing name fails unless forced' '
|
|
|
|
(
|
|
|
|
cd addtest2 &&
|
|
|
|
rm -rf repo &&
|
|
|
|
git rm repo &&
|
|
|
|
test_must_fail git submodule add -q --name repo_new "$submodurl/repo.git" repo &&
|
|
|
|
test ! -d repo &&
|
2013-08-06 19:15:25 +00:00
|
|
|
test_must_fail git config -f .gitmodules submodule.repo_new.path &&
|
|
|
|
test_must_fail git config -f .gitmodules submodule.repo_new.url &&
|
2012-09-30 21:01:29 +00:00
|
|
|
echo "$submodurl/bare.git" >expect &&
|
|
|
|
git config submodule.repo_new.url >actual &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
git submodule add -f -q --name repo_new "$submodurl/repo.git" repo &&
|
|
|
|
test -d repo &&
|
|
|
|
echo "repo" >expect &&
|
|
|
|
git config -f .gitmodules submodule.repo_new.path >actual &&
|
2020-03-22 21:14:22 +00:00
|
|
|
test_cmp expect actual &&
|
2012-09-30 21:01:29 +00:00
|
|
|
echo "$submodurl/repo.git" >expect &&
|
|
|
|
git config -f .gitmodules submodule.repo_new.url >actual &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
echo "$submodurl/repo.git" >expect &&
|
|
|
|
git config submodule.repo_new.url >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2013-03-04 21:20:24 +00:00
|
|
|
test_expect_success 'set up a second submodule' '
|
|
|
|
git submodule add ./init2 example2 &&
|
|
|
|
git commit -m "submodule example2 added"
|
|
|
|
'
|
|
|
|
|
submodule: fix regression for deinit without submodules
Per Cederqvist wrote:
> It used to be possible to run
>
> git submodule deinit -f .
>
> to remove any submodules, no matter how many submodules you had. That
> is no longer possible in projects that don't have any submodules at
> all. The command will fail with:
>
> error: pathspec '.' did not match any file(s) known to git.
This regression was introduced in 74703a1e4dfc (submodule: rewrite
`module_list` shell function in C, 2015-09-02), as we changed the
order of checking in new module listing to first check whether it is
a gitlin before feeding it to match_pathspec(). It used to be that
a pathspec that does not match any path were diagnosed as an error,
but the new code complains for a pathspec that does not match any
submodule path.
Arguably the new behaviour may give us a better diagnosis, but that
is inconsistent with the suggestion "deinit" gives, and also this
was an unintended accident. The new behaviour hopefully can be
redesigned and implemented better in future releases, but for now,
switch these two checks to restore the same behavior as before. In
an empty repository, giving the pathspec '.' will still get the same
"did not match" error, but that is the same bug we had before 1.7.0.
Reported-by: Per Cederqvist <cederp@opera.com>
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-03-22 23:42:14 +00:00
|
|
|
test_expect_success 'submodule deinit works on repository without submodules' '
|
|
|
|
test_when_finished "rm -rf newdirectory" &&
|
|
|
|
mkdir newdirectory &&
|
|
|
|
(
|
|
|
|
cd newdirectory &&
|
|
|
|
git init &&
|
|
|
|
>file &&
|
|
|
|
git add file &&
|
2016-05-02 22:24:02 +00:00
|
|
|
git commit -m "repo should not be empty" &&
|
2016-05-05 19:52:32 +00:00
|
|
|
git submodule deinit . &&
|
|
|
|
git submodule deinit --all
|
submodule: fix regression for deinit without submodules
Per Cederqvist wrote:
> It used to be possible to run
>
> git submodule deinit -f .
>
> to remove any submodules, no matter how many submodules you had. That
> is no longer possible in projects that don't have any submodules at
> all. The command will fail with:
>
> error: pathspec '.' did not match any file(s) known to git.
This regression was introduced in 74703a1e4dfc (submodule: rewrite
`module_list` shell function in C, 2015-09-02), as we changed the
order of checking in new module listing to first check whether it is
a gitlin before feeding it to match_pathspec(). It used to be that
a pathspec that does not match any path were diagnosed as an error,
but the new code complains for a pathspec that does not match any
submodule path.
Arguably the new behaviour may give us a better diagnosis, but that
is inconsistent with the suggestion "deinit" gives, and also this
was an unintended accident. The new behaviour hopefully can be
redesigned and implemented better in future releases, but for now,
switch these two checks to restore the same behavior as before. In
an empty repository, giving the pathspec '.' will still get the same
"did not match" error, but that is the same bug we had before 1.7.0.
Reported-by: Per Cederqvist <cederp@opera.com>
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-03-22 23:42:14 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2013-03-04 21:20:24 +00:00
|
|
|
test_expect_success 'submodule deinit should remove the whole submodule section from .git/config' '
|
|
|
|
git config submodule.example.foo bar &&
|
|
|
|
git config submodule.example2.frotz nitfol &&
|
|
|
|
git submodule deinit init &&
|
|
|
|
test -z "$(git config --get-regexp "submodule\.example\.")" &&
|
|
|
|
test -n "$(git config --get-regexp "submodule\.example2\.")" &&
|
|
|
|
test -f example2/.git &&
|
|
|
|
rmdir init
|
|
|
|
'
|
|
|
|
|
submodule deinit: unset core.worktree
When a submodule is deinit'd, the working tree is gone, so the setting of
core.worktree is bogus. Unset it. As we covered the only other case in
which a submodule loses its working tree in the earlier step
(i.e. switching branches of top-level project to move to a commit that did
not have the submodule), this makes the code always maintain
core.worktree correctly unset when there is no working tree
for a submodule.
This re-introduces 984cd77ddb (submodule deinit: unset core.worktree,
2018-06-18), which was reverted as part of f178c13fda (Revert "Merge
branch 'sb/submodule-core-worktree'", 2018-09-07)
The whole series was reverted as the offending commit e98317508c
(submodule: ensure core.worktree is set after update, 2018-06-18)
was relied on by other commits such as 984cd77ddb.
Keep the offending commit reverted, but its functionality came back via
4d6d6ef1fc (Merge branch 'sb/submodule-update-in-c', 2018-09-17), such
that we can reintroduce 984cd77ddb now.
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-12-14 23:59:45 +00:00
|
|
|
test_expect_success 'submodule deinit should unset core.worktree' '
|
|
|
|
test_path_is_file .git/modules/example/config &&
|
|
|
|
test_must_fail git config -f .git/modules/example/config core.worktree
|
|
|
|
'
|
|
|
|
|
2013-06-16 14:18:18 +00:00
|
|
|
test_expect_success 'submodule deinit from subdirectory' '
|
|
|
|
git submodule update --init &&
|
|
|
|
git config submodule.example.foo bar &&
|
|
|
|
mkdir -p sub &&
|
|
|
|
(
|
|
|
|
cd sub &&
|
|
|
|
git submodule deinit ../init >../output
|
|
|
|
) &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "\\.\\./init" output &&
|
2013-06-16 14:18:18 +00:00
|
|
|
test -z "$(git config --get-regexp "submodule\.example\.")" &&
|
|
|
|
test -n "$(git config --get-regexp "submodule\.example2\.")" &&
|
|
|
|
test -f example2/.git &&
|
|
|
|
rmdir init
|
|
|
|
'
|
|
|
|
|
2013-03-04 21:20:24 +00:00
|
|
|
test_expect_success 'submodule deinit . deinits all initialized submodules' '
|
|
|
|
git submodule update --init &&
|
|
|
|
git config submodule.example.foo bar &&
|
|
|
|
git config submodule.example2.frotz nitfol &&
|
|
|
|
test_must_fail git submodule deinit &&
|
2013-04-01 19:02:00 +00:00
|
|
|
git submodule deinit . >actual &&
|
2013-03-04 21:20:24 +00:00
|
|
|
test -z "$(git config --get-regexp "submodule\.example\.")" &&
|
|
|
|
test -z "$(git config --get-regexp "submodule\.example2\.")" &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "Cleared directory .init" actual &&
|
|
|
|
test_grep "Cleared directory .example2" actual &&
|
2013-03-04 21:20:24 +00:00
|
|
|
rmdir init example2
|
|
|
|
'
|
|
|
|
|
2016-05-05 19:52:32 +00:00
|
|
|
test_expect_success 'submodule deinit --all deinits all initialized submodules' '
|
|
|
|
git submodule update --init &&
|
|
|
|
git config submodule.example.foo bar &&
|
|
|
|
git config submodule.example2.frotz nitfol &&
|
|
|
|
test_must_fail git submodule deinit &&
|
|
|
|
git submodule deinit --all >actual &&
|
|
|
|
test -z "$(git config --get-regexp "submodule\.example\.")" &&
|
|
|
|
test -z "$(git config --get-regexp "submodule\.example2\.")" &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "Cleared directory .init" actual &&
|
|
|
|
test_grep "Cleared directory .example2" actual &&
|
2016-05-05 19:52:32 +00:00
|
|
|
rmdir init example2
|
|
|
|
'
|
|
|
|
|
2013-03-04 21:20:24 +00:00
|
|
|
test_expect_success 'submodule deinit deinits a submodule when its work tree is missing or empty' '
|
|
|
|
git submodule update --init &&
|
|
|
|
rm -rf init example2/* example2/.git &&
|
2013-04-01 19:02:00 +00:00
|
|
|
git submodule deinit init example2 >actual &&
|
2013-03-04 21:20:24 +00:00
|
|
|
test -z "$(git config --get-regexp "submodule\.example\.")" &&
|
|
|
|
test -z "$(git config --get-regexp "submodule\.example2\.")" &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep ! "Cleared directory .init" actual &&
|
|
|
|
test_grep "Cleared directory .example2" actual &&
|
2013-03-04 21:20:24 +00:00
|
|
|
rmdir init
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'submodule deinit fails when the submodule contains modifications unless forced' '
|
|
|
|
git submodule update --init &&
|
|
|
|
echo X >>init/s &&
|
|
|
|
test_must_fail git submodule deinit init &&
|
|
|
|
test -n "$(git config --get-regexp "submodule\.example\.")" &&
|
|
|
|
test -f example2/.git &&
|
2013-04-01 19:02:00 +00:00
|
|
|
git submodule deinit -f init >actual &&
|
2013-03-04 21:20:24 +00:00
|
|
|
test -z "$(git config --get-regexp "submodule\.example\.")" &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "Cleared directory .init" actual &&
|
2013-03-04 21:20:24 +00:00
|
|
|
rmdir init
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'submodule deinit fails when the submodule contains untracked files unless forced' '
|
|
|
|
git submodule update --init &&
|
|
|
|
echo X >>init/untracked &&
|
|
|
|
test_must_fail git submodule deinit init &&
|
|
|
|
test -n "$(git config --get-regexp "submodule\.example\.")" &&
|
|
|
|
test -f example2/.git &&
|
2013-04-01 19:02:00 +00:00
|
|
|
git submodule deinit -f init >actual &&
|
2013-03-04 21:20:24 +00:00
|
|
|
test -z "$(git config --get-regexp "submodule\.example\.")" &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "Cleared directory .init" actual &&
|
2013-03-04 21:20:24 +00:00
|
|
|
rmdir init
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'submodule deinit fails when the submodule HEAD does not match unless forced' '
|
|
|
|
git submodule update --init &&
|
|
|
|
(
|
|
|
|
cd init &&
|
|
|
|
git checkout HEAD^
|
|
|
|
) &&
|
|
|
|
test_must_fail git submodule deinit init &&
|
|
|
|
test -n "$(git config --get-regexp "submodule\.example\.")" &&
|
|
|
|
test -f example2/.git &&
|
2013-04-01 19:02:00 +00:00
|
|
|
git submodule deinit -f init >actual &&
|
2013-03-04 21:20:24 +00:00
|
|
|
test -z "$(git config --get-regexp "submodule\.example\.")" &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "Cleared directory .init" actual &&
|
2013-03-04 21:20:24 +00:00
|
|
|
rmdir init
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'submodule deinit is silent when used on an uninitialized submodule' '
|
|
|
|
git submodule update --init &&
|
|
|
|
git submodule deinit init >actual &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "Submodule .example. (.*) unregistered for path .init" actual &&
|
|
|
|
test_grep "Cleared directory .init" actual &&
|
2013-03-04 21:20:24 +00:00
|
|
|
git submodule deinit init >actual &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep ! "Submodule .example. (.*) unregistered for path .init" actual &&
|
|
|
|
test_grep "Cleared directory .init" actual &&
|
2013-03-04 21:20:24 +00:00
|
|
|
git submodule deinit . >actual &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep ! "Submodule .example. (.*) unregistered for path .init" actual &&
|
|
|
|
test_grep "Submodule .example2. (.*) unregistered for path .example2" actual &&
|
|
|
|
test_grep "Cleared directory .init" actual &&
|
2013-03-04 21:20:24 +00:00
|
|
|
git submodule deinit . >actual &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep ! "Submodule .example. (.*) unregistered for path .init" actual &&
|
|
|
|
test_grep ! "Submodule .example2. (.*) unregistered for path .example2" actual &&
|
|
|
|
test_grep "Cleared directory .init" actual &&
|
2016-05-05 19:52:32 +00:00
|
|
|
git submodule deinit --all >actual &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep ! "Submodule .example. (.*) unregistered for path .init" actual &&
|
|
|
|
test_grep ! "Submodule .example2. (.*) unregistered for path .example2" actual &&
|
|
|
|
test_grep "Cleared directory .init" actual &&
|
2013-03-04 21:20:24 +00:00
|
|
|
rmdir init example2
|
|
|
|
'
|
|
|
|
|
2021-11-19 10:56:27 +00:00
|
|
|
test_expect_success 'submodule deinit absorbs .git directory if .git is a directory' '
|
2013-03-04 21:20:24 +00:00
|
|
|
git submodule update --init &&
|
|
|
|
(
|
|
|
|
cd init &&
|
|
|
|
rm .git &&
|
2021-11-19 10:56:27 +00:00
|
|
|
mv ../.git/modules/example .git &&
|
2013-03-04 21:20:24 +00:00
|
|
|
GIT_WORK_TREE=. git config --unset core.worktree
|
|
|
|
) &&
|
2021-11-19 10:56:27 +00:00
|
|
|
git submodule deinit init &&
|
|
|
|
test_path_is_missing init/.git &&
|
|
|
|
test -z "$(git config --get-regexp "submodule\.example\.")"
|
2013-03-04 21:20:24 +00:00
|
|
|
'
|
|
|
|
|
2013-06-20 14:58:48 +00:00
|
|
|
test_expect_success 'submodule with UTF-8 name' '
|
|
|
|
svname=$(printf "\303\245 \303\244\303\266") &&
|
|
|
|
mkdir "$svname" &&
|
2013-06-14 00:26:02 +00:00
|
|
|
(
|
2013-06-20 14:58:48 +00:00
|
|
|
cd "$svname" &&
|
2013-06-14 00:26:02 +00:00
|
|
|
git init &&
|
2013-06-20 14:58:48 +00:00
|
|
|
>sub &&
|
|
|
|
git add sub &&
|
2013-06-14 00:26:02 +00:00
|
|
|
git commit -m "init sub"
|
2013-06-20 14:58:48 +00:00
|
|
|
) &&
|
|
|
|
git submodule add ./"$svname" &&
|
|
|
|
git submodule >&2 &&
|
|
|
|
test -n "$(git submodule | grep "$svname")"
|
2013-06-14 00:26:02 +00:00
|
|
|
'
|
2013-07-15 17:28:48 +00:00
|
|
|
|
2013-07-02 21:42:56 +00:00
|
|
|
test_expect_success 'submodule add clone shallow submodule' '
|
|
|
|
mkdir super &&
|
2015-03-20 10:07:15 +00:00
|
|
|
pwd=$(pwd) &&
|
2013-07-02 21:42:56 +00:00
|
|
|
(
|
|
|
|
cd super &&
|
|
|
|
git init &&
|
|
|
|
git submodule add --depth=1 file://"$pwd"/example2 submodule &&
|
|
|
|
(
|
|
|
|
cd submodule &&
|
|
|
|
test 1 = $(git log --oneline | wc -l)
|
|
|
|
)
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2017-03-17 22:38:02 +00:00
|
|
|
test_expect_success 'setup superproject with submodules' '
|
|
|
|
git init sub1 &&
|
|
|
|
test_commit -C sub1 test &&
|
|
|
|
test_commit -C sub1 test2 &&
|
|
|
|
git init multisuper &&
|
|
|
|
git -C multisuper submodule add ../sub1 sub0 &&
|
|
|
|
git -C multisuper submodule add ../sub1 sub1 &&
|
|
|
|
git -C multisuper submodule add ../sub1 sub2 &&
|
|
|
|
git -C multisuper submodule add ../sub1 sub3 &&
|
|
|
|
git -C multisuper commit -m "add some submodules"
|
|
|
|
'
|
|
|
|
|
|
|
|
cat >expect <<-EOF
|
|
|
|
-sub0
|
|
|
|
sub1 (test2)
|
|
|
|
sub2 (test2)
|
|
|
|
sub3 (test2)
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'submodule update --init with a specification' '
|
|
|
|
test_when_finished "rm -rf multisuper_clone" &&
|
|
|
|
pwd=$(pwd) &&
|
|
|
|
git clone file://"$pwd"/multisuper multisuper_clone &&
|
|
|
|
git -C multisuper_clone submodule update --init . ":(exclude)sub0" &&
|
2020-07-29 23:14:03 +00:00
|
|
|
git -C multisuper_clone submodule status | sed "s/$OID_REGEX //" >actual &&
|
2017-03-17 22:38:02 +00:00
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'submodule update --init with submodule.active set' '
|
|
|
|
test_when_finished "rm -rf multisuper_clone" &&
|
|
|
|
pwd=$(pwd) &&
|
|
|
|
git clone file://"$pwd"/multisuper multisuper_clone &&
|
|
|
|
git -C multisuper_clone config submodule.active "." &&
|
|
|
|
git -C multisuper_clone config --add submodule.active ":(exclude)sub0" &&
|
|
|
|
git -C multisuper_clone submodule update --init &&
|
2020-07-29 23:14:03 +00:00
|
|
|
git -C multisuper_clone submodule status | sed "s/$OID_REGEX //" >actual &&
|
2017-03-17 22:38:02 +00:00
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'submodule update and setting submodule.<name>.active' '
|
|
|
|
test_when_finished "rm -rf multisuper_clone" &&
|
|
|
|
pwd=$(pwd) &&
|
|
|
|
git clone file://"$pwd"/multisuper multisuper_clone &&
|
|
|
|
git -C multisuper_clone config --bool submodule.sub0.active "true" &&
|
|
|
|
git -C multisuper_clone config --bool submodule.sub1.active "false" &&
|
|
|
|
git -C multisuper_clone config --bool submodule.sub2.active "true" &&
|
|
|
|
|
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
sub0 (test2)
|
|
|
|
-sub1
|
|
|
|
sub2 (test2)
|
|
|
|
-sub3
|
|
|
|
EOF
|
|
|
|
git -C multisuper_clone submodule update &&
|
2020-07-29 23:14:03 +00:00
|
|
|
git -C multisuper_clone submodule status | sed "s/$OID_REGEX //" >actual &&
|
2017-03-17 22:38:02 +00:00
|
|
|
test_cmp expect actual
|
|
|
|
'
|
2013-07-02 21:42:56 +00:00
|
|
|
|
2018-10-16 17:27:03 +00:00
|
|
|
test_expect_success 'clone active submodule without submodule url set' '
|
|
|
|
test_when_finished "rm -rf test/test" &&
|
|
|
|
mkdir test &&
|
|
|
|
# another dir breaks accidental relative paths still being correct
|
|
|
|
git clone file://"$pwd"/multisuper test/test &&
|
|
|
|
(
|
|
|
|
cd test/test &&
|
|
|
|
git config submodule.active "." &&
|
|
|
|
|
|
|
|
# do not pass --init flag, as the submodule is already active:
|
|
|
|
git submodule update &&
|
|
|
|
git submodule status >actual_raw &&
|
|
|
|
|
2020-07-29 23:14:03 +00:00
|
|
|
cut -d" " -f3- actual_raw >actual &&
|
2018-10-16 17:27:03 +00:00
|
|
|
cat >expect <<-\EOF &&
|
2020-07-29 23:14:03 +00:00
|
|
|
sub0 (test2)
|
|
|
|
sub1 (test2)
|
|
|
|
sub2 (test2)
|
|
|
|
sub3 (test2)
|
2018-10-16 17:27:03 +00:00
|
|
|
EOF
|
|
|
|
test_cmp expect actual
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
builtin/submodule--helper.c: handle missing submodule URLs
In e0a862fdaf (submodule helper: convert relative URL to absolute URL if
needed, 2018-10-16), `prepare_to_clone_next_submodule()` lost the
ability to handle URL-less submodules, due to a change from:
if (repo_get_config_string_const(the_repostiory, sb.buf, &url))
url = sub->url;
to
if (repo_get_config_string_const(the_repostiory, sb.buf, &url)) {
if (starts_with_dot_slash(sub->url) ||
starts_with_dot_dot_slash(sub->url)) {
/* ... */
}
}
, which will segfault when `sub->url` is NULL, since both
`starts_with_dot_slash()` does not guard its arguments as non-NULL.
Guard the checks to both of the above functions by first checking
whether `sub->url` is non-NULL. There is no need to check whether `sub`
itself is NULL, since we already perform this check earlier in
`prepare_to_clone_next_submodule()`.
By adding a NULL-ness check on `sub->url`, we'll fall into the 'else'
branch, setting `url` to `sub->url` (which is NULL). Before attempting
to invoke `git submodule--helper clone`, check whether `url` is NULL,
and die() if it is.
Reported-by: Tribo Dar <3bodar@gmail.com>
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-05-24 19:51:43 +00:00
|
|
|
test_expect_success 'update submodules without url set in .gitconfig' '
|
|
|
|
test_when_finished "rm -rf multisuper_clone" &&
|
|
|
|
git clone file://"$pwd"/multisuper multisuper_clone &&
|
|
|
|
|
|
|
|
git -C multisuper_clone submodule init &&
|
|
|
|
for s in sub0 sub1 sub2 sub3
|
|
|
|
do
|
|
|
|
key=submodule.$s.url &&
|
|
|
|
git -C multisuper_clone config --local --unset $key &&
|
|
|
|
git -C multisuper_clone config --file .gitmodules --unset $key || return 1
|
|
|
|
done &&
|
|
|
|
|
|
|
|
test_must_fail git -C multisuper_clone submodule update 2>err &&
|
|
|
|
grep "cannot clone submodule .sub[0-3]. without a URL" err
|
|
|
|
'
|
|
|
|
|
2017-03-17 22:38:03 +00:00
|
|
|
test_expect_success 'clone --recurse-submodules with a pathspec works' '
|
|
|
|
test_when_finished "rm -rf multisuper_clone" &&
|
|
|
|
cat >expected <<-\EOF &&
|
|
|
|
sub0 (test2)
|
|
|
|
-sub1
|
|
|
|
-sub2
|
|
|
|
-sub3
|
|
|
|
EOF
|
|
|
|
|
|
|
|
git clone --recurse-submodules="sub0" multisuper multisuper_clone &&
|
2020-07-29 23:14:03 +00:00
|
|
|
git -C multisuper_clone submodule status | sed "s/$OID_REGEX //" >actual &&
|
2017-10-06 19:00:06 +00:00
|
|
|
test_cmp expected actual
|
2017-03-17 22:38:03 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'clone with multiple --recurse-submodules options' '
|
|
|
|
test_when_finished "rm -rf multisuper_clone" &&
|
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
-sub0
|
|
|
|
sub1 (test2)
|
|
|
|
-sub2
|
|
|
|
sub3 (test2)
|
|
|
|
EOF
|
|
|
|
|
|
|
|
git clone --recurse-submodules="." \
|
|
|
|
--recurse-submodules=":(exclude)sub0" \
|
|
|
|
--recurse-submodules=":(exclude)sub2" \
|
|
|
|
multisuper multisuper_clone &&
|
2020-07-29 23:14:03 +00:00
|
|
|
git -C multisuper_clone submodule status | sed "s/$OID_REGEX //" >actual &&
|
2017-03-17 22:38:03 +00:00
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'clone and subsequent updates correctly auto-initialize submodules' '
|
|
|
|
test_when_finished "rm -rf multisuper_clone" &&
|
|
|
|
cat <<-\EOF >expect &&
|
|
|
|
-sub0
|
|
|
|
sub1 (test2)
|
|
|
|
-sub2
|
|
|
|
sub3 (test2)
|
|
|
|
EOF
|
|
|
|
|
|
|
|
cat <<-\EOF >expect2 &&
|
|
|
|
-sub0
|
|
|
|
sub1 (test2)
|
|
|
|
-sub2
|
|
|
|
sub3 (test2)
|
|
|
|
-sub4
|
|
|
|
sub5 (test2)
|
|
|
|
EOF
|
|
|
|
|
|
|
|
git clone --recurse-submodules="." \
|
|
|
|
--recurse-submodules=":(exclude)sub0" \
|
|
|
|
--recurse-submodules=":(exclude)sub2" \
|
|
|
|
--recurse-submodules=":(exclude)sub4" \
|
|
|
|
multisuper multisuper_clone &&
|
|
|
|
|
2020-07-29 23:14:03 +00:00
|
|
|
git -C multisuper_clone submodule status | sed "s/$OID_REGEX //" >actual &&
|
2017-03-17 22:38:03 +00:00
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
git -C multisuper submodule add ../sub1 sub4 &&
|
|
|
|
git -C multisuper submodule add ../sub1 sub5 &&
|
|
|
|
git -C multisuper commit -m "add more submodules" &&
|
|
|
|
# obtain the new superproject
|
|
|
|
git -C multisuper_clone pull &&
|
|
|
|
git -C multisuper_clone submodule update --init &&
|
2020-07-29 23:14:03 +00:00
|
|
|
git -C multisuper_clone submodule status | sed "s/$OID_REGEX //" >actual &&
|
2017-03-17 22:38:03 +00:00
|
|
|
test_cmp expect2 actual
|
|
|
|
'
|
|
|
|
|
2017-03-17 22:38:04 +00:00
|
|
|
test_expect_success 'init properly sets the config' '
|
|
|
|
test_when_finished "rm -rf multisuper_clone" &&
|
|
|
|
git clone --recurse-submodules="." \
|
|
|
|
--recurse-submodules=":(exclude)sub0" \
|
|
|
|
multisuper multisuper_clone &&
|
|
|
|
|
|
|
|
git -C multisuper_clone submodule init -- sub0 sub1 &&
|
|
|
|
git -C multisuper_clone config --get submodule.sub0.active &&
|
|
|
|
test_must_fail git -C multisuper_clone config --get submodule.sub1.active
|
|
|
|
'
|
|
|
|
|
2017-08-03 22:25:44 +00:00
|
|
|
test_expect_success 'recursive clone respects -q' '
|
|
|
|
test_when_finished "rm -rf multisuper_clone" &&
|
|
|
|
git clone -q --recurse-submodules multisuper multisuper_clone >actual &&
|
|
|
|
test_must_be_empty actual
|
|
|
|
'
|
|
|
|
|
init.templateDir: consider this config setting protected
The ability to configuring the template directory is a delicate feature:
It allows defining hooks that will be run e.g. during a `git clone`
operation, such as the `post-checkout` hook.
As such, it is of utmost importance that Git would not allow that config
setting to be changed during a `git clone` by mistake, allowing an
attacker a chance for a Remote Code Execution, allowing attackers to run
arbitrary code on unsuspecting users' machines.
As a defense-in-depth measure, to prevent minor vulnerabilities in the
`git clone` code from ballooning into higher-serverity attack vectors,
let's make this a protected setting just like `safe.directory` and
friends, i.e. ignore any `init.templateDir` entries from any local
config.
Note: This does not change the behavior of any recursive clone (modulo
bugs), as the local repository config is not even supposed to be written
while cloning the superproject, except in one scenario: If a config
template is configured that sets the template directory. This might be
done because `git clone --recurse-submodules --template=<directory>`
does not pass that template directory on to the submodules'
initialization.
Another scenario where this commit changes behavior is where
repositories are _not_ cloned recursively, and then some (intentional,
benign) automation configures the template directory to be used before
initializing the submodules.
So the caveat is that this could theoretically break existing processes.
In both scenarios, there is a way out, though: configuring the template
directory via the environment variable `GIT_TEMPLATE_DIR`.
This change in behavior is a trade-off between security and
backwards-compatibility that is struck in favor of security.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
2024-03-29 12:15:32 +00:00
|
|
|
test_expect_success '`submodule init` and `init.templateDir`' '
|
|
|
|
mkdir -p tmpl/hooks &&
|
|
|
|
write_script tmpl/hooks/post-checkout <<-EOF &&
|
|
|
|
echo HOOK-RUN >&2
|
|
|
|
echo I was here >hook.run
|
|
|
|
exit 1
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_config init.templateDir "$(pwd)/tmpl" &&
|
|
|
|
test_when_finished \
|
|
|
|
"git config --global --unset init.templateDir || true" &&
|
|
|
|
(
|
|
|
|
sane_unset GIT_TEMPLATE_DIR &&
|
|
|
|
NO_SET_GIT_TEMPLATE_DIR=t &&
|
|
|
|
export NO_SET_GIT_TEMPLATE_DIR &&
|
|
|
|
|
|
|
|
git config --global init.templateDir "$(pwd)/tmpl" &&
|
|
|
|
test_must_fail git submodule \
|
|
|
|
add "$submodurl" sub-global 2>err &&
|
|
|
|
git config --global --unset init.templateDir &&
|
2024-04-10 20:04:48 +00:00
|
|
|
test_grep HOOK-RUN err &&
|
init.templateDir: consider this config setting protected
The ability to configuring the template directory is a delicate feature:
It allows defining hooks that will be run e.g. during a `git clone`
operation, such as the `post-checkout` hook.
As such, it is of utmost importance that Git would not allow that config
setting to be changed during a `git clone` by mistake, allowing an
attacker a chance for a Remote Code Execution, allowing attackers to run
arbitrary code on unsuspecting users' machines.
As a defense-in-depth measure, to prevent minor vulnerabilities in the
`git clone` code from ballooning into higher-serverity attack vectors,
let's make this a protected setting just like `safe.directory` and
friends, i.e. ignore any `init.templateDir` entries from any local
config.
Note: This does not change the behavior of any recursive clone (modulo
bugs), as the local repository config is not even supposed to be written
while cloning the superproject, except in one scenario: If a config
template is configured that sets the template directory. This might be
done because `git clone --recurse-submodules --template=<directory>`
does not pass that template directory on to the submodules'
initialization.
Another scenario where this commit changes behavior is where
repositories are _not_ cloned recursively, and then some (intentional,
benign) automation configures the template directory to be used before
initializing the submodules.
So the caveat is that this could theoretically break existing processes.
In both scenarios, there is a way out, though: configuring the template
directory via the environment variable `GIT_TEMPLATE_DIR`.
This change in behavior is a trade-off between security and
backwards-compatibility that is struck in favor of security.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
2024-03-29 12:15:32 +00:00
|
|
|
test_path_is_file sub-global/hook.run &&
|
|
|
|
|
|
|
|
git config init.templateDir "$(pwd)/tmpl" &&
|
|
|
|
git submodule add "$submodurl" sub-local 2>err &&
|
|
|
|
git config --unset init.templateDir &&
|
2024-04-10 20:04:48 +00:00
|
|
|
test_grep ! HOOK-RUN err &&
|
init.templateDir: consider this config setting protected
The ability to configuring the template directory is a delicate feature:
It allows defining hooks that will be run e.g. during a `git clone`
operation, such as the `post-checkout` hook.
As such, it is of utmost importance that Git would not allow that config
setting to be changed during a `git clone` by mistake, allowing an
attacker a chance for a Remote Code Execution, allowing attackers to run
arbitrary code on unsuspecting users' machines.
As a defense-in-depth measure, to prevent minor vulnerabilities in the
`git clone` code from ballooning into higher-serverity attack vectors,
let's make this a protected setting just like `safe.directory` and
friends, i.e. ignore any `init.templateDir` entries from any local
config.
Note: This does not change the behavior of any recursive clone (modulo
bugs), as the local repository config is not even supposed to be written
while cloning the superproject, except in one scenario: If a config
template is configured that sets the template directory. This might be
done because `git clone --recurse-submodules --template=<directory>`
does not pass that template directory on to the submodules'
initialization.
Another scenario where this commit changes behavior is where
repositories are _not_ cloned recursively, and then some (intentional,
benign) automation configures the template directory to be used before
initializing the submodules.
So the caveat is that this could theoretically break existing processes.
In both scenarios, there is a way out, though: configuring the template
directory via the environment variable `GIT_TEMPLATE_DIR`.
This change in behavior is a trade-off between security and
backwards-compatibility that is struck in favor of security.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
2024-03-29 12:15:32 +00:00
|
|
|
test_path_is_missing sub-local/hook.run
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2007-06-02 01:27:42 +00:00
|
|
|
test_done
|