git/t/t7400-submodule-basic.sh
Patrick Steinhardt 6771e2012e builtin/submodule--helper: fix leaking buffer in is_tip_reachable
The `rev` buffer in `is_tip_reachable()` is being populated with the
output of git-rev-list(1) -- if either the command fails or the buffer
contains any data, then the input commit is not reachable.

The buffer isn't used for anything else, but neither do we free it,
causing a memory leak. Fix this.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2024-08-01 08:47:35 -07:00

1486 lines
41 KiB
Bash
Executable file

#!/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
subcommands of git submodule.
'
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main
export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME
TEST_PASSES_SANITIZE_LEAK=true
. ./test-lib.sh
test_expect_success 'setup - enable local submodules' '
git config --global protocol.file.allow always
'
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
test_expect_success 'submodule deinit works on empty repository' '
git submodule deinit --all
'
test_expect_success 'setup - initial commit' '
>t &&
git add t &&
git commit -m "initial commit" &&
git branch initial
'
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 &&
test_grep "No url found for submodule path" actual
'
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 &&
test_grep "Submodule path .sub. not initialized" actual
'
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
'
test_expect_success 'add aborts on repository with no commits' '
cat >expect <<-\EOF &&
fatal: '"'repo-no-commits'"' does not have a commit checked out
EOF
git init repo-no-commits &&
test_must_fail git submodule add ../a ./repo-no-commits 2>actual &&
test_cmp expect actual
'
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 &&
test_grep "^error: .*did not match any file(s) known to git" output.err
'
test_expect_success 'setup - repository in init subdirectory' '
mkdir init &&
(
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' '
echo a >a &&
echo z >z &&
git add a init z &&
git commit -m "super commit 1"
'
test_expect_success 'setup - hide init subdirectory' '
mv init .subrepo
'
test_expect_success 'setup - repository to add submodules to' '
git init addtest &&
git init addtest-ignore
'
# The 'submodule add' tests need some repository to add as a submodule.
# 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)
listbranches() {
git for-each-ref --format='%(refname)' 'refs/heads/*'
}
inspect() {
dir=$1 &&
dotdot="${2:-..}" &&
(
cd "$dir" &&
listbranches >"$dotdot/heads" &&
{ git symbolic-ref HEAD || :; } >"$dotdot/head" &&
git rev-parse HEAD >"$dotdot/head-sha1" &&
git update-index --refresh &&
git diff-files --exit-code &&
git clean -n -d -x >"$dotdot/untracked"
)
}
test_expect_success 'submodule add' '
echo "refs/heads/main" >expect &&
(
cd addtest &&
git submodule add -q "$submodurl" submod >actual &&
test_must_be_empty actual &&
echo "gitdir: ../.git/modules/submod" >expect &&
test_cmp expect submod/.git &&
(
cd submod &&
git config core.worktree >actual &&
echo "../../../submod" >expect &&
test_cmp expect actual &&
rm -f actual expect
) &&
git submodule init
) &&
rm -f heads head untracked &&
inspect addtest/submod ../.. &&
test_cmp expect heads &&
test_cmp expect head &&
test_must_be_empty untracked
'
test_expect_success !WINDOWS 'submodule add (absolute path)' '
test_when_finished "git reset --hard" &&
git submodule add "$submodurl" "$submodurl/add-abs"
'
test_expect_success 'setup parent and one repository' '
test_create_repo parent &&
test_commit -C parent one
'
test_expect_success 'redirected submodule add does not show progress' '
git -C addtest submodule add "file://$submodurl/parent" submod-redirected \
2>err &&
! grep % err &&
test_grep ! "Checking connectivity" err
'
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
'
test_expect_success 'submodule add to .gitignored path fails' '
(
cd addtest-ignore &&
cat <<-\EOF >expect &&
The following paths are ignored by one of your .gitignore files:
submod
hint: Use -f if you really want to add them.
hint: Disable this message with "git config advice.addIgnoredFile false"
EOF
# Does not use test_commit due to the ignore
echo "*" > .gitignore &&
git add --force .gitignore &&
git commit -m"Ignore everything" &&
! git submodule add "$submodurl" submod >actual 2>&1 &&
test_cmp expect actual
)
'
test_expect_success 'submodule add to .gitignored path with --force' '
(
cd addtest-ignore &&
git submodule add --force "$submodurl" submod
)
'
test_expect_success 'submodule add to path with tracked content fails' '
(
cd addtest &&
echo "fatal: '\''dir-tracked'\'' already exists in the index" >expect &&
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
)
'
test_expect_success 'submodule add to reconfigure existing submodule with --force' '
(
cd addtest-ignore &&
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)" &&
# Restore the url
git submodule add --force "$submodurl" submod &&
test "$submodurl" = "$(git config -f .gitmodules submodule.submod.url)" &&
test "$submodurl" = "$(git config submodule.submod.url)"
)
'
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 &&
test_grep "^fatal: .*index\.lock" output.err &&
test_path_is_missing sub-while-locked
)
'
test_expect_success 'submodule add --branch' '
echo "refs/heads/initial" >expect-head &&
cat <<-\EOF >expect-heads &&
refs/heads/initial
refs/heads/main
EOF
(
cd addtest &&
git submodule add -b initial "$submodurl" submod-branch &&
test "initial" = "$(git config -f .gitmodules submodule.submod-branch.branch)" &&
git submodule init
) &&
rm -f heads head untracked &&
inspect addtest/submod-branch ../.. &&
test_cmp expect-heads heads &&
test_cmp expect-head head &&
test_must_be_empty untracked
'
test_expect_success 'submodule add with ./ in path' '
echo "refs/heads/main" >expect &&
(
cd addtest &&
git submodule add "$submodurl" ././dotsubmod/./frotz/./ &&
git submodule init
) &&
rm -f heads head untracked &&
inspect addtest/dotsubmod/frotz ../../.. &&
test_cmp expect heads &&
test_cmp expect head &&
test_must_be_empty untracked
'
test_expect_success 'submodule add with /././ in path' '
echo "refs/heads/main" >expect &&
(
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 &&
test_must_be_empty untracked
'
test_expect_success 'submodule add with // in path' '
echo "refs/heads/main" >expect &&
(
cd addtest &&
git submodule add "$submodurl" slashslashsubmod///frotz// &&
git submodule init
) &&
rm -f heads head untracked &&
inspect addtest/slashslashsubmod/frotz ../../.. &&
test_cmp expect heads &&
test_cmp expect head &&
test_must_be_empty untracked
'
test_expect_success 'submodule add with /.. in path' '
echo "refs/heads/main" >expect &&
(
cd addtest &&
git submodule add "$submodurl" dotdotsubmod/../realsubmod/frotz/.. &&
git submodule init
) &&
rm -f heads head untracked &&
inspect addtest/realsubmod ../.. &&
test_cmp expect heads &&
test_cmp expect head &&
test_must_be_empty untracked
'
test_expect_success 'submodule add with ./, /.. and // in path' '
echo "refs/heads/main" >expect &&
(
cd addtest &&
git submodule add "$submodurl" dot/dotslashsubmod/./../..////realsubmod2/a/b/c/d/../../../../frotz//.. &&
git submodule init
) &&
rm -f heads head untracked &&
inspect addtest/realsubmod2 ../.. &&
test_cmp expect heads &&
test_cmp expect head &&
test_must_be_empty untracked
'
test_expect_success !CYGWIN 'submodule add with \\ in path' '
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
'
test_expect_success 'submodule add in subdirectory' '
echo "refs/heads/main" >expect &&
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 &&
test_must_be_empty untracked
'
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
) &&
test_grep toplevel output.err
'
test_expect_success 'setup - add an example entry to .gitmodules' '
git config --file=.gitmodules submodule.example.url git://example.com/init.git
'
test_expect_success 'status should fail for unmapped paths' '
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
git config --file=.gitmodules submodule.example.path init &&
test_cmp expect .gitmodules
'
test_expect_success 'status should only print one line' '
git submodule status >lines &&
test_line_count = 1 lines
'
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
)
'
test_expect_success 'setup - fetch commit name from submodule' '
rev1=$(cd .subrepo && git rev-parse HEAD) &&
printf "rev1: %s\n" "$rev1" &&
test -n "$rev1"
'
test_expect_success 'status should initially be "missing"' '
git submodule status >lines &&
grep "^-$rev1" lines
'
test_expect_success 'init should register submodule url in .git/config' '
echo git://example.com/init.git >expect &&
git submodule init &&
git config submodule.example.url >url &&
git config submodule.example.url ./.subrepo &&
test_cmp expect url
'
test_expect_success 'status should still be "missing" after initializing' '
rm -fr init &&
mkdir init &&
git submodule status >lines &&
rm -fr init &&
grep "^-$rev1" lines
'
test_failure_with_unknown_submodule () {
test_must_fail git submodule $1 no-such-submodule 2>output.err &&
test_grep "^error: .*no-such-submodule" output.err
}
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
'
test_expect_success 'update should fail when path is used by a file' '
echo hello >expect &&
echo "hello" >init &&
test_must_fail git submodule update &&
test_cmp expect init
'
test_expect_success 'update should fail when path is used by a nonempty directory' '
echo hello >expect &&
rm -fr init &&
mkdir init &&
echo "hello" >init/a &&
test_must_fail git submodule update &&
test_cmp expect init/a
'
test_expect_success 'update should work when path is an empty dir' '
rm -fr init &&
rm -f head-sha1 &&
echo "$rev1" >expect &&
mkdir init &&
git submodule update -q >update.out &&
test_must_be_empty update.out &&
inspect init &&
test_cmp expect head-sha1
'
test_expect_success 'status should be "up-to-date" after update' '
git submodule status >list &&
grep "^ $rev1" list
'
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
'
test_expect_success 'status should be "modified" after submodule commit' '
(
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
'
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
'
test_expect_success 'the --cached sha1 should be rev1' '
git submodule --cached status >list &&
grep "^+$rev1" list
'
test_expect_success 'git diff should report the SHA1 of the new submodule commit' '
git diff >diff &&
grep "^+Subproject commit $rev2" diff
'
test_expect_success 'update should checkout rev1' '
rm -f head-sha1 &&
echo "$rev1" >expect &&
git submodule update init &&
inspect init &&
test_cmp expect head-sha1
'
test_expect_success 'status should be "up-to-date" after update' '
git submodule status >list &&
grep "^ $rev1" list
'
test_expect_success 'checkout superproject with subproject already present' '
git checkout initial &&
git checkout main
'
test_expect_success 'apply submodule diff' '
git branch second &&
(
cd init &&
echo s >s &&
git add s &&
git commit -m "change subproject"
) &&
git update-index --add init &&
git commit -m "change init" &&
git format-patch -1 --stdout >P.diff &&
git checkout second &&
git apply --index P.diff &&
git diff --cached main >staged &&
test_must_be_empty staged
'
test_expect_success 'update --init' '
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 &&
git submodule update init 2> update.out &&
test_grep "not initialized" update.out &&
test_must_fail git rev-parse --resolve-git-dir init/.git &&
git submodule update --init init &&
git rev-parse --resolve-git-dir init/.git
'
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 &&
git submodule update ../init 2>update.out &&
test_grep "not initialized" update.out &&
test_must_fail git rev-parse --resolve-git-dir ../init/.git &&
git submodule update --init ../init
) &&
git rev-parse --resolve-git-dir init/.git
'
test_expect_success 'do not add files from a submodule' '
git reset --hard &&
test_must_fail git add init/a
'
test_expect_success 'gracefully add/reset submodule with a trailing slash' '
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 |
sed -n "s/^160000 \([^ ]*\).*/\1/p") &&
git reset init/ &&
git diff --exit-code --cached init
'
test_expect_success 'ls-files gracefully handles trailing slash' '
test "init" = "$(git ls-files init/)"
'
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
'
test_expect_success 'submodule <invalid-subcommand> fails' '
test_must_fail git submodule no-such-subcommand
'
test_expect_success 'add submodules without specifying an explicit path' '
mkdir repo &&
(
cd repo &&
git init &&
echo r >r &&
git add r &&
git commit -m "repo commit 1"
) &&
git clone --bare repo/ bare.git &&
(
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
)
'
test_expect_success 'use superproject as upstream when path is relative and no url is set there' '
(
cd addtest &&
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"
)
'
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 &&
cp .git/config pristine-.git-config &&
cp .gitmodules pristine-.gitmodules
)
'
test_expect_success '../subrepo works with URL - ssh://hostname/repo' '
(
cd reltest &&
cp pristine-.git-config .git/config &&
cp pristine-.gitmodules .gitmodules &&
git config remote.origin.url ssh://hostname/repo &&
git submodule init &&
test "$(git config submodule.sub.url)" = ssh://hostname/subrepo
)
'
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
)
'
# 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' '
(
cd reltest &&
cp pristine-.git-config .git/config &&
cp pristine-.gitmodules .gitmodules &&
git config remote.origin.url "//somewhere else/repo" &&
git submodule init &&
test "$(git config submodule.sub.url)" = "//somewhere else/subrepo"
)
'
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' '
(
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
)
'
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
)
'
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 &&
# actual: fails with an error
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 '../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 '../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 &&
(cd a/b/c && git init && test_commit msg) &&
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
)
'
test_expect_success 'moving the superproject does not break submodules' '
(
cd addtest &&
git submodule status >expect
) &&
mv addtest addtest2 &&
(
cd addtest2 &&
git submodule status >actual &&
test_cmp expect actual
)
'
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
'
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 &&
test_must_be_empty actual &&
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 &&
test_must_fail git config -f .gitmodules submodule.repo.path &&
git config -f .gitmodules submodule.repo_new.path >actual &&
test_cmp expect actual &&
echo "$submodurl/repo" >expect &&
test_must_fail git config -f .gitmodules submodule.repo.url &&
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
)
'
test_expect_success 'recursive relative submodules stay relative' '
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
'
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 &&
test_must_fail git config -f .gitmodules submodule.repo_new.path &&
test_must_fail git config -f .gitmodules submodule.repo_new.url &&
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 &&
test_cmp expect actual &&
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
)
'
test_expect_success 'set up a second submodule' '
git submodule add ./init2 example2 &&
git commit -m "submodule example2 added"
'
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 &&
git commit -m "repo should not be empty" &&
git submodule deinit . &&
git submodule deinit --all
)
'
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
'
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
'
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
) &&
test_grep "\\.\\./init" output &&
test -z "$(git config --get-regexp "submodule\.example\.")" &&
test -n "$(git config --get-regexp "submodule\.example2\.")" &&
test -f example2/.git &&
rmdir init
'
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 &&
git submodule deinit . >actual &&
test -z "$(git config --get-regexp "submodule\.example\.")" &&
test -z "$(git config --get-regexp "submodule\.example2\.")" &&
test_grep "Cleared directory .init" actual &&
test_grep "Cleared directory .example2" actual &&
rmdir init example2
'
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\.")" &&
test_grep "Cleared directory .init" actual &&
test_grep "Cleared directory .example2" actual &&
rmdir init example2
'
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 &&
git submodule deinit init example2 >actual &&
test -z "$(git config --get-regexp "submodule\.example\.")" &&
test -z "$(git config --get-regexp "submodule\.example2\.")" &&
test_grep ! "Cleared directory .init" actual &&
test_grep "Cleared directory .example2" actual &&
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 &&
git submodule deinit -f init >actual &&
test -z "$(git config --get-regexp "submodule\.example\.")" &&
test_grep "Cleared directory .init" actual &&
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 &&
git submodule deinit -f init >actual &&
test -z "$(git config --get-regexp "submodule\.example\.")" &&
test_grep "Cleared directory .init" actual &&
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 &&
git submodule deinit -f init >actual &&
test -z "$(git config --get-regexp "submodule\.example\.")" &&
test_grep "Cleared directory .init" actual &&
rmdir init
'
test_expect_success 'submodule deinit is silent when used on an uninitialized submodule' '
git submodule update --init &&
git submodule deinit init >actual &&
test_grep "Submodule .example. (.*) unregistered for path .init" actual &&
test_grep "Cleared directory .init" actual &&
git submodule deinit init >actual &&
test_grep ! "Submodule .example. (.*) unregistered for path .init" actual &&
test_grep "Cleared directory .init" actual &&
git submodule deinit . >actual &&
test_grep ! "Submodule .example. (.*) unregistered for path .init" actual &&
test_grep "Submodule .example2. (.*) unregistered for path .example2" actual &&
test_grep "Cleared directory .init" actual &&
git submodule deinit . >actual &&
test_grep ! "Submodule .example. (.*) unregistered for path .init" actual &&
test_grep ! "Submodule .example2. (.*) unregistered for path .example2" actual &&
test_grep "Cleared directory .init" actual &&
git submodule deinit --all >actual &&
test_grep ! "Submodule .example. (.*) unregistered for path .init" actual &&
test_grep ! "Submodule .example2. (.*) unregistered for path .example2" actual &&
test_grep "Cleared directory .init" actual &&
rmdir init example2
'
test_expect_success 'submodule deinit absorbs .git directory if .git is a directory' '
git submodule update --init &&
(
cd init &&
rm .git &&
mv ../.git/modules/example .git &&
GIT_WORK_TREE=. git config --unset core.worktree
) &&
git submodule deinit init &&
test_path_is_missing init/.git &&
test -z "$(git config --get-regexp "submodule\.example\.")"
'
test_expect_success 'submodule with UTF-8 name' '
svname=$(printf "\303\245 \303\244\303\266") &&
mkdir "$svname" &&
(
cd "$svname" &&
git init &&
>sub &&
git add sub &&
git commit -m "init sub"
) &&
git submodule add ./"$svname" &&
git submodule >&2 &&
test -n "$(git submodule | grep "$svname")"
'
test_expect_success 'submodule add clone shallow submodule' '
mkdir super &&
pwd=$(pwd) &&
(
cd super &&
git init &&
git submodule add --depth=1 file://"$pwd"/example2 submodule &&
(
cd submodule &&
test 1 = $(git log --oneline | wc -l)
)
)
'
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" &&
git -C multisuper_clone submodule status | sed "s/$OID_REGEX //" >actual &&
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 &&
git -C multisuper_clone submodule status | sed "s/$OID_REGEX //" >actual &&
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 &&
git -C multisuper_clone submodule status | sed "s/$OID_REGEX //" >actual &&
test_cmp expect actual
'
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 &&
cut -d" " -f3- actual_raw >actual &&
cat >expect <<-\EOF &&
sub0 (test2)
sub1 (test2)
sub2 (test2)
sub3 (test2)
EOF
test_cmp expect actual
)
'
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
'
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 &&
git -C multisuper_clone submodule status | sed "s/$OID_REGEX //" >actual &&
test_cmp expected actual
'
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 &&
git -C multisuper_clone submodule status | sed "s/$OID_REGEX //" >actual &&
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 &&
git -C multisuper_clone submodule status | sed "s/$OID_REGEX //" >actual &&
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 &&
git -C multisuper_clone submodule status | sed "s/$OID_REGEX //" >actual &&
test_cmp expect2 actual
'
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
'
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
'
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 &&
test_grep HOOK-RUN err &&
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 &&
test_grep ! HOOK-RUN err &&
test_path_is_missing sub-local/hook.run
)
'
test_done