2014-11-30 08:24:47 +00:00
|
|
|
#!/bin/sh
|
|
|
|
|
2015-07-06 17:30:54 +00:00
|
|
|
test_description='test git worktree add'
|
2014-11-30 08:24:47 +00:00
|
|
|
|
2020-11-18 23:44:22 +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
|
|
|
|
|
2022-06-03 11:15:05 +00:00
|
|
|
TEST_CREATE_REPO_NO_TEMPLATE=1
|
2014-11-30 08:24:47 +00:00
|
|
|
. ./test-lib.sh
|
|
|
|
|
2016-04-22 13:01:33 +00:00
|
|
|
. "$TEST_DIRECTORY"/lib-rebase.sh
|
|
|
|
|
2014-11-30 08:24:47 +00:00
|
|
|
test_expect_success 'setup' '
|
|
|
|
test_commit init
|
|
|
|
'
|
|
|
|
|
2015-07-06 17:30:54 +00:00
|
|
|
test_expect_success '"add" an existing worktree' '
|
2014-11-30 08:24:58 +00:00
|
|
|
mkdir -p existing/subtree &&
|
2020-11-18 23:44:22 +00:00
|
|
|
test_must_fail git worktree add --detach existing main
|
2014-11-30 08:24:47 +00:00
|
|
|
'
|
|
|
|
|
2015-07-06 17:30:54 +00:00
|
|
|
test_expect_success '"add" an existing empty worktree' '
|
2014-11-30 08:24:58 +00:00
|
|
|
mkdir existing_empty &&
|
2020-11-18 23:44:22 +00:00
|
|
|
git worktree add --detach existing_empty main
|
2014-11-30 08:24:58 +00:00
|
|
|
'
|
|
|
|
|
2016-05-27 13:17:08 +00:00
|
|
|
test_expect_success '"add" using shorthand - fails when no previous branch' '
|
|
|
|
test_must_fail git worktree add existing_short -
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '"add" using - shorthand' '
|
|
|
|
git checkout -b newbranch &&
|
|
|
|
echo hello >myworld &&
|
|
|
|
git add myworld &&
|
|
|
|
git commit -m myworld &&
|
2020-11-18 23:44:22 +00:00
|
|
|
git checkout main &&
|
2016-05-27 13:17:08 +00:00
|
|
|
git worktree add short-hand - &&
|
|
|
|
echo refs/heads/newbranch >expect &&
|
|
|
|
git -C short-hand rev-parse --symbolic-full-name HEAD >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2015-07-06 17:30:54 +00:00
|
|
|
test_expect_success '"add" refuses to checkout locked branch' '
|
2020-11-18 23:44:22 +00:00
|
|
|
test_must_fail git worktree add zere main &&
|
2014-11-30 08:24:50 +00:00
|
|
|
! test -d zere &&
|
|
|
|
! test -d .git/worktrees/zere
|
|
|
|
'
|
|
|
|
|
2015-06-12 10:49:24 +00:00
|
|
|
test_expect_success 'checking out paths not complaining about linked checkouts' '
|
|
|
|
(
|
|
|
|
cd existing_empty &&
|
|
|
|
echo dirty >>init.t &&
|
2020-11-18 23:44:22 +00:00
|
|
|
git checkout main -- init.t
|
2015-06-12 10:49:24 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2015-07-06 17:30:54 +00:00
|
|
|
test_expect_success '"add" worktree' '
|
2014-11-30 08:24:49 +00:00
|
|
|
git rev-parse HEAD >expect &&
|
2020-11-18 23:44:22 +00:00
|
|
|
git worktree add --detach here main &&
|
2014-11-30 08:24:47 +00:00
|
|
|
(
|
|
|
|
cd here &&
|
|
|
|
test_cmp ../init.t init.t &&
|
2014-11-30 08:24:49 +00:00
|
|
|
test_must_fail git symbolic-ref HEAD &&
|
|
|
|
git rev-parse HEAD >actual &&
|
|
|
|
test_cmp ../expect actual &&
|
2014-11-30 08:24:47 +00:00
|
|
|
git fsck
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2017-04-12 13:58:05 +00:00
|
|
|
test_expect_success '"add" worktree with lock' '
|
2020-11-18 23:44:22 +00:00
|
|
|
git worktree add --detach --lock here-with-lock main &&
|
2021-07-11 00:27:18 +00:00
|
|
|
test_when_finished "git worktree unlock here-with-lock || :" &&
|
2017-04-12 13:58:05 +00:00
|
|
|
test -f .git/worktrees/here-with-lock/locked
|
|
|
|
'
|
|
|
|
|
2021-07-15 02:32:30 +00:00
|
|
|
test_expect_success '"add" worktree with lock and reason' '
|
|
|
|
lock_reason="why not" &&
|
|
|
|
git worktree add --detach --lock --reason "$lock_reason" here-with-lock-reason main &&
|
|
|
|
test_when_finished "git worktree unlock here-with-lock-reason || :" &&
|
|
|
|
test -f .git/worktrees/here-with-lock-reason/locked &&
|
|
|
|
echo "$lock_reason" >expect &&
|
|
|
|
test_cmp expect .git/worktrees/here-with-lock-reason/locked
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '"add" worktree with reason but no lock' '
|
|
|
|
test_must_fail git worktree add --detach --reason "why not" here-with-reason-only main &&
|
|
|
|
test_path_is_missing .git/worktrees/here-with-reason-only/locked
|
|
|
|
'
|
|
|
|
|
2015-07-06 17:30:54 +00:00
|
|
|
test_expect_success '"add" worktree from a subdir' '
|
2014-11-30 08:24:47 +00:00
|
|
|
(
|
|
|
|
mkdir sub &&
|
|
|
|
cd sub &&
|
2020-11-18 23:44:22 +00:00
|
|
|
git worktree add --detach here main &&
|
2014-11-30 08:24:47 +00:00
|
|
|
cd here &&
|
|
|
|
test_cmp ../../init.t init.t
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2015-07-06 17:30:54 +00:00
|
|
|
test_expect_success '"add" from a linked checkout' '
|
2014-11-30 08:24:47 +00:00
|
|
|
(
|
|
|
|
cd here &&
|
2020-11-18 23:44:22 +00:00
|
|
|
git worktree add --detach nested-here main &&
|
2014-11-30 08:24:47 +00:00
|
|
|
cd nested-here &&
|
|
|
|
git fsck
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2015-07-06 17:30:54 +00:00
|
|
|
test_expect_success '"add" worktree creating new branch' '
|
2020-11-18 23:44:22 +00:00
|
|
|
git worktree add -b newmain there main &&
|
2014-11-30 08:24:47 +00:00
|
|
|
(
|
|
|
|
cd there &&
|
|
|
|
test_cmp ../init.t init.t &&
|
|
|
|
git symbolic-ref HEAD >actual &&
|
2020-11-18 23:44:22 +00:00
|
|
|
echo refs/heads/newmain >expect &&
|
2014-11-30 08:24:47 +00:00
|
|
|
test_cmp expect actual &&
|
|
|
|
git fsck
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2014-11-30 08:24:49 +00:00
|
|
|
test_expect_success 'die the same branch is already checked out' '
|
|
|
|
(
|
|
|
|
cd here &&
|
2020-11-18 23:44:22 +00:00
|
|
|
test_must_fail git checkout newmain
|
2014-11-30 08:24:49 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2015-07-17 23:00:03 +00:00
|
|
|
test_expect_success SYMLINKS 'die the same branch is already checked out (symlink)' '
|
|
|
|
head=$(git -C there rev-parse --git-path HEAD) &&
|
|
|
|
ref=$(git -C there symbolic-ref HEAD) &&
|
|
|
|
rm "$head" &&
|
|
|
|
ln -s "$ref" "$head" &&
|
2020-11-18 23:44:22 +00:00
|
|
|
test_must_fail git -C here checkout newmain
|
2015-07-17 23:00:03 +00:00
|
|
|
'
|
|
|
|
|
2015-01-03 09:41:26 +00:00
|
|
|
test_expect_success 'not die the same branch is already checked out' '
|
|
|
|
(
|
|
|
|
cd here &&
|
2020-11-18 23:44:22 +00:00
|
|
|
git worktree add --force anothernewmain newmain
|
2015-01-03 09:41:26 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2014-11-30 08:24:49 +00:00
|
|
|
test_expect_success 'not die on re-checking out current branch' '
|
|
|
|
(
|
|
|
|
cd there &&
|
2020-11-18 23:44:22 +00:00
|
|
|
git checkout newmain
|
2014-11-30 08:24:49 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2015-07-06 17:30:54 +00:00
|
|
|
test_expect_success '"add" from a bare repo' '
|
2014-11-30 08:24:56 +00:00
|
|
|
(
|
|
|
|
git clone --bare . bare &&
|
|
|
|
cd bare &&
|
2020-11-18 23:44:22 +00:00
|
|
|
git worktree add -b bare-main ../there2 main
|
2014-11-30 08:24:56 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2015-07-06 17:30:54 +00:00
|
|
|
test_expect_success 'checkout from a bare repo without "add"' '
|
2014-11-30 08:24:56 +00:00
|
|
|
(
|
|
|
|
cd bare &&
|
2020-11-18 23:44:22 +00:00
|
|
|
test_must_fail git checkout main
|
2014-11-30 08:24:56 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2016-10-12 16:41:07 +00:00
|
|
|
test_expect_success '"add" default branch of a bare repo' '
|
|
|
|
(
|
|
|
|
git clone --bare . bare2 &&
|
|
|
|
cd bare2 &&
|
2022-02-07 21:33:02 +00:00
|
|
|
git worktree add ../there3 main &&
|
|
|
|
cd ../there3 &&
|
|
|
|
# Simple check that a Git command does not
|
|
|
|
# immediately fail with the current setup
|
|
|
|
git status
|
|
|
|
) &&
|
|
|
|
cat >expect <<-EOF &&
|
|
|
|
init.t
|
|
|
|
EOF
|
|
|
|
ls there3 >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '"add" to bare repo with worktree config' '
|
|
|
|
(
|
|
|
|
git clone --bare . bare3 &&
|
|
|
|
cd bare3 &&
|
|
|
|
git config extensions.worktreeconfig true &&
|
|
|
|
|
|
|
|
# Add config values that are erroneous to have in
|
|
|
|
# a config.worktree file outside of the main
|
|
|
|
# working tree, to check that Git filters them out
|
|
|
|
# when copying config during "git worktree add".
|
|
|
|
git config --worktree core.bare true &&
|
|
|
|
git config --worktree core.worktree "$(pwd)" &&
|
|
|
|
|
|
|
|
# We want to check that bogus.key is copied
|
|
|
|
git config --worktree bogus.key value &&
|
|
|
|
git config --unset core.bare &&
|
|
|
|
git worktree add ../there4 main &&
|
|
|
|
cd ../there4 &&
|
|
|
|
|
|
|
|
# Simple check that a Git command does not
|
|
|
|
# immediately fail with the current setup
|
|
|
|
git status &&
|
|
|
|
git worktree add --detach ../there5 &&
|
|
|
|
cd ../there5 &&
|
|
|
|
git status
|
|
|
|
) &&
|
|
|
|
|
|
|
|
# the worktree has the arbitrary value copied.
|
|
|
|
test_cmp_config -C there4 value bogus.key &&
|
|
|
|
test_cmp_config -C there5 value bogus.key &&
|
|
|
|
|
|
|
|
# however, core.bare and core.worktree were removed.
|
|
|
|
test_must_fail git -C there4 config core.bare &&
|
|
|
|
test_must_fail git -C there4 config core.worktree &&
|
|
|
|
|
|
|
|
cat >expect <<-EOF &&
|
|
|
|
init.t
|
|
|
|
EOF
|
|
|
|
|
|
|
|
ls there4 >actual &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
ls there5 >actual &&
|
|
|
|
test_cmp expect actual
|
2016-10-12 16:41:07 +00:00
|
|
|
'
|
|
|
|
|
2014-11-30 08:24:57 +00:00
|
|
|
test_expect_success 'checkout with grafts' '
|
|
|
|
test_when_finished rm .git/info/grafts &&
|
|
|
|
test_commit abc &&
|
2015-12-22 15:05:52 +00:00
|
|
|
SHA1=$(git rev-parse HEAD) &&
|
2014-11-30 08:24:57 +00:00
|
|
|
test_commit def &&
|
|
|
|
test_commit xyz &&
|
2022-06-03 11:15:05 +00:00
|
|
|
mkdir .git/info &&
|
2015-12-22 15:05:52 +00:00
|
|
|
echo "$(git rev-parse HEAD) $SHA1" >.git/info/grafts &&
|
2014-11-30 08:24:57 +00:00
|
|
|
cat >expected <<-\EOF &&
|
|
|
|
xyz
|
|
|
|
abc
|
|
|
|
EOF
|
|
|
|
git log --format=%s -2 >actual &&
|
|
|
|
test_cmp expected actual &&
|
2020-11-18 23:44:22 +00:00
|
|
|
git worktree add --detach grafted main &&
|
2014-11-30 08:24:57 +00:00
|
|
|
git --git-dir=grafted/.git log --format=%s -2 >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2015-07-06 17:30:54 +00:00
|
|
|
test_expect_success '"add" from relative HEAD' '
|
2015-07-06 17:30:45 +00:00
|
|
|
test_commit a &&
|
|
|
|
test_commit b &&
|
|
|
|
test_commit c &&
|
|
|
|
git rev-parse HEAD~1 >expected &&
|
2015-07-06 17:30:54 +00:00
|
|
|
git worktree add relhead HEAD~1 &&
|
2015-07-06 17:30:45 +00:00
|
|
|
git -C relhead rev-parse HEAD >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2015-07-06 17:30:58 +00:00
|
|
|
test_expect_success '"add -b" with <branch> omitted' '
|
|
|
|
git worktree add -b burble flornk &&
|
|
|
|
test_cmp_rev HEAD burble
|
|
|
|
'
|
|
|
|
|
2015-07-17 23:00:09 +00:00
|
|
|
test_expect_success '"add --detach" with <branch> omitted' '
|
|
|
|
git worktree add --detach fishhook &&
|
|
|
|
git rev-parse HEAD >expected &&
|
|
|
|
git -C fishhook rev-parse HEAD >actual &&
|
|
|
|
test_cmp expected actual &&
|
|
|
|
test_must_fail git -C fishhook symbolic-ref HEAD
|
|
|
|
'
|
|
|
|
|
2015-07-06 17:30:59 +00:00
|
|
|
test_expect_success '"add" with <branch> omitted' '
|
|
|
|
git worktree add wiffle/bat &&
|
|
|
|
test_cmp_rev HEAD bat
|
|
|
|
'
|
|
|
|
|
2018-04-24 21:56:35 +00:00
|
|
|
test_expect_success '"add" checks out existing branch of dwimd name' '
|
|
|
|
git branch dwim HEAD~1 &&
|
|
|
|
git worktree add dwim &&
|
|
|
|
test_cmp_rev HEAD~1 dwim &&
|
|
|
|
(
|
|
|
|
cd dwim &&
|
|
|
|
test_cmp_rev HEAD dwim
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '"add <path>" dwim fails with checked out branch' '
|
|
|
|
git checkout -b test-branch &&
|
|
|
|
test_must_fail git worktree add test-branch &&
|
|
|
|
test_path_is_missing test-branch
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '"add --force" with existing dwimd name doesnt die' '
|
|
|
|
git checkout test-branch &&
|
|
|
|
git worktree add --force test-branch
|
2015-07-06 17:30:59 +00:00
|
|
|
'
|
|
|
|
|
2015-07-17 23:00:09 +00:00
|
|
|
test_expect_success '"add" no auto-vivify with --detach and <branch> omitted' '
|
|
|
|
git worktree add --detach mish/mash &&
|
|
|
|
test_must_fail git rev-parse mash -- &&
|
|
|
|
test_must_fail git -C mish/mash symbolic-ref HEAD
|
|
|
|
'
|
|
|
|
|
2023-05-17 21:48:35 +00:00
|
|
|
# Helper function to test mutually exclusive options.
|
|
|
|
#
|
|
|
|
# Note: Quoted arguments containing spaces are not supported.
|
|
|
|
test_wt_add_excl () {
|
|
|
|
local opts="$*" &&
|
|
|
|
test_expect_success "'worktree add' with '$opts' has mutually exclusive options" '
|
|
|
|
test_must_fail git worktree add $opts 2>actual &&
|
|
|
|
grep -E "fatal:( options)? .* cannot be used together" actual
|
|
|
|
'
|
|
|
|
}
|
|
|
|
|
|
|
|
test_wt_add_excl -b poodle -B poodle bamboo main
|
|
|
|
test_wt_add_excl -b poodle --detach bamboo main
|
|
|
|
test_wt_add_excl -B poodle --detach bamboo main
|
2023-05-17 21:48:47 +00:00
|
|
|
test_wt_add_excl --orphan --detach bamboo
|
|
|
|
test_wt_add_excl --orphan --no-checkout bamboo
|
|
|
|
test_wt_add_excl --orphan bamboo main
|
|
|
|
test_wt_add_excl --orphan -b bamboo wtdir/ main
|
2015-07-17 23:00:08 +00:00
|
|
|
|
2016-02-15 13:35:33 +00:00
|
|
|
test_expect_success '"add -B" fails if the branch is checked out' '
|
2020-11-18 23:44:22 +00:00
|
|
|
git rev-parse newmain >before &&
|
|
|
|
test_must_fail git worktree add -B newmain bamboo main &&
|
|
|
|
git rev-parse newmain >after &&
|
2016-02-15 13:35:33 +00:00
|
|
|
test_cmp before after
|
|
|
|
'
|
|
|
|
|
2016-02-15 13:35:32 +00:00
|
|
|
test_expect_success 'add -B' '
|
2020-11-18 23:44:22 +00:00
|
|
|
git worktree add -B poodle bamboo2 main^ &&
|
2016-02-15 13:35:32 +00:00
|
|
|
git -C bamboo2 symbolic-ref HEAD >actual &&
|
|
|
|
echo refs/heads/poodle >expected &&
|
|
|
|
test_cmp expected actual &&
|
2020-11-18 23:44:22 +00:00
|
|
|
test_cmp_rev main^ poodle
|
2016-02-15 13:35:32 +00:00
|
|
|
'
|
|
|
|
|
2018-08-15 20:56:30 +00:00
|
|
|
test_expect_success 'add --quiet' '
|
2023-05-17 21:48:28 +00:00
|
|
|
test_when_finished "git worktree remove -f -f another-worktree" &&
|
2020-11-18 23:44:22 +00:00
|
|
|
git worktree add --quiet another-worktree main 2>actual &&
|
2018-08-15 20:56:30 +00:00
|
|
|
test_must_be_empty actual
|
|
|
|
'
|
|
|
|
|
2023-05-17 21:48:40 +00:00
|
|
|
test_expect_success 'add --quiet -b' '
|
|
|
|
test_when_finished "git branch -D quietnewbranch" &&
|
|
|
|
test_when_finished "git worktree remove -f -f another-worktree" &&
|
|
|
|
git worktree add --quiet -b quietnewbranch another-worktree 2>actual &&
|
|
|
|
test_must_be_empty actual
|
|
|
|
'
|
|
|
|
|
2023-05-17 21:48:47 +00:00
|
|
|
test_expect_success '"add --orphan"' '
|
|
|
|
test_when_finished "git worktree remove -f -f orphandir" &&
|
|
|
|
git worktree add --orphan -b neworphan orphandir &&
|
|
|
|
echo refs/heads/neworphan >expected &&
|
|
|
|
git -C orphandir symbolic-ref HEAD >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '"add --orphan (no -b)"' '
|
|
|
|
test_when_finished "git worktree remove -f -f neworphan" &&
|
|
|
|
git worktree add --orphan neworphan &&
|
|
|
|
echo refs/heads/neworphan >expected &&
|
|
|
|
git -C neworphan symbolic-ref HEAD >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '"add --orphan --quiet"' '
|
|
|
|
test_when_finished "git worktree remove -f -f orphandir" &&
|
|
|
|
git worktree add --quiet --orphan -b neworphan orphandir 2>log.actual &&
|
|
|
|
test_must_be_empty log.actual &&
|
|
|
|
echo refs/heads/neworphan >expected &&
|
|
|
|
git -C orphandir symbolic-ref HEAD >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '"add --orphan" fails if the branch already exists' '
|
|
|
|
test_when_finished "git branch -D existingbranch" &&
|
|
|
|
git worktree add -b existingbranch orphandir main &&
|
|
|
|
git worktree remove orphandir &&
|
|
|
|
test_must_fail git worktree add --orphan -b existingbranch orphandir
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '"add --orphan" with empty repository' '
|
|
|
|
test_when_finished "rm -rf empty_repo" &&
|
|
|
|
echo refs/heads/newbranch >expected &&
|
|
|
|
GIT_DIR="empty_repo" git init --bare &&
|
|
|
|
git -C empty_repo worktree add --orphan -b newbranch worktreedir &&
|
|
|
|
git -C empty_repo/worktreedir symbolic-ref HEAD >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '"add" worktree with orphan branch and lock' '
|
|
|
|
git worktree add --lock --orphan -b orphanbr orphan-with-lock &&
|
|
|
|
test_when_finished "git worktree unlock orphan-with-lock || :" &&
|
|
|
|
test -f .git/worktrees/orphan-with-lock/locked
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '"add" worktree with orphan branch, lock, and reason' '
|
|
|
|
lock_reason="why not" &&
|
|
|
|
git worktree add --detach --lock --reason "$lock_reason" orphan-with-lock-reason main &&
|
|
|
|
test_when_finished "git worktree unlock orphan-with-lock-reason || :" &&
|
|
|
|
test -f .git/worktrees/orphan-with-lock-reason/locked &&
|
|
|
|
echo "$lock_reason" >expect &&
|
|
|
|
test_cmp expect .git/worktrees/orphan-with-lock-reason/locked
|
|
|
|
'
|
|
|
|
|
2023-05-17 21:48:52 +00:00
|
|
|
# Note: Quoted arguments containing spaces are not supported.
|
|
|
|
test_wt_add_orphan_hint () {
|
|
|
|
local context="$1" &&
|
|
|
|
local use_branch=$2 &&
|
|
|
|
shift 2 &&
|
|
|
|
local opts="$*" &&
|
|
|
|
test_expect_success "'worktree add' show orphan hint in bad/orphan HEAD w/ $context" '
|
|
|
|
test_when_finished "rm -rf repo" &&
|
|
|
|
git init repo &&
|
|
|
|
(cd repo && test_commit commit) &&
|
|
|
|
git -C repo switch --orphan noref &&
|
|
|
|
test_must_fail git -C repo worktree add $opts foobar/ 2>actual &&
|
|
|
|
! grep "error: unknown switch" actual &&
|
|
|
|
grep "hint: If you meant to create a worktree containing a new orphan branch" actual &&
|
|
|
|
if [ $use_branch -eq 1 ]
|
|
|
|
then
|
|
|
|
grep -E "^hint:\s+git worktree add --orphan -b \S+ \S+\s*$" actual
|
|
|
|
else
|
|
|
|
grep -E "^hint:\s+git worktree add --orphan \S+\s*$" actual
|
|
|
|
fi
|
|
|
|
|
|
|
|
'
|
|
|
|
}
|
|
|
|
|
|
|
|
test_wt_add_orphan_hint 'no opts' 0
|
|
|
|
test_wt_add_orphan_hint '-b' 1 -b foobar_branch
|
|
|
|
test_wt_add_orphan_hint '-B' 1 -B foobar_branch
|
|
|
|
|
|
|
|
test_expect_success "'worktree add' doesn't show orphan hint in bad/orphan HEAD w/ --quiet" '
|
|
|
|
test_when_finished "rm -rf repo" &&
|
|
|
|
git init repo &&
|
|
|
|
(cd repo && test_commit commit) &&
|
|
|
|
test_must_fail git -C repo worktree add --quiet foobar_branch foobar/ 2>actual &&
|
|
|
|
! grep "error: unknown switch" actual &&
|
|
|
|
! grep "hint: If you meant to create a worktree containing a new orphan branch" actual
|
|
|
|
'
|
|
|
|
|
2015-09-28 13:06:15 +00:00
|
|
|
test_expect_success 'local clone from linked checkout' '
|
|
|
|
git clone --local here here-clone &&
|
|
|
|
( cd here-clone && git fsck )
|
|
|
|
'
|
|
|
|
|
2017-12-11 23:16:12 +00:00
|
|
|
test_expect_success 'local clone --shared from linked checkout' '
|
|
|
|
git -C bare worktree add --detach ../baretree &&
|
|
|
|
git clone --local --shared baretree bare-clone &&
|
|
|
|
grep /bare/ bare-clone/.git/objects/info/alternates
|
|
|
|
'
|
|
|
|
|
2016-03-29 10:11:01 +00:00
|
|
|
test_expect_success '"add" worktree with --no-checkout' '
|
|
|
|
git worktree add --no-checkout -b swamp swamp &&
|
|
|
|
! test -e swamp/init.t &&
|
|
|
|
git -C swamp reset --hard &&
|
|
|
|
test_cmp init.t swamp/init.t
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '"add" worktree with --checkout' '
|
|
|
|
git worktree add --checkout -b swmap2 swamp2 &&
|
|
|
|
test_cmp init.t swamp2/init.t
|
|
|
|
'
|
|
|
|
|
2016-04-22 13:01:33 +00:00
|
|
|
test_expect_success 'put a worktree under rebase' '
|
|
|
|
git worktree add under-rebase &&
|
|
|
|
(
|
|
|
|
cd under-rebase &&
|
|
|
|
set_fake_editor &&
|
|
|
|
FAKE_LINES="edit 1" git rebase -i HEAD^ &&
|
|
|
|
git worktree list | grep "under-rebase.*detached HEAD"
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'add a worktree, checking out a rebased branch' '
|
|
|
|
test_must_fail git worktree add new-rebase under-rebase &&
|
|
|
|
! test -d new-rebase
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'checking out a rebased branch from another worktree' '
|
|
|
|
git worktree add new-place &&
|
|
|
|
test_must_fail git -C new-place checkout under-rebase
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'not allow to delete a branch under rebase' '
|
|
|
|
(
|
|
|
|
cd under-rebase &&
|
|
|
|
test_must_fail git branch -D under-rebase
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2016-04-22 13:01:36 +00:00
|
|
|
test_expect_success 'rename a branch under rebase not allowed' '
|
|
|
|
test_must_fail git branch -M under-rebase rebase-with-new-name
|
|
|
|
'
|
|
|
|
|
2016-04-22 13:01:33 +00:00
|
|
|
test_expect_success 'check out from current worktree branch ok' '
|
|
|
|
(
|
|
|
|
cd under-rebase &&
|
|
|
|
git checkout under-rebase &&
|
|
|
|
git checkout - &&
|
|
|
|
git rebase --abort
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2016-04-22 13:01:35 +00:00
|
|
|
test_expect_success 'checkout a branch under bisect' '
|
|
|
|
git worktree add under-bisect &&
|
|
|
|
(
|
|
|
|
cd under-bisect &&
|
|
|
|
git bisect start &&
|
|
|
|
git bisect bad &&
|
|
|
|
git bisect good HEAD~2 &&
|
|
|
|
git worktree list | grep "under-bisect.*detached HEAD" &&
|
|
|
|
test_must_fail git worktree add new-bisect under-bisect &&
|
|
|
|
! test -d new-bisect
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2016-04-22 13:01:36 +00:00
|
|
|
test_expect_success 'rename a branch under bisect not allowed' '
|
|
|
|
test_must_fail git branch -M under-bisect bisect-with-new-name
|
|
|
|
'
|
2017-11-26 19:43:53 +00:00
|
|
|
# Is branch "refs/heads/$1" set to pull from "$2/$3"?
|
|
|
|
test_branch_upstream () {
|
|
|
|
printf "%s\n" "$2" "refs/heads/$3" >expect.upstream &&
|
|
|
|
{
|
|
|
|
git config "branch.$1.remote" &&
|
|
|
|
git config "branch.$1.merge"
|
|
|
|
} >actual.upstream &&
|
|
|
|
test_cmp expect.upstream actual.upstream
|
|
|
|
}
|
|
|
|
|
|
|
|
test_expect_success '--track sets up tracking' '
|
|
|
|
test_when_finished rm -rf track &&
|
2020-11-18 23:44:22 +00:00
|
|
|
git worktree add --track -b track track main &&
|
|
|
|
test_branch_upstream track . main
|
2017-11-26 19:43:53 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
# setup remote repository $1 and repository $2 with $1 set up as
|
2020-11-18 23:44:22 +00:00
|
|
|
# remote. The remote has two branches, main and foo.
|
2017-11-26 19:43:53 +00:00
|
|
|
setup_remote_repo () {
|
|
|
|
git init $1 &&
|
|
|
|
(
|
|
|
|
cd $1 &&
|
2020-11-18 23:44:22 +00:00
|
|
|
test_commit $1_main &&
|
2017-11-26 19:43:53 +00:00
|
|
|
git checkout -b foo &&
|
|
|
|
test_commit upstream_foo
|
|
|
|
) &&
|
|
|
|
git init $2 &&
|
|
|
|
(
|
|
|
|
cd $2 &&
|
2020-11-18 23:44:22 +00:00
|
|
|
test_commit $2_main &&
|
2017-11-26 19:43:53 +00:00
|
|
|
git remote add $1 ../$1 &&
|
|
|
|
git config remote.$1.fetch \
|
|
|
|
"refs/heads/*:refs/remotes/$1/*" &&
|
|
|
|
git fetch --all
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2023-05-17 21:48:47 +00:00
|
|
|
test_expect_success '"add" <path> <remote/branch> w/ no HEAD' '
|
|
|
|
test_when_finished rm -rf repo_upstream repo_local foo &&
|
|
|
|
setup_remote_repo repo_upstream repo_local &&
|
|
|
|
git -C repo_local config --bool core.bare true &&
|
|
|
|
git -C repo_local branch -D main &&
|
|
|
|
git -C repo_local worktree add ./foo repo_upstream/foo
|
|
|
|
'
|
|
|
|
|
2017-11-26 19:43:53 +00:00
|
|
|
test_expect_success '--no-track avoids setting up tracking' '
|
|
|
|
test_when_finished rm -rf repo_upstream repo_local foo &&
|
|
|
|
setup_remote_repo repo_upstream repo_local &&
|
|
|
|
(
|
|
|
|
cd repo_local &&
|
|
|
|
git worktree add --no-track -b foo ../foo repo_upstream/foo
|
|
|
|
) &&
|
|
|
|
(
|
|
|
|
cd foo &&
|
|
|
|
test_must_fail git config "branch.foo.remote" &&
|
|
|
|
test_must_fail git config "branch.foo.merge" &&
|
|
|
|
test_cmp_rev refs/remotes/repo_upstream/foo refs/heads/foo
|
|
|
|
)
|
|
|
|
'
|
2016-04-22 13:01:36 +00:00
|
|
|
|
2017-11-26 19:43:54 +00:00
|
|
|
test_expect_success '"add" <path> <non-existent-branch> fails' '
|
|
|
|
test_must_fail git worktree add foo non-existent
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '"add" <path> <branch> dwims' '
|
|
|
|
test_when_finished rm -rf repo_upstream repo_dwim foo &&
|
|
|
|
setup_remote_repo repo_upstream repo_dwim &&
|
|
|
|
git init repo_dwim &&
|
|
|
|
(
|
|
|
|
cd repo_dwim &&
|
|
|
|
git worktree add ../foo foo
|
|
|
|
) &&
|
|
|
|
(
|
|
|
|
cd foo &&
|
|
|
|
test_branch_upstream foo repo_upstream foo &&
|
|
|
|
test_cmp_rev refs/remotes/repo_upstream/foo refs/heads/foo
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
checkout & worktree: introduce checkout.defaultRemote
Introduce a checkout.defaultRemote setting which can be used to
designate a remote to prefer (via checkout.defaultRemote=origin) when
running e.g. "git checkout master" to mean origin/master, even though
there's other remotes that have the "master" branch.
I want this because it's very handy to use this workflow to checkout a
repository and create a topic branch, then get back to a "master" as
retrieved from upstream:
(
cd /tmp &&
rm -rf tbdiff &&
git clone git@github.com:trast/tbdiff.git &&
cd tbdiff &&
git branch -m topic &&
git checkout master
)
That will output:
Branch 'master' set up to track remote branch 'master' from 'origin'.
Switched to a new branch 'master'
But as soon as a new remote is added (e.g. just to inspect something
from someone else) the DWIMery goes away:
(
cd /tmp &&
rm -rf tbdiff &&
git clone git@github.com:trast/tbdiff.git &&
cd tbdiff &&
git branch -m topic &&
git remote add avar git@github.com:avar/tbdiff.git &&
git fetch avar &&
git checkout master
)
Will output (without the advice output added earlier in this series):
error: pathspec 'master' did not match any file(s) known to git.
The new checkout.defaultRemote config allows me to say that whenever
that ambiguity comes up I'd like to prefer "origin", and it'll still
work as though the only remote I had was "origin".
Also adjust the advice.checkoutAmbiguousRemoteBranchName message to
mention this new config setting to the user, the full output on my
git.git is now (the last paragraph is new):
$ ./git --exec-path=$PWD checkout master
error: pathspec 'master' did not match any file(s) known to git.
hint: 'master' matched more than one remote tracking branch.
hint: We found 26 remotes with a reference that matched. So we fell back
hint: on trying to resolve the argument as a path, but failed there too!
hint:
hint: If you meant to check out a remote tracking branch on, e.g. 'origin',
hint: you can do so by fully qualifying the name with the --track option:
hint:
hint: git checkout --track origin/<name>
hint:
hint: If you'd like to always have checkouts of an ambiguous <name> prefer
hint: one remote, e.g. the 'origin' remote, consider setting
hint: checkout.defaultRemote=origin in your config.
I considered splitting this into checkout.defaultRemote and
worktree.defaultRemote, but it's probably less confusing to break our
own rules that anything shared between config should live in core.*
than have two config settings, and I couldn't come up with a short
name under core.* that made sense (core.defaultRemoteForCheckout?).
See also 70c9ac2f19 ("DWIM "git checkout frotz" to "git checkout -b
frotz origin/frotz"", 2009-10-18) which introduced this DWIM feature
to begin with, and 4e85333197 ("worktree: make add <path> <branch>
dwim", 2017-11-26) which added it to git-worktree.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-06-05 14:40:49 +00:00
|
|
|
test_expect_success '"add" <path> <branch> dwims with checkout.defaultRemote' '
|
|
|
|
test_when_finished rm -rf repo_upstream repo_dwim foo &&
|
|
|
|
setup_remote_repo repo_upstream repo_dwim &&
|
|
|
|
git init repo_dwim &&
|
|
|
|
(
|
|
|
|
cd repo_dwim &&
|
|
|
|
git remote add repo_upstream2 ../repo_upstream &&
|
|
|
|
git fetch repo_upstream2 &&
|
|
|
|
test_must_fail git worktree add ../foo foo &&
|
|
|
|
git -c checkout.defaultRemote=repo_upstream worktree add ../foo foo &&
|
|
|
|
git status -uno --porcelain >status.actual &&
|
2018-07-27 17:48:11 +00:00
|
|
|
test_must_be_empty status.actual
|
checkout & worktree: introduce checkout.defaultRemote
Introduce a checkout.defaultRemote setting which can be used to
designate a remote to prefer (via checkout.defaultRemote=origin) when
running e.g. "git checkout master" to mean origin/master, even though
there's other remotes that have the "master" branch.
I want this because it's very handy to use this workflow to checkout a
repository and create a topic branch, then get back to a "master" as
retrieved from upstream:
(
cd /tmp &&
rm -rf tbdiff &&
git clone git@github.com:trast/tbdiff.git &&
cd tbdiff &&
git branch -m topic &&
git checkout master
)
That will output:
Branch 'master' set up to track remote branch 'master' from 'origin'.
Switched to a new branch 'master'
But as soon as a new remote is added (e.g. just to inspect something
from someone else) the DWIMery goes away:
(
cd /tmp &&
rm -rf tbdiff &&
git clone git@github.com:trast/tbdiff.git &&
cd tbdiff &&
git branch -m topic &&
git remote add avar git@github.com:avar/tbdiff.git &&
git fetch avar &&
git checkout master
)
Will output (without the advice output added earlier in this series):
error: pathspec 'master' did not match any file(s) known to git.
The new checkout.defaultRemote config allows me to say that whenever
that ambiguity comes up I'd like to prefer "origin", and it'll still
work as though the only remote I had was "origin".
Also adjust the advice.checkoutAmbiguousRemoteBranchName message to
mention this new config setting to the user, the full output on my
git.git is now (the last paragraph is new):
$ ./git --exec-path=$PWD checkout master
error: pathspec 'master' did not match any file(s) known to git.
hint: 'master' matched more than one remote tracking branch.
hint: We found 26 remotes with a reference that matched. So we fell back
hint: on trying to resolve the argument as a path, but failed there too!
hint:
hint: If you meant to check out a remote tracking branch on, e.g. 'origin',
hint: you can do so by fully qualifying the name with the --track option:
hint:
hint: git checkout --track origin/<name>
hint:
hint: If you'd like to always have checkouts of an ambiguous <name> prefer
hint: one remote, e.g. the 'origin' remote, consider setting
hint: checkout.defaultRemote=origin in your config.
I considered splitting this into checkout.defaultRemote and
worktree.defaultRemote, but it's probably less confusing to break our
own rules that anything shared between config should live in core.*
than have two config settings, and I couldn't come up with a short
name under core.* that made sense (core.defaultRemoteForCheckout?).
See also 70c9ac2f19 ("DWIM "git checkout frotz" to "git checkout -b
frotz origin/frotz"", 2009-10-18) which introduced this DWIM feature
to begin with, and 4e85333197 ("worktree: make add <path> <branch>
dwim", 2017-11-26) which added it to git-worktree.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-06-05 14:40:49 +00:00
|
|
|
) &&
|
|
|
|
(
|
|
|
|
cd foo &&
|
|
|
|
test_branch_upstream foo repo_upstream foo &&
|
|
|
|
test_cmp_rev refs/remotes/repo_upstream/foo refs/heads/foo
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2017-11-29 20:04:50 +00:00
|
|
|
test_expect_success 'git worktree add does not match remote' '
|
|
|
|
test_when_finished rm -rf repo_a repo_b foo &&
|
|
|
|
setup_remote_repo repo_a repo_b &&
|
|
|
|
(
|
|
|
|
cd repo_b &&
|
|
|
|
git worktree add ../foo
|
|
|
|
) &&
|
|
|
|
(
|
|
|
|
cd foo &&
|
|
|
|
test_must_fail git config "branch.foo.remote" &&
|
|
|
|
test_must_fail git config "branch.foo.merge" &&
|
2019-11-12 23:07:45 +00:00
|
|
|
test_cmp_rev ! refs/remotes/repo_a/foo refs/heads/foo
|
2017-11-29 20:04:50 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'git worktree add --guess-remote sets up tracking' '
|
|
|
|
test_when_finished rm -rf repo_a repo_b foo &&
|
|
|
|
setup_remote_repo repo_a repo_b &&
|
|
|
|
(
|
|
|
|
cd repo_b &&
|
|
|
|
git worktree add --guess-remote ../foo
|
|
|
|
) &&
|
|
|
|
(
|
|
|
|
cd foo &&
|
|
|
|
test_branch_upstream foo repo_a foo &&
|
|
|
|
test_cmp_rev refs/remotes/repo_a/foo refs/heads/foo
|
|
|
|
)
|
|
|
|
'
|
2023-05-17 21:48:40 +00:00
|
|
|
test_expect_success 'git worktree add --guess-remote sets up tracking (quiet)' '
|
|
|
|
test_when_finished rm -rf repo_a repo_b foo &&
|
|
|
|
setup_remote_repo repo_a repo_b &&
|
|
|
|
(
|
|
|
|
cd repo_b &&
|
|
|
|
git worktree add --quiet --guess-remote ../foo 2>actual &&
|
|
|
|
test_must_be_empty actual
|
|
|
|
) &&
|
|
|
|
(
|
|
|
|
cd foo &&
|
|
|
|
test_branch_upstream foo repo_a foo &&
|
|
|
|
test_cmp_rev refs/remotes/repo_a/foo refs/heads/foo
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'git worktree --no-guess-remote (quiet)' '
|
|
|
|
test_when_finished rm -rf repo_a repo_b foo &&
|
|
|
|
setup_remote_repo repo_a repo_b &&
|
|
|
|
(
|
|
|
|
cd repo_b &&
|
|
|
|
git worktree add --quiet --no-guess-remote ../foo
|
|
|
|
) &&
|
|
|
|
(
|
|
|
|
cd foo &&
|
|
|
|
test_must_fail git config "branch.foo.remote" &&
|
|
|
|
test_must_fail git config "branch.foo.merge" &&
|
|
|
|
test_cmp_rev ! refs/remotes/repo_a/foo refs/heads/foo
|
|
|
|
)
|
|
|
|
'
|
2017-11-29 20:04:50 +00:00
|
|
|
|
2017-11-29 20:04:51 +00:00
|
|
|
test_expect_success 'git worktree add with worktree.guessRemote sets up tracking' '
|
|
|
|
test_when_finished rm -rf repo_a repo_b foo &&
|
|
|
|
setup_remote_repo repo_a repo_b &&
|
|
|
|
(
|
|
|
|
cd repo_b &&
|
|
|
|
git config worktree.guessRemote true &&
|
|
|
|
git worktree add ../foo
|
|
|
|
) &&
|
|
|
|
(
|
|
|
|
cd foo &&
|
|
|
|
test_branch_upstream foo repo_a foo &&
|
|
|
|
test_cmp_rev refs/remotes/repo_a/foo refs/heads/foo
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'git worktree --no-guess-remote option overrides config' '
|
|
|
|
test_when_finished rm -rf repo_a repo_b foo &&
|
|
|
|
setup_remote_repo repo_a repo_b &&
|
|
|
|
(
|
|
|
|
cd repo_b &&
|
|
|
|
git config worktree.guessRemote true &&
|
|
|
|
git worktree add --no-guess-remote ../foo
|
|
|
|
) &&
|
|
|
|
(
|
|
|
|
cd foo &&
|
|
|
|
test_must_fail git config "branch.foo.remote" &&
|
|
|
|
test_must_fail git config "branch.foo.merge" &&
|
2019-11-12 23:07:45 +00:00
|
|
|
test_cmp_rev ! refs/remotes/repo_a/foo refs/heads/foo
|
2017-11-29 20:04:51 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2023-05-17 21:48:58 +00:00
|
|
|
test_dwim_orphan () {
|
|
|
|
local info_text="No possible source branch, inferring '--orphan'" &&
|
|
|
|
local fetch_error_text="fatal: No local or remote refs exist despite at least one remote" &&
|
|
|
|
local orphan_hint="hint: If you meant to create a worktree containing a new orphan branch" &&
|
|
|
|
local invalid_ref_regex="^fatal: invalid reference:\s\+.*" &&
|
|
|
|
local bad_combo_regex="^fatal: '[a-z-]\+' and '[a-z-]\+' cannot be used together" &&
|
|
|
|
|
|
|
|
local git_ns="repo" &&
|
|
|
|
local dashc_args="-C $git_ns" &&
|
|
|
|
local use_cd=0 &&
|
|
|
|
|
|
|
|
local bad_head=0 &&
|
|
|
|
local empty_repo=1 &&
|
|
|
|
local local_ref=0 &&
|
|
|
|
local use_quiet=0 &&
|
|
|
|
local remote=0 &&
|
|
|
|
local remote_ref=0 &&
|
2023-05-17 21:49:06 +00:00
|
|
|
local use_detach=0 &&
|
2023-05-17 21:48:58 +00:00
|
|
|
local use_new_branch=0 &&
|
|
|
|
|
|
|
|
local outcome="$1" &&
|
|
|
|
local outcome_text &&
|
|
|
|
local success &&
|
|
|
|
shift &&
|
|
|
|
local args="" &&
|
|
|
|
local context="" &&
|
|
|
|
case "$outcome" in
|
|
|
|
"infer")
|
|
|
|
success=1 &&
|
|
|
|
outcome_text='"add" DWIM infer --orphan'
|
|
|
|
;;
|
|
|
|
"no_infer")
|
|
|
|
success=1 &&
|
|
|
|
outcome_text='"add" DWIM doesnt infer --orphan'
|
|
|
|
;;
|
|
|
|
"fetch_error")
|
|
|
|
success=0 &&
|
|
|
|
outcome_text='"add" error need fetch'
|
|
|
|
;;
|
|
|
|
"fatal_orphan_bad_combo")
|
|
|
|
success=0 &&
|
|
|
|
outcome_text='"add" error inferred "--orphan" gives illegal opts combo'
|
|
|
|
;;
|
2023-05-17 21:49:06 +00:00
|
|
|
"warn_bad_head")
|
|
|
|
success=0 &&
|
|
|
|
outcome_text='"add" error, warn on bad HEAD, hint use orphan'
|
|
|
|
;;
|
2023-05-17 21:48:58 +00:00
|
|
|
*)
|
|
|
|
echo "test_dwim_orphan(): invalid outcome: '$outcome'" >&2 &&
|
|
|
|
return 1
|
|
|
|
;;
|
|
|
|
esac &&
|
|
|
|
while [ $# -gt 0 ]
|
|
|
|
do
|
|
|
|
case "$1" in
|
|
|
|
# How and from where to create the worktree
|
|
|
|
"-C_repo")
|
|
|
|
use_cd=0 &&
|
|
|
|
git_ns="repo" &&
|
|
|
|
dashc_args="-C $git_ns" &&
|
|
|
|
context="$context, 'git -C repo'"
|
|
|
|
;;
|
|
|
|
"-C_wt")
|
|
|
|
use_cd=0 &&
|
|
|
|
git_ns="wt" &&
|
|
|
|
dashc_args="-C $git_ns" &&
|
|
|
|
context="$context, 'git -C wt'"
|
|
|
|
;;
|
|
|
|
"cd_repo")
|
|
|
|
use_cd=1 &&
|
|
|
|
git_ns="repo" &&
|
|
|
|
dashc_args="" &&
|
|
|
|
context="$context, 'cd repo && git'"
|
|
|
|
;;
|
|
|
|
"cd_wt")
|
|
|
|
use_cd=1 &&
|
|
|
|
git_ns="wt" &&
|
|
|
|
dashc_args="" &&
|
|
|
|
context="$context, 'cd wt && git'"
|
|
|
|
;;
|
|
|
|
|
|
|
|
# Bypass the "pull first" warning
|
|
|
|
"force")
|
|
|
|
args="$args --force" &&
|
|
|
|
context="$context, --force"
|
|
|
|
;;
|
|
|
|
|
|
|
|
# Try to use remote refs when DWIM
|
|
|
|
"guess_remote")
|
|
|
|
args="$args --guess-remote" &&
|
|
|
|
context="$context, --guess-remote"
|
|
|
|
;;
|
|
|
|
"no_guess_remote")
|
|
|
|
args="$args --no-guess-remote" &&
|
|
|
|
context="$context, --no-guess-remote"
|
|
|
|
;;
|
|
|
|
|
|
|
|
# Whether there is at least one local branch present
|
|
|
|
"local_ref")
|
|
|
|
empty_repo=0 &&
|
|
|
|
local_ref=1 &&
|
|
|
|
context="$context, >=1 local branches"
|
|
|
|
;;
|
|
|
|
"no_local_ref")
|
|
|
|
empty_repo=0 &&
|
|
|
|
context="$context, 0 local branches"
|
|
|
|
;;
|
|
|
|
|
|
|
|
# Whether the HEAD points at a valid ref (skip this opt when no refs)
|
|
|
|
"good_head")
|
|
|
|
# requires: local_ref
|
|
|
|
context="$context, valid HEAD"
|
|
|
|
;;
|
|
|
|
"bad_head")
|
|
|
|
bad_head=1 &&
|
|
|
|
context="$context, invalid (or orphan) HEAD"
|
|
|
|
;;
|
|
|
|
|
2023-05-17 21:49:06 +00:00
|
|
|
# Whether the code path is tested with the base add command, -b, or --detach
|
2023-05-17 21:48:58 +00:00
|
|
|
"no_-b")
|
|
|
|
use_new_branch=0 &&
|
|
|
|
context="$context, no --branch"
|
|
|
|
;;
|
|
|
|
"-b")
|
|
|
|
use_new_branch=1 &&
|
|
|
|
context="$context, --branch"
|
|
|
|
;;
|
2023-05-17 21:49:06 +00:00
|
|
|
"detach")
|
|
|
|
use_detach=1 &&
|
|
|
|
context="$context, --detach"
|
|
|
|
;;
|
2023-05-17 21:48:58 +00:00
|
|
|
|
|
|
|
# Whether to check that all output is suppressed (except errors)
|
|
|
|
# or that the output is as expected
|
|
|
|
"quiet")
|
|
|
|
use_quiet=1 &&
|
|
|
|
args="$args --quiet" &&
|
|
|
|
context="$context, --quiet"
|
|
|
|
;;
|
|
|
|
"no_quiet")
|
|
|
|
use_quiet=0 &&
|
|
|
|
context="$context, no --quiet (expect output)"
|
|
|
|
;;
|
|
|
|
|
|
|
|
# Whether there is at least one remote attached to the repo
|
|
|
|
"remote")
|
|
|
|
empty_repo=0 &&
|
|
|
|
remote=1 &&
|
|
|
|
context="$context, >=1 remotes"
|
|
|
|
;;
|
|
|
|
"no_remote")
|
|
|
|
empty_repo=0 &&
|
|
|
|
remote=0 &&
|
|
|
|
context="$context, 0 remotes"
|
|
|
|
;;
|
|
|
|
|
|
|
|
# Whether there is at least one valid remote ref
|
|
|
|
"remote_ref")
|
|
|
|
# requires: remote
|
|
|
|
empty_repo=0 &&
|
|
|
|
remote_ref=1 &&
|
|
|
|
context="$context, >=1 fetched remote branches"
|
|
|
|
;;
|
|
|
|
"no_remote_ref")
|
|
|
|
empty_repo=0 &&
|
|
|
|
remote_ref=0 &&
|
|
|
|
context="$context, 0 fetched remote branches"
|
|
|
|
;;
|
|
|
|
|
|
|
|
# Options or flags that become illegal when --orphan is inferred
|
|
|
|
"no_checkout")
|
|
|
|
args="$args --no-checkout" &&
|
|
|
|
context="$context, --no-checkout"
|
|
|
|
;;
|
|
|
|
"track")
|
|
|
|
args="$args --track" &&
|
|
|
|
context="$context, --track"
|
|
|
|
;;
|
|
|
|
|
|
|
|
# All other options are illegal
|
|
|
|
*)
|
|
|
|
echo "test_dwim_orphan(): invalid arg: '$1'" >&2 &&
|
|
|
|
return 1
|
|
|
|
;;
|
|
|
|
esac &&
|
|
|
|
shift
|
|
|
|
done &&
|
|
|
|
context="${context#', '}" &&
|
|
|
|
if [ $use_new_branch -eq 1 ]
|
|
|
|
then
|
|
|
|
args="$args -b foo"
|
2023-05-17 21:49:06 +00:00
|
|
|
elif [ $use_detach -eq 1 ]
|
|
|
|
then
|
|
|
|
args="$args --detach"
|
2023-05-17 21:48:58 +00:00
|
|
|
else
|
|
|
|
context="DWIM (no --branch), $context"
|
|
|
|
fi &&
|
|
|
|
if [ $empty_repo -eq 1 ]
|
|
|
|
then
|
|
|
|
context="empty repo, $context"
|
|
|
|
fi &&
|
|
|
|
args="$args ../foo" &&
|
|
|
|
context="${context%', '}" &&
|
|
|
|
test_expect_success "$outcome_text w/ $context" '
|
|
|
|
test_when_finished "rm -rf repo" &&
|
|
|
|
git init repo &&
|
|
|
|
if [ $local_ref -eq 1 ] && [ "$git_ns" = "repo" ]
|
|
|
|
then
|
|
|
|
(cd repo && test_commit commit) &&
|
|
|
|
if [ $bad_head -eq 1 ]
|
|
|
|
then
|
|
|
|
git -C repo symbolic-ref HEAD refs/heads/badbranch
|
|
|
|
fi
|
|
|
|
elif [ $local_ref -eq 1 ] && [ "$git_ns" = "wt" ]
|
|
|
|
then
|
|
|
|
test_when_finished "git -C repo worktree remove -f ../wt" &&
|
|
|
|
git -C repo worktree add --orphan -b main ../wt &&
|
|
|
|
(cd wt && test_commit commit) &&
|
|
|
|
if [ $bad_head -eq 1 ]
|
|
|
|
then
|
|
|
|
git -C wt symbolic-ref HEAD refs/heads/badbranch
|
|
|
|
fi
|
|
|
|
elif [ $local_ref -eq 0 ] && [ "$git_ns" = "wt" ]
|
|
|
|
then
|
|
|
|
test_when_finished "git -C repo worktree remove -f ../wt" &&
|
|
|
|
git -C repo worktree add --orphan -b orphanbranch ../wt
|
|
|
|
fi &&
|
|
|
|
|
|
|
|
if [ $remote -eq 1 ]
|
|
|
|
then
|
|
|
|
test_when_finished "rm -rf upstream" &&
|
|
|
|
git init upstream &&
|
|
|
|
(cd upstream && test_commit commit) &&
|
|
|
|
git -C upstream switch -c foo &&
|
|
|
|
git -C repo remote add upstream ../upstream
|
|
|
|
fi &&
|
|
|
|
|
|
|
|
if [ $remote_ref -eq 1 ]
|
|
|
|
then
|
|
|
|
git -C repo fetch
|
|
|
|
fi &&
|
|
|
|
if [ $success -eq 1 ]
|
|
|
|
then
|
|
|
|
test_when_finished git -C repo worktree remove ../foo
|
|
|
|
fi &&
|
|
|
|
(
|
|
|
|
if [ $use_cd -eq 1 ]
|
|
|
|
then
|
|
|
|
cd $git_ns
|
|
|
|
fi &&
|
|
|
|
if [ "$outcome" = "infer" ]
|
|
|
|
then
|
|
|
|
git $dashc_args worktree add $args 2>actual &&
|
|
|
|
if [ $use_quiet -eq 1 ]
|
|
|
|
then
|
|
|
|
test_must_be_empty actual
|
|
|
|
else
|
|
|
|
grep "$info_text" actual
|
|
|
|
fi
|
|
|
|
elif [ "$outcome" = "no_infer" ]
|
|
|
|
then
|
|
|
|
git $dashc_args worktree add $args 2>actual &&
|
|
|
|
if [ $use_quiet -eq 1 ]
|
|
|
|
then
|
|
|
|
test_must_be_empty actual
|
|
|
|
else
|
|
|
|
! grep "$info_text" actual
|
|
|
|
fi
|
|
|
|
elif [ "$outcome" = "fetch_error" ]
|
|
|
|
then
|
|
|
|
test_must_fail git $dashc_args worktree add $args 2>actual &&
|
|
|
|
grep "$fetch_error_text" actual
|
|
|
|
elif [ "$outcome" = "fatal_orphan_bad_combo" ]
|
|
|
|
then
|
|
|
|
test_must_fail git $dashc_args worktree add $args 2>actual &&
|
|
|
|
if [ $use_quiet -eq 1 ]
|
|
|
|
then
|
|
|
|
! grep "$info_text" actual
|
|
|
|
else
|
|
|
|
grep "$info_text" actual
|
|
|
|
fi &&
|
|
|
|
grep "$bad_combo_regex" actual
|
|
|
|
elif [ "$outcome" = "warn_bad_head" ]
|
|
|
|
then
|
|
|
|
test_must_fail git $dashc_args worktree add $args 2>actual &&
|
|
|
|
if [ $use_quiet -eq 1 ]
|
|
|
|
then
|
|
|
|
grep "$invalid_ref_regex" actual &&
|
|
|
|
! grep "$orphan_hint" actual
|
|
|
|
else
|
2023-07-26 21:42:18 +00:00
|
|
|
headpath=$(git $dashc_args rev-parse --path-format=absolute --git-path HEAD) &&
|
2023-05-17 21:48:58 +00:00
|
|
|
headcontents=$(cat "$headpath") &&
|
|
|
|
grep "HEAD points to an invalid (or orphaned) reference" actual &&
|
|
|
|
grep "HEAD path:\s*.$headpath." actual &&
|
|
|
|
grep "HEAD contents:\s*.$headcontents." actual &&
|
|
|
|
grep "$orphan_hint" actual &&
|
|
|
|
! grep "$info_text" actual
|
|
|
|
fi &&
|
|
|
|
grep "$invalid_ref_regex" actual
|
|
|
|
else
|
|
|
|
# Unreachable
|
|
|
|
false
|
|
|
|
fi
|
|
|
|
) &&
|
|
|
|
if [ $success -ne 1 ]
|
|
|
|
then
|
|
|
|
test_path_is_missing foo
|
|
|
|
fi
|
|
|
|
'
|
|
|
|
}
|
|
|
|
|
|
|
|
for quiet_mode in "no_quiet" "quiet"
|
|
|
|
do
|
|
|
|
for changedir_type in "cd_repo" "cd_wt" "-C_repo" "-C_wt"
|
|
|
|
do
|
|
|
|
dwim_test_args="$quiet_mode $changedir_type"
|
|
|
|
test_dwim_orphan 'infer' $dwim_test_args no_-b
|
|
|
|
test_dwim_orphan 'no_infer' $dwim_test_args no_-b local_ref good_head
|
|
|
|
test_dwim_orphan 'infer' $dwim_test_args no_-b no_local_ref no_remote no_remote_ref no_guess_remote
|
|
|
|
test_dwim_orphan 'infer' $dwim_test_args no_-b no_local_ref remote no_remote_ref no_guess_remote
|
|
|
|
test_dwim_orphan 'fetch_error' $dwim_test_args no_-b no_local_ref remote no_remote_ref guess_remote
|
|
|
|
test_dwim_orphan 'infer' $dwim_test_args no_-b no_local_ref remote no_remote_ref guess_remote force
|
|
|
|
test_dwim_orphan 'no_infer' $dwim_test_args no_-b no_local_ref remote remote_ref guess_remote
|
|
|
|
|
|
|
|
test_dwim_orphan 'infer' $dwim_test_args -b
|
|
|
|
test_dwim_orphan 'no_infer' $dwim_test_args -b local_ref good_head
|
|
|
|
test_dwim_orphan 'infer' $dwim_test_args -b no_local_ref no_remote no_remote_ref no_guess_remote
|
|
|
|
test_dwim_orphan 'infer' $dwim_test_args -b no_local_ref remote no_remote_ref no_guess_remote
|
|
|
|
test_dwim_orphan 'infer' $dwim_test_args -b no_local_ref remote no_remote_ref guess_remote
|
|
|
|
test_dwim_orphan 'infer' $dwim_test_args -b no_local_ref remote remote_ref guess_remote
|
2023-05-17 21:49:06 +00:00
|
|
|
|
|
|
|
test_dwim_orphan 'warn_bad_head' $dwim_test_args no_-b local_ref bad_head
|
|
|
|
test_dwim_orphan 'warn_bad_head' $dwim_test_args -b local_ref bad_head
|
|
|
|
test_dwim_orphan 'warn_bad_head' $dwim_test_args detach local_ref bad_head
|
2023-05-17 21:48:58 +00:00
|
|
|
done
|
|
|
|
|
|
|
|
test_dwim_orphan 'fatal_orphan_bad_combo' $quiet_mode no_-b no_checkout
|
|
|
|
test_dwim_orphan 'fatal_orphan_bad_combo' $quiet_mode no_-b track
|
|
|
|
test_dwim_orphan 'fatal_orphan_bad_combo' $quiet_mode -b no_checkout
|
|
|
|
test_dwim_orphan 'fatal_orphan_bad_combo' $quiet_mode -b track
|
|
|
|
done
|
|
|
|
|
2017-12-07 21:20:17 +00:00
|
|
|
post_checkout_hook () {
|
2022-06-03 11:15:05 +00:00
|
|
|
test_when_finished "rm -rf .git/hooks" &&
|
|
|
|
mkdir .git/hooks &&
|
2022-03-17 10:13:16 +00:00
|
|
|
test_hook -C "$1" post-checkout <<-\EOF
|
worktree: add: fix 'post-checkout' not knowing new worktree location
Although "git worktree add" learned to run the 'post-checkout' hook in
ade546be47 (worktree: invoke post-checkout hook, 2017-12-07), it
neglected to change to the directory of the newly-created worktree
before running the hook. Instead, the hook runs within the directory
from which the "git worktree add" command itself was invoked, which
effectively neuters the hook since it knows nothing about the new
worktree directory.
Further, ade546be47 failed to sanitize the environment before running
the hook, which means that user-assigned values of GIT_DIR and
GIT_WORK_TREE could mislead the hook about the location of the new
worktree. In the case of "git worktree add" being run from a bare
repository, the GIT_DIR="." assigned by Git itself leaks into the hook's
environment and breaks Git commands; this is so even when the working
directory is correctly changed to the new worktree before the hook runs
since ".", relative to the new worktree directory, does not point at the
bare repository.
Fix these problems by (1) changing to the new worktree's directory
before running the hook, and (2) sanitizing the environment of GIT_DIR
and GIT_WORK_TREE so hooks can't be confused by misleading values.
Enhance the t2025 'post-checkout' tests to verify that the hook is
indeed run within the correct directory and that Git commands invoked by
the hook compute Git-dir and top-level worktree locations correctly.
While at it, also add two new tests: (1) verify that the hook is run
within the correct directory even when the new worktree is created from
a sibling worktree (as opposed to the main worktree); (2) verify that
the hook is provided with correct context when the new worktree is
created from a bare repository (test provided by Lars Schneider).
Implementation Notes:
Rather than sanitizing the environment of GIT_DIR and GIT_WORK_TREE, an
alternative would be to set them explicitly, as is already done for
other Git commands run internally by "git worktree add". This patch opts
instead to sanitize the environment in order to clearly document that
the worktree is fully functional by the time the hook is run, thus does
not require special environmental overrides.
The hook is run manually, rather than via run_hook_le(), since it needs
to change the working directory to that of the worktree, and
run_hook_le() does not provide such functionality. As this is a one-off
case, adding 'run_hook' overloads which allow the directory to be set
does not seem warranted at this time.
Reported-by: Lars Schneider <larsxschneider@gmail.com>
Signed-off-by: Eric Sunshine <sunshine@sunshineco.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-02-15 19:18:41 +00:00
|
|
|
{
|
|
|
|
echo $*
|
|
|
|
git rev-parse --git-dir --show-toplevel
|
|
|
|
} >hook.actual
|
2017-12-07 21:20:17 +00:00
|
|
|
EOF
|
|
|
|
}
|
|
|
|
|
|
|
|
test_expect_success '"add" invokes post-checkout hook (branch)' '
|
|
|
|
post_checkout_hook &&
|
worktree: add: fix 'post-checkout' not knowing new worktree location
Although "git worktree add" learned to run the 'post-checkout' hook in
ade546be47 (worktree: invoke post-checkout hook, 2017-12-07), it
neglected to change to the directory of the newly-created worktree
before running the hook. Instead, the hook runs within the directory
from which the "git worktree add" command itself was invoked, which
effectively neuters the hook since it knows nothing about the new
worktree directory.
Further, ade546be47 failed to sanitize the environment before running
the hook, which means that user-assigned values of GIT_DIR and
GIT_WORK_TREE could mislead the hook about the location of the new
worktree. In the case of "git worktree add" being run from a bare
repository, the GIT_DIR="." assigned by Git itself leaks into the hook's
environment and breaks Git commands; this is so even when the working
directory is correctly changed to the new worktree before the hook runs
since ".", relative to the new worktree directory, does not point at the
bare repository.
Fix these problems by (1) changing to the new worktree's directory
before running the hook, and (2) sanitizing the environment of GIT_DIR
and GIT_WORK_TREE so hooks can't be confused by misleading values.
Enhance the t2025 'post-checkout' tests to verify that the hook is
indeed run within the correct directory and that Git commands invoked by
the hook compute Git-dir and top-level worktree locations correctly.
While at it, also add two new tests: (1) verify that the hook is run
within the correct directory even when the new worktree is created from
a sibling worktree (as opposed to the main worktree); (2) verify that
the hook is provided with correct context when the new worktree is
created from a bare repository (test provided by Lars Schneider).
Implementation Notes:
Rather than sanitizing the environment of GIT_DIR and GIT_WORK_TREE, an
alternative would be to set them explicitly, as is already done for
other Git commands run internally by "git worktree add". This patch opts
instead to sanitize the environment in order to clearly document that
the worktree is fully functional by the time the hook is run, thus does
not require special environmental overrides.
The hook is run manually, rather than via run_hook_le(), since it needs
to change the working directory to that of the worktree, and
run_hook_le() does not provide such functionality. As this is a one-off
case, adding 'run_hook' overloads which allow the directory to be set
does not seem warranted at this time.
Reported-by: Lars Schneider <larsxschneider@gmail.com>
Signed-off-by: Eric Sunshine <sunshine@sunshineco.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-02-15 19:18:41 +00:00
|
|
|
{
|
2018-05-13 02:24:13 +00:00
|
|
|
echo $ZERO_OID $(git rev-parse HEAD) 1 &&
|
worktree: add: fix 'post-checkout' not knowing new worktree location
Although "git worktree add" learned to run the 'post-checkout' hook in
ade546be47 (worktree: invoke post-checkout hook, 2017-12-07), it
neglected to change to the directory of the newly-created worktree
before running the hook. Instead, the hook runs within the directory
from which the "git worktree add" command itself was invoked, which
effectively neuters the hook since it knows nothing about the new
worktree directory.
Further, ade546be47 failed to sanitize the environment before running
the hook, which means that user-assigned values of GIT_DIR and
GIT_WORK_TREE could mislead the hook about the location of the new
worktree. In the case of "git worktree add" being run from a bare
repository, the GIT_DIR="." assigned by Git itself leaks into the hook's
environment and breaks Git commands; this is so even when the working
directory is correctly changed to the new worktree before the hook runs
since ".", relative to the new worktree directory, does not point at the
bare repository.
Fix these problems by (1) changing to the new worktree's directory
before running the hook, and (2) sanitizing the environment of GIT_DIR
and GIT_WORK_TREE so hooks can't be confused by misleading values.
Enhance the t2025 'post-checkout' tests to verify that the hook is
indeed run within the correct directory and that Git commands invoked by
the hook compute Git-dir and top-level worktree locations correctly.
While at it, also add two new tests: (1) verify that the hook is run
within the correct directory even when the new worktree is created from
a sibling worktree (as opposed to the main worktree); (2) verify that
the hook is provided with correct context when the new worktree is
created from a bare repository (test provided by Lars Schneider).
Implementation Notes:
Rather than sanitizing the environment of GIT_DIR and GIT_WORK_TREE, an
alternative would be to set them explicitly, as is already done for
other Git commands run internally by "git worktree add". This patch opts
instead to sanitize the environment in order to clearly document that
the worktree is fully functional by the time the hook is run, thus does
not require special environmental overrides.
The hook is run manually, rather than via run_hook_le(), since it needs
to change the working directory to that of the worktree, and
run_hook_le() does not provide such functionality. As this is a one-off
case, adding 'run_hook' overloads which allow the directory to be set
does not seem warranted at this time.
Reported-by: Lars Schneider <larsxschneider@gmail.com>
Signed-off-by: Eric Sunshine <sunshine@sunshineco.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-02-15 19:18:41 +00:00
|
|
|
echo $(pwd)/.git/worktrees/gumby &&
|
|
|
|
echo $(pwd)/gumby
|
|
|
|
} >hook.expect &&
|
2017-12-07 21:20:17 +00:00
|
|
|
git worktree add gumby &&
|
worktree: add: fix 'post-checkout' not knowing new worktree location
Although "git worktree add" learned to run the 'post-checkout' hook in
ade546be47 (worktree: invoke post-checkout hook, 2017-12-07), it
neglected to change to the directory of the newly-created worktree
before running the hook. Instead, the hook runs within the directory
from which the "git worktree add" command itself was invoked, which
effectively neuters the hook since it knows nothing about the new
worktree directory.
Further, ade546be47 failed to sanitize the environment before running
the hook, which means that user-assigned values of GIT_DIR and
GIT_WORK_TREE could mislead the hook about the location of the new
worktree. In the case of "git worktree add" being run from a bare
repository, the GIT_DIR="." assigned by Git itself leaks into the hook's
environment and breaks Git commands; this is so even when the working
directory is correctly changed to the new worktree before the hook runs
since ".", relative to the new worktree directory, does not point at the
bare repository.
Fix these problems by (1) changing to the new worktree's directory
before running the hook, and (2) sanitizing the environment of GIT_DIR
and GIT_WORK_TREE so hooks can't be confused by misleading values.
Enhance the t2025 'post-checkout' tests to verify that the hook is
indeed run within the correct directory and that Git commands invoked by
the hook compute Git-dir and top-level worktree locations correctly.
While at it, also add two new tests: (1) verify that the hook is run
within the correct directory even when the new worktree is created from
a sibling worktree (as opposed to the main worktree); (2) verify that
the hook is provided with correct context when the new worktree is
created from a bare repository (test provided by Lars Schneider).
Implementation Notes:
Rather than sanitizing the environment of GIT_DIR and GIT_WORK_TREE, an
alternative would be to set them explicitly, as is already done for
other Git commands run internally by "git worktree add". This patch opts
instead to sanitize the environment in order to clearly document that
the worktree is fully functional by the time the hook is run, thus does
not require special environmental overrides.
The hook is run manually, rather than via run_hook_le(), since it needs
to change the working directory to that of the worktree, and
run_hook_le() does not provide such functionality. As this is a one-off
case, adding 'run_hook' overloads which allow the directory to be set
does not seem warranted at this time.
Reported-by: Lars Schneider <larsxschneider@gmail.com>
Signed-off-by: Eric Sunshine <sunshine@sunshineco.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-02-15 19:18:41 +00:00
|
|
|
test_cmp hook.expect gumby/hook.actual
|
2017-12-07 21:20:17 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '"add" invokes post-checkout hook (detached)' '
|
|
|
|
post_checkout_hook &&
|
worktree: add: fix 'post-checkout' not knowing new worktree location
Although "git worktree add" learned to run the 'post-checkout' hook in
ade546be47 (worktree: invoke post-checkout hook, 2017-12-07), it
neglected to change to the directory of the newly-created worktree
before running the hook. Instead, the hook runs within the directory
from which the "git worktree add" command itself was invoked, which
effectively neuters the hook since it knows nothing about the new
worktree directory.
Further, ade546be47 failed to sanitize the environment before running
the hook, which means that user-assigned values of GIT_DIR and
GIT_WORK_TREE could mislead the hook about the location of the new
worktree. In the case of "git worktree add" being run from a bare
repository, the GIT_DIR="." assigned by Git itself leaks into the hook's
environment and breaks Git commands; this is so even when the working
directory is correctly changed to the new worktree before the hook runs
since ".", relative to the new worktree directory, does not point at the
bare repository.
Fix these problems by (1) changing to the new worktree's directory
before running the hook, and (2) sanitizing the environment of GIT_DIR
and GIT_WORK_TREE so hooks can't be confused by misleading values.
Enhance the t2025 'post-checkout' tests to verify that the hook is
indeed run within the correct directory and that Git commands invoked by
the hook compute Git-dir and top-level worktree locations correctly.
While at it, also add two new tests: (1) verify that the hook is run
within the correct directory even when the new worktree is created from
a sibling worktree (as opposed to the main worktree); (2) verify that
the hook is provided with correct context when the new worktree is
created from a bare repository (test provided by Lars Schneider).
Implementation Notes:
Rather than sanitizing the environment of GIT_DIR and GIT_WORK_TREE, an
alternative would be to set them explicitly, as is already done for
other Git commands run internally by "git worktree add". This patch opts
instead to sanitize the environment in order to clearly document that
the worktree is fully functional by the time the hook is run, thus does
not require special environmental overrides.
The hook is run manually, rather than via run_hook_le(), since it needs
to change the working directory to that of the worktree, and
run_hook_le() does not provide such functionality. As this is a one-off
case, adding 'run_hook' overloads which allow the directory to be set
does not seem warranted at this time.
Reported-by: Lars Schneider <larsxschneider@gmail.com>
Signed-off-by: Eric Sunshine <sunshine@sunshineco.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-02-15 19:18:41 +00:00
|
|
|
{
|
2018-05-13 02:24:13 +00:00
|
|
|
echo $ZERO_OID $(git rev-parse HEAD) 1 &&
|
worktree: add: fix 'post-checkout' not knowing new worktree location
Although "git worktree add" learned to run the 'post-checkout' hook in
ade546be47 (worktree: invoke post-checkout hook, 2017-12-07), it
neglected to change to the directory of the newly-created worktree
before running the hook. Instead, the hook runs within the directory
from which the "git worktree add" command itself was invoked, which
effectively neuters the hook since it knows nothing about the new
worktree directory.
Further, ade546be47 failed to sanitize the environment before running
the hook, which means that user-assigned values of GIT_DIR and
GIT_WORK_TREE could mislead the hook about the location of the new
worktree. In the case of "git worktree add" being run from a bare
repository, the GIT_DIR="." assigned by Git itself leaks into the hook's
environment and breaks Git commands; this is so even when the working
directory is correctly changed to the new worktree before the hook runs
since ".", relative to the new worktree directory, does not point at the
bare repository.
Fix these problems by (1) changing to the new worktree's directory
before running the hook, and (2) sanitizing the environment of GIT_DIR
and GIT_WORK_TREE so hooks can't be confused by misleading values.
Enhance the t2025 'post-checkout' tests to verify that the hook is
indeed run within the correct directory and that Git commands invoked by
the hook compute Git-dir and top-level worktree locations correctly.
While at it, also add two new tests: (1) verify that the hook is run
within the correct directory even when the new worktree is created from
a sibling worktree (as opposed to the main worktree); (2) verify that
the hook is provided with correct context when the new worktree is
created from a bare repository (test provided by Lars Schneider).
Implementation Notes:
Rather than sanitizing the environment of GIT_DIR and GIT_WORK_TREE, an
alternative would be to set them explicitly, as is already done for
other Git commands run internally by "git worktree add". This patch opts
instead to sanitize the environment in order to clearly document that
the worktree is fully functional by the time the hook is run, thus does
not require special environmental overrides.
The hook is run manually, rather than via run_hook_le(), since it needs
to change the working directory to that of the worktree, and
run_hook_le() does not provide such functionality. As this is a one-off
case, adding 'run_hook' overloads which allow the directory to be set
does not seem warranted at this time.
Reported-by: Lars Schneider <larsxschneider@gmail.com>
Signed-off-by: Eric Sunshine <sunshine@sunshineco.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-02-15 19:18:41 +00:00
|
|
|
echo $(pwd)/.git/worktrees/grumpy &&
|
|
|
|
echo $(pwd)/grumpy
|
|
|
|
} >hook.expect &&
|
2017-12-07 21:20:17 +00:00
|
|
|
git worktree add --detach grumpy &&
|
worktree: add: fix 'post-checkout' not knowing new worktree location
Although "git worktree add" learned to run the 'post-checkout' hook in
ade546be47 (worktree: invoke post-checkout hook, 2017-12-07), it
neglected to change to the directory of the newly-created worktree
before running the hook. Instead, the hook runs within the directory
from which the "git worktree add" command itself was invoked, which
effectively neuters the hook since it knows nothing about the new
worktree directory.
Further, ade546be47 failed to sanitize the environment before running
the hook, which means that user-assigned values of GIT_DIR and
GIT_WORK_TREE could mislead the hook about the location of the new
worktree. In the case of "git worktree add" being run from a bare
repository, the GIT_DIR="." assigned by Git itself leaks into the hook's
environment and breaks Git commands; this is so even when the working
directory is correctly changed to the new worktree before the hook runs
since ".", relative to the new worktree directory, does not point at the
bare repository.
Fix these problems by (1) changing to the new worktree's directory
before running the hook, and (2) sanitizing the environment of GIT_DIR
and GIT_WORK_TREE so hooks can't be confused by misleading values.
Enhance the t2025 'post-checkout' tests to verify that the hook is
indeed run within the correct directory and that Git commands invoked by
the hook compute Git-dir and top-level worktree locations correctly.
While at it, also add two new tests: (1) verify that the hook is run
within the correct directory even when the new worktree is created from
a sibling worktree (as opposed to the main worktree); (2) verify that
the hook is provided with correct context when the new worktree is
created from a bare repository (test provided by Lars Schneider).
Implementation Notes:
Rather than sanitizing the environment of GIT_DIR and GIT_WORK_TREE, an
alternative would be to set them explicitly, as is already done for
other Git commands run internally by "git worktree add". This patch opts
instead to sanitize the environment in order to clearly document that
the worktree is fully functional by the time the hook is run, thus does
not require special environmental overrides.
The hook is run manually, rather than via run_hook_le(), since it needs
to change the working directory to that of the worktree, and
run_hook_le() does not provide such functionality. As this is a one-off
case, adding 'run_hook' overloads which allow the directory to be set
does not seem warranted at this time.
Reported-by: Lars Schneider <larsxschneider@gmail.com>
Signed-off-by: Eric Sunshine <sunshine@sunshineco.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-02-15 19:18:41 +00:00
|
|
|
test_cmp hook.expect grumpy/hook.actual
|
2017-12-07 21:20:17 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '"add --no-checkout" suppresses post-checkout hook' '
|
|
|
|
post_checkout_hook &&
|
|
|
|
rm -f hook.actual &&
|
|
|
|
git worktree add --no-checkout gloopy &&
|
worktree: add: fix 'post-checkout' not knowing new worktree location
Although "git worktree add" learned to run the 'post-checkout' hook in
ade546be47 (worktree: invoke post-checkout hook, 2017-12-07), it
neglected to change to the directory of the newly-created worktree
before running the hook. Instead, the hook runs within the directory
from which the "git worktree add" command itself was invoked, which
effectively neuters the hook since it knows nothing about the new
worktree directory.
Further, ade546be47 failed to sanitize the environment before running
the hook, which means that user-assigned values of GIT_DIR and
GIT_WORK_TREE could mislead the hook about the location of the new
worktree. In the case of "git worktree add" being run from a bare
repository, the GIT_DIR="." assigned by Git itself leaks into the hook's
environment and breaks Git commands; this is so even when the working
directory is correctly changed to the new worktree before the hook runs
since ".", relative to the new worktree directory, does not point at the
bare repository.
Fix these problems by (1) changing to the new worktree's directory
before running the hook, and (2) sanitizing the environment of GIT_DIR
and GIT_WORK_TREE so hooks can't be confused by misleading values.
Enhance the t2025 'post-checkout' tests to verify that the hook is
indeed run within the correct directory and that Git commands invoked by
the hook compute Git-dir and top-level worktree locations correctly.
While at it, also add two new tests: (1) verify that the hook is run
within the correct directory even when the new worktree is created from
a sibling worktree (as opposed to the main worktree); (2) verify that
the hook is provided with correct context when the new worktree is
created from a bare repository (test provided by Lars Schneider).
Implementation Notes:
Rather than sanitizing the environment of GIT_DIR and GIT_WORK_TREE, an
alternative would be to set them explicitly, as is already done for
other Git commands run internally by "git worktree add". This patch opts
instead to sanitize the environment in order to clearly document that
the worktree is fully functional by the time the hook is run, thus does
not require special environmental overrides.
The hook is run manually, rather than via run_hook_le(), since it needs
to change the working directory to that of the worktree, and
run_hook_le() does not provide such functionality. As this is a one-off
case, adding 'run_hook' overloads which allow the directory to be set
does not seem warranted at this time.
Reported-by: Lars Schneider <larsxschneider@gmail.com>
Signed-off-by: Eric Sunshine <sunshine@sunshineco.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-02-15 19:18:41 +00:00
|
|
|
test_path_is_missing gloopy/hook.actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '"add" in other worktree invokes post-checkout hook' '
|
|
|
|
post_checkout_hook &&
|
|
|
|
{
|
2018-05-13 02:24:13 +00:00
|
|
|
echo $ZERO_OID $(git rev-parse HEAD) 1 &&
|
worktree: add: fix 'post-checkout' not knowing new worktree location
Although "git worktree add" learned to run the 'post-checkout' hook in
ade546be47 (worktree: invoke post-checkout hook, 2017-12-07), it
neglected to change to the directory of the newly-created worktree
before running the hook. Instead, the hook runs within the directory
from which the "git worktree add" command itself was invoked, which
effectively neuters the hook since it knows nothing about the new
worktree directory.
Further, ade546be47 failed to sanitize the environment before running
the hook, which means that user-assigned values of GIT_DIR and
GIT_WORK_TREE could mislead the hook about the location of the new
worktree. In the case of "git worktree add" being run from a bare
repository, the GIT_DIR="." assigned by Git itself leaks into the hook's
environment and breaks Git commands; this is so even when the working
directory is correctly changed to the new worktree before the hook runs
since ".", relative to the new worktree directory, does not point at the
bare repository.
Fix these problems by (1) changing to the new worktree's directory
before running the hook, and (2) sanitizing the environment of GIT_DIR
and GIT_WORK_TREE so hooks can't be confused by misleading values.
Enhance the t2025 'post-checkout' tests to verify that the hook is
indeed run within the correct directory and that Git commands invoked by
the hook compute Git-dir and top-level worktree locations correctly.
While at it, also add two new tests: (1) verify that the hook is run
within the correct directory even when the new worktree is created from
a sibling worktree (as opposed to the main worktree); (2) verify that
the hook is provided with correct context when the new worktree is
created from a bare repository (test provided by Lars Schneider).
Implementation Notes:
Rather than sanitizing the environment of GIT_DIR and GIT_WORK_TREE, an
alternative would be to set them explicitly, as is already done for
other Git commands run internally by "git worktree add". This patch opts
instead to sanitize the environment in order to clearly document that
the worktree is fully functional by the time the hook is run, thus does
not require special environmental overrides.
The hook is run manually, rather than via run_hook_le(), since it needs
to change the working directory to that of the worktree, and
run_hook_le() does not provide such functionality. As this is a one-off
case, adding 'run_hook' overloads which allow the directory to be set
does not seem warranted at this time.
Reported-by: Lars Schneider <larsxschneider@gmail.com>
Signed-off-by: Eric Sunshine <sunshine@sunshineco.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-02-15 19:18:41 +00:00
|
|
|
echo $(pwd)/.git/worktrees/guppy &&
|
|
|
|
echo $(pwd)/guppy
|
|
|
|
} >hook.expect &&
|
|
|
|
git -C gloopy worktree add --detach ../guppy &&
|
|
|
|
test_cmp hook.expect guppy/hook.actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '"add" in bare repo invokes post-checkout hook' '
|
|
|
|
rm -rf bare &&
|
|
|
|
git clone --bare . bare &&
|
|
|
|
{
|
2018-05-13 02:24:13 +00:00
|
|
|
echo $ZERO_OID $(git --git-dir=bare rev-parse HEAD) 1 &&
|
worktree: add: fix 'post-checkout' not knowing new worktree location
Although "git worktree add" learned to run the 'post-checkout' hook in
ade546be47 (worktree: invoke post-checkout hook, 2017-12-07), it
neglected to change to the directory of the newly-created worktree
before running the hook. Instead, the hook runs within the directory
from which the "git worktree add" command itself was invoked, which
effectively neuters the hook since it knows nothing about the new
worktree directory.
Further, ade546be47 failed to sanitize the environment before running
the hook, which means that user-assigned values of GIT_DIR and
GIT_WORK_TREE could mislead the hook about the location of the new
worktree. In the case of "git worktree add" being run from a bare
repository, the GIT_DIR="." assigned by Git itself leaks into the hook's
environment and breaks Git commands; this is so even when the working
directory is correctly changed to the new worktree before the hook runs
since ".", relative to the new worktree directory, does not point at the
bare repository.
Fix these problems by (1) changing to the new worktree's directory
before running the hook, and (2) sanitizing the environment of GIT_DIR
and GIT_WORK_TREE so hooks can't be confused by misleading values.
Enhance the t2025 'post-checkout' tests to verify that the hook is
indeed run within the correct directory and that Git commands invoked by
the hook compute Git-dir and top-level worktree locations correctly.
While at it, also add two new tests: (1) verify that the hook is run
within the correct directory even when the new worktree is created from
a sibling worktree (as opposed to the main worktree); (2) verify that
the hook is provided with correct context when the new worktree is
created from a bare repository (test provided by Lars Schneider).
Implementation Notes:
Rather than sanitizing the environment of GIT_DIR and GIT_WORK_TREE, an
alternative would be to set them explicitly, as is already done for
other Git commands run internally by "git worktree add". This patch opts
instead to sanitize the environment in order to clearly document that
the worktree is fully functional by the time the hook is run, thus does
not require special environmental overrides.
The hook is run manually, rather than via run_hook_le(), since it needs
to change the working directory to that of the worktree, and
run_hook_le() does not provide such functionality. As this is a one-off
case, adding 'run_hook' overloads which allow the directory to be set
does not seem warranted at this time.
Reported-by: Lars Schneider <larsxschneider@gmail.com>
Signed-off-by: Eric Sunshine <sunshine@sunshineco.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-02-15 19:18:41 +00:00
|
|
|
echo $(pwd)/bare/worktrees/goozy &&
|
|
|
|
echo $(pwd)/goozy
|
|
|
|
} >hook.expect &&
|
|
|
|
post_checkout_hook bare &&
|
|
|
|
git -C bare worktree add --detach ../goozy &&
|
|
|
|
test_cmp hook.expect goozy/hook.actual
|
2017-12-07 21:20:17 +00:00
|
|
|
'
|
|
|
|
|
2018-08-28 21:20:22 +00:00
|
|
|
test_expect_success '"add" an existing but missing worktree' '
|
|
|
|
git worktree add --detach pneu &&
|
|
|
|
test_must_fail git worktree add --detach pneu &&
|
|
|
|
rm -fr pneu &&
|
2018-08-28 21:20:23 +00:00
|
|
|
test_must_fail git worktree add --detach pneu &&
|
|
|
|
git worktree add --force --detach pneu
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '"add" an existing locked but missing worktree' '
|
|
|
|
git worktree add --detach gnoo &&
|
|
|
|
git worktree lock gnoo &&
|
|
|
|
test_when_finished "git worktree unlock gnoo || :" &&
|
|
|
|
rm -fr gnoo &&
|
|
|
|
test_must_fail git worktree add --detach gnoo &&
|
|
|
|
test_must_fail git worktree add --force --detach gnoo &&
|
|
|
|
git worktree add --force --force --detach gnoo
|
2018-08-28 21:20:22 +00:00
|
|
|
'
|
|
|
|
|
worktree: don't allow "add" validation to be fooled by suffix matching
"git worktree add <path>" performs various checks before approving
<path> as a valid location for the new worktree. Aside from ensuring
that <path> does not already exist, one of the questions it asks is
whether <path> is already a registered worktree. To perform this check,
it queries find_worktree() and disallows the "add" operation if
find_worktree() finds a match for <path>. As a convenience, however,
find_worktree() casts an overly wide net to allow users to identify
worktrees by shorthand in order to keep typing to a minimum. For
instance, it performs suffix matching which, given subtrees "foo/bar"
and "foo/baz", can correctly select the latter when asked only for
"baz".
"add" validation knows the exact path it is interrogating, so this sort
of heuristic-based matching is, at best, questionable for this use-case
and, at worst, may may accidentally interpret <path> as matching an
existing worktree and incorrectly report it as already registered even
when it isn't. (In fact, validate_worktree_add() already contains a
special case to avoid accidentally matching against the main worktree,
precisely due to this problem.)
Avoid the problem of potential accidental matching against an existing
worktree by instead taking advantage of find_worktree_by_path() which
matches paths deterministically, without applying any sort of magic
shorthand matching performed by find_worktree().
Reported-by: Cameron Gunnin <cameron.gunnin@synopsys.com>
Signed-off-by: Eric Sunshine <sunshine@sunshineco.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-02-24 09:08:48 +00:00
|
|
|
test_expect_success '"add" not tripped up by magic worktree matching"' '
|
|
|
|
# if worktree "sub1/bar" exists, "git worktree add bar" in distinct
|
|
|
|
# directory `sub2` should not mistakenly complain that `bar` is an
|
|
|
|
# already-registered worktree
|
|
|
|
mkdir sub1 sub2 &&
|
|
|
|
git -C sub1 --git-dir=../.git worktree add --detach bozo &&
|
|
|
|
git -C sub2 --git-dir=../.git worktree add --detach bozo
|
|
|
|
'
|
|
|
|
|
2019-03-08 09:28:34 +00:00
|
|
|
test_expect_success FUNNYNAMES 'sanitize generated worktree name' '
|
|
|
|
git worktree add --detach ". weird*..?.lock.lock" &&
|
|
|
|
test -d .git/worktrees/---weird-.-
|
|
|
|
'
|
|
|
|
|
2019-05-13 10:49:44 +00:00
|
|
|
test_expect_success '"add" should not fail because of another bad worktree' '
|
|
|
|
git init add-fail &&
|
|
|
|
(
|
|
|
|
cd add-fail &&
|
|
|
|
test_commit first &&
|
|
|
|
mkdir sub &&
|
|
|
|
git worktree add sub/to-be-deleted &&
|
|
|
|
rm -rf sub &&
|
|
|
|
git worktree add second
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2019-10-27 17:16:25 +00:00
|
|
|
test_expect_success '"add" with uninitialized submodule, with submodule.recurse unset' '
|
2022-07-29 19:20:03 +00:00
|
|
|
test_config_global protocol.file.allow always &&
|
2019-10-27 17:16:25 +00:00
|
|
|
test_create_repo submodule &&
|
|
|
|
test_commit -C submodule first &&
|
|
|
|
test_create_repo project &&
|
|
|
|
git -C project submodule add ../submodule &&
|
|
|
|
git -C project add submodule &&
|
|
|
|
test_tick &&
|
|
|
|
git -C project commit -m add_sub &&
|
|
|
|
git clone project project-clone &&
|
|
|
|
git -C project-clone worktree add ../project-2
|
|
|
|
'
|
|
|
|
test_expect_success '"add" with uninitialized submodule, with submodule.recurse set' '
|
|
|
|
git -C project-clone -c submodule.recurse worktree add ../project-3
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '"add" with initialized submodule, with submodule.recurse unset' '
|
2022-07-29 19:20:03 +00:00
|
|
|
test_config_global protocol.file.allow always &&
|
2019-10-27 17:16:25 +00:00
|
|
|
git -C project-clone submodule update --init &&
|
|
|
|
git -C project-clone worktree add ../project-4
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success '"add" with initialized submodule, with submodule.recurse set' '
|
|
|
|
git -C project-clone -c submodule.recurse worktree add ../project-5
|
|
|
|
'
|
|
|
|
|
2014-11-30 08:24:47 +00:00
|
|
|
test_done
|