2007-09-24 05:29:12 +00:00
|
|
|
#!/bin/sh
|
|
|
|
|
|
|
|
test_description='git remote porcelain-ish'
|
|
|
|
|
|
|
|
. ./test-lib.sh
|
|
|
|
|
|
|
|
setup_repository () {
|
|
|
|
mkdir "$1" && (
|
|
|
|
cd "$1" &&
|
2020-12-17 01:07:05 +00:00
|
|
|
git init -b main &&
|
2007-09-24 05:29:12 +00:00
|
|
|
>file &&
|
|
|
|
git add file &&
|
2008-03-04 11:23:53 +00:00
|
|
|
test_tick &&
|
2007-09-24 05:29:12 +00:00
|
|
|
git commit -m "Initial" &&
|
|
|
|
git checkout -b side &&
|
|
|
|
>elif &&
|
|
|
|
git add elif &&
|
2008-03-04 11:23:53 +00:00
|
|
|
test_tick &&
|
2007-09-24 05:29:12 +00:00
|
|
|
git commit -m "Second" &&
|
2020-12-17 01:07:05 +00:00
|
|
|
git checkout main
|
2007-09-24 05:29:12 +00:00
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
tokens_match () {
|
|
|
|
echo "$1" | tr ' ' '\012' | sort | sed -e '/^$/d' >expect &&
|
|
|
|
echo "$2" | tr ' ' '\012' | sort | sed -e '/^$/d' >actual &&
|
2008-03-12 21:36:36 +00:00
|
|
|
test_cmp expect actual
|
2007-09-24 05:29:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
check_remote_track () {
|
2009-02-25 08:32:27 +00:00
|
|
|
actual=$(git remote show "$1" | sed -ne 's|^ \(.*\) tracked$|\1|p')
|
2007-09-24 05:29:12 +00:00
|
|
|
shift &&
|
|
|
|
tokens_match "$*" "$actual"
|
|
|
|
}
|
|
|
|
|
|
|
|
check_tracking_branch () {
|
|
|
|
f="" &&
|
|
|
|
r=$(git for-each-ref "--format=%(refname)" |
|
|
|
|
sed -ne "s|^refs/remotes/$1/||p") &&
|
|
|
|
shift &&
|
|
|
|
tokens_match "$*" "$r"
|
|
|
|
}
|
|
|
|
|
|
|
|
test_expect_success setup '
|
|
|
|
setup_repository one &&
|
|
|
|
setup_repository two &&
|
|
|
|
(
|
2013-06-22 07:58:08 +00:00
|
|
|
cd two &&
|
|
|
|
git branch another
|
2007-09-24 05:29:12 +00:00
|
|
|
) &&
|
|
|
|
git clone one test
|
|
|
|
'
|
|
|
|
|
2016-02-17 16:20:47 +00:00
|
|
|
test_expect_success 'add remote whose URL agrees with url.<...>.insteadOf' '
|
|
|
|
test_config url.git@host.com:team/repo.git.insteadOf myremote &&
|
|
|
|
git remote add myremote git@host.com:team/repo.git
|
|
|
|
'
|
|
|
|
|
2021-02-11 01:53:51 +00:00
|
|
|
test_expect_success 'remote information for the origin' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
tokens_match origin "$(git remote)" &&
|
2020-12-17 01:07:05 +00:00
|
|
|
check_remote_track origin main side &&
|
|
|
|
check_tracking_branch origin HEAD main side
|
2013-06-22 07:58:08 +00:00
|
|
|
)
|
2007-09-24 05:29:12 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'add another remote' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
git remote add -f second ../two &&
|
|
|
|
tokens_match "origin second" "$(git remote)" &&
|
2020-12-17 01:07:05 +00:00
|
|
|
check_tracking_branch second main side another &&
|
2013-06-22 07:58:08 +00:00
|
|
|
git for-each-ref "--format=%(refname)" refs/remotes |
|
|
|
|
sed -e "/^refs\/remotes\/origin\//d" \
|
|
|
|
-e "/^refs\/remotes\/second\//d" >actual &&
|
2018-07-27 17:48:11 +00:00
|
|
|
test_must_be_empty actual
|
2013-06-22 07:58:08 +00:00
|
|
|
)
|
2007-09-24 05:29:12 +00:00
|
|
|
'
|
|
|
|
|
2022-05-09 11:32:48 +00:00
|
|
|
test_expect_success 'setup bare clone for server' '
|
|
|
|
git clone --bare "file://$(pwd)/one" srv.bare &&
|
|
|
|
git -C srv.bare config --local uploadpack.allowfilter 1 &&
|
|
|
|
git -C srv.bare config --local uploadpack.allowanysha1inwant 1
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'filters for promisor remotes are listed by git remote -v' '
|
|
|
|
test_when_finished "rm -rf pc" &&
|
|
|
|
git clone --filter=blob:none "file://$(pwd)/srv.bare" pc &&
|
|
|
|
git -C pc remote -v >out &&
|
|
|
|
grep "srv.bare (fetch) \[blob:none\]" out &&
|
|
|
|
|
|
|
|
git -C pc config remote.origin.partialCloneFilter object:type=commit &&
|
|
|
|
git -C pc remote -v >out &&
|
|
|
|
grep "srv.bare (fetch) \[object:type=commit\]" out
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'filters should not be listed for non promisor remotes (remote -v)' '
|
|
|
|
test_when_finished "rm -rf pc" &&
|
|
|
|
git clone one pc &&
|
|
|
|
git -C pc remote -v >out &&
|
|
|
|
! grep "(fetch) \[.*\]" out
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'filters are listed by git remote -v only' '
|
|
|
|
test_when_finished "rm -rf pc" &&
|
|
|
|
git clone --filter=blob:none "file://$(pwd)/srv.bare" pc &&
|
|
|
|
git -C pc remote >out &&
|
|
|
|
! grep "\[blob:none\]" out &&
|
|
|
|
|
|
|
|
git -C pc remote show >out &&
|
|
|
|
! grep "\[blob:none\]" out
|
|
|
|
'
|
|
|
|
|
2021-02-11 01:53:51 +00:00
|
|
|
test_expect_success 'check remote-tracking' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd test &&
|
2020-12-17 01:07:05 +00:00
|
|
|
check_remote_track origin main side &&
|
|
|
|
check_remote_track second main side another
|
2013-06-22 07:58:08 +00:00
|
|
|
)
|
2012-08-27 05:36:54 +00:00
|
|
|
'
|
|
|
|
|
2008-04-22 11:11:13 +00:00
|
|
|
test_expect_success 'remote forces tracking branches' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd test &&
|
2015-12-23 13:45:53 +00:00
|
|
|
case $(git config remote.second.fetch) in
|
2013-06-22 07:58:08 +00:00
|
|
|
+*) true ;;
|
|
|
|
*) false ;;
|
|
|
|
esac
|
|
|
|
)
|
2008-04-22 11:11:13 +00:00
|
|
|
'
|
|
|
|
|
2007-09-24 05:29:12 +00:00
|
|
|
test_expect_success 'remove remote' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd test &&
|
2020-12-17 01:07:05 +00:00
|
|
|
git symbolic-ref refs/remotes/second/HEAD refs/remotes/second/main &&
|
2013-06-22 07:58:08 +00:00
|
|
|
git remote rm second
|
|
|
|
)
|
2007-09-24 05:29:12 +00:00
|
|
|
'
|
|
|
|
|
2021-02-11 01:53:51 +00:00
|
|
|
test_expect_success 'remove remote' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
tokens_match origin "$(git remote)" &&
|
2020-12-17 01:07:05 +00:00
|
|
|
check_remote_track origin main side &&
|
2013-06-22 07:58:08 +00:00
|
|
|
git for-each-ref "--format=%(refname)" refs/remotes |
|
|
|
|
sed -e "/^refs\/remotes\/origin\//d" >actual &&
|
2018-07-27 17:48:11 +00:00
|
|
|
test_must_be_empty actual
|
2013-06-22 07:58:08 +00:00
|
|
|
)
|
2007-09-24 05:29:12 +00:00
|
|
|
'
|
|
|
|
|
2010-11-02 15:31:25 +00:00
|
|
|
test_expect_success 'remove remote protects local branches' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
cat >expect1 <<-\EOF &&
|
|
|
|
Note: A branch outside the refs/remotes/ hierarchy was not removed;
|
|
|
|
to delete it, use:
|
2020-12-17 01:07:05 +00:00
|
|
|
git branch -d main
|
2013-06-22 07:58:08 +00:00
|
|
|
EOF
|
|
|
|
cat >expect2 <<-\EOF &&
|
|
|
|
Note: Some branches outside the refs/remotes/ hierarchy were not removed;
|
|
|
|
to delete them, use:
|
|
|
|
git branch -d foobranch
|
2020-12-17 01:07:05 +00:00
|
|
|
git branch -d main
|
2013-06-22 07:58:08 +00:00
|
|
|
EOF
|
|
|
|
git tag footag &&
|
|
|
|
git config --add remote.oops.fetch "+refs/*:refs/*" &&
|
|
|
|
git remote remove oops 2>actual1 &&
|
|
|
|
git branch foobranch &&
|
|
|
|
git config --add remote.oops.fetch "+refs/*:refs/*" &&
|
|
|
|
git remote rm oops 2>actual2 &&
|
|
|
|
git branch -d foobranch &&
|
|
|
|
git tag -d footag &&
|
2021-02-11 01:53:53 +00:00
|
|
|
test_cmp expect1 actual1 &&
|
|
|
|
test_cmp expect2 actual2
|
2013-06-22 07:58:08 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2016-02-16 09:47:51 +00:00
|
|
|
test_expect_success 'remove errors out early when deleting non-existent branch' '
|
|
|
|
(
|
|
|
|
cd test &&
|
2020-10-27 09:41:36 +00:00
|
|
|
echo "error: No such remote: '\''foo'\''" >expect &&
|
|
|
|
test_expect_code 2 git remote rm foo 2>actual &&
|
2021-02-11 01:53:53 +00:00
|
|
|
test_cmp expect actual
|
2016-02-16 09:47:51 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2017-02-18 00:23:41 +00:00
|
|
|
test_expect_success 'remove remote with a branch without configured merge' '
|
|
|
|
test_when_finished "(
|
2020-12-17 01:07:05 +00:00
|
|
|
git -C test checkout main;
|
2017-02-18 00:23:41 +00:00
|
|
|
git -C test branch -D two;
|
|
|
|
git -C test config --remove-section remote.two;
|
|
|
|
git -C test config --remove-section branch.second;
|
|
|
|
true
|
|
|
|
)" &&
|
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
git remote add two ../two &&
|
|
|
|
git fetch two &&
|
2020-12-17 01:07:05 +00:00
|
|
|
git checkout -b second two/main^0 &&
|
2017-02-18 00:23:41 +00:00
|
|
|
git config branch.second.remote two &&
|
2020-12-17 01:07:05 +00:00
|
|
|
git checkout main &&
|
2017-02-18 00:23:41 +00:00
|
|
|
git remote rm two
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2016-02-16 09:47:51 +00:00
|
|
|
test_expect_success 'rename errors out early when deleting non-existent branch' '
|
|
|
|
(
|
|
|
|
cd test &&
|
2020-10-27 09:41:36 +00:00
|
|
|
echo "error: No such remote: '\''foo'\''" >expect &&
|
|
|
|
test_expect_code 2 git remote rename foo bar 2>actual &&
|
2021-02-11 01:53:53 +00:00
|
|
|
test_cmp expect actual
|
2016-02-16 09:47:51 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2021-06-11 11:18:50 +00:00
|
|
|
test_expect_success 'rename errors out early when new name is invalid' '
|
2020-10-01 03:46:12 +00:00
|
|
|
test_config remote.foo.vcs bar &&
|
|
|
|
echo "fatal: '\''invalid...name'\'' is not a valid remote name" >expect &&
|
|
|
|
test_must_fail git remote rename foo invalid...name 2>actual &&
|
2021-02-11 01:53:53 +00:00
|
|
|
test_cmp expect actual
|
2020-10-01 03:46:12 +00:00
|
|
|
'
|
|
|
|
|
2016-02-16 09:47:52 +00:00
|
|
|
test_expect_success 'add existing foreign_vcs remote' '
|
|
|
|
test_config remote.foo.vcs bar &&
|
2020-10-27 09:41:36 +00:00
|
|
|
echo "error: remote foo already exists." >expect &&
|
|
|
|
test_expect_code 3 git remote add foo bar 2>actual &&
|
2021-02-11 01:53:53 +00:00
|
|
|
test_cmp expect actual
|
2016-02-16 09:47:52 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'add existing foreign_vcs remote' '
|
|
|
|
test_config remote.foo.vcs bar &&
|
|
|
|
test_config remote.bar.vcs bar &&
|
2020-10-27 09:41:36 +00:00
|
|
|
echo "error: remote bar already exists." >expect &&
|
|
|
|
test_expect_code 3 git remote rename foo bar 2>actual &&
|
2021-02-11 01:53:53 +00:00
|
|
|
test_cmp expect actual
|
2016-02-16 09:47:52 +00:00
|
|
|
'
|
|
|
|
|
2020-10-01 03:46:12 +00:00
|
|
|
test_expect_success 'add invalid foreign_vcs remote' '
|
|
|
|
echo "fatal: '\''invalid...name'\'' is not a valid remote name" >expect &&
|
|
|
|
test_must_fail git remote add invalid...name bar 2>actual &&
|
2021-02-11 01:53:53 +00:00
|
|
|
test_cmp expect actual
|
2020-10-01 03:46:12 +00:00
|
|
|
'
|
|
|
|
|
2013-06-22 07:58:08 +00:00
|
|
|
cat >test/expect <<EOF
|
2008-02-29 01:45:24 +00:00
|
|
|
* remote origin
|
2009-06-13 16:29:10 +00:00
|
|
|
Fetch URL: $(pwd)/one
|
|
|
|
Push URL: $(pwd)/one
|
2020-12-17 01:07:05 +00:00
|
|
|
HEAD branch: main
|
2009-02-25 08:32:27 +00:00
|
|
|
Remote branches:
|
2020-10-23 14:00:05 +00:00
|
|
|
main new (next fetch will store in remotes/origin)
|
|
|
|
side tracked
|
2009-02-25 08:32:27 +00:00
|
|
|
Local branches configured for 'git pull':
|
2020-10-23 14:00:05 +00:00
|
|
|
ahead merges with remote main
|
|
|
|
main merges with remote main
|
2009-02-25 08:32:27 +00:00
|
|
|
octopus merges with remote topic-a
|
|
|
|
and with remote topic-b
|
|
|
|
and with remote topic-c
|
2020-12-17 01:07:05 +00:00
|
|
|
rebase rebases onto remote main
|
2009-02-25 08:32:28 +00:00
|
|
|
Local refs configured for 'git push':
|
2020-10-23 14:00:05 +00:00
|
|
|
main pushes to main (local out of date)
|
|
|
|
main pushes to upstream (create)
|
2009-02-25 08:32:24 +00:00
|
|
|
* remote two
|
2009-06-13 16:29:10 +00:00
|
|
|
Fetch URL: ../two
|
|
|
|
Push URL: ../three
|
2020-12-17 01:07:05 +00:00
|
|
|
HEAD branch: main
|
2009-02-25 08:32:28 +00:00
|
|
|
Local refs configured for 'git push':
|
2020-10-23 14:00:05 +00:00
|
|
|
ahead forces to main (fast-forwardable)
|
|
|
|
main pushes to another (up to date)
|
2008-02-29 01:45:24 +00:00
|
|
|
EOF
|
|
|
|
|
2020-12-17 01:07:05 +00:00
|
|
|
test_expect_success 'show' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd test &&
|
2020-12-17 01:07:05 +00:00
|
|
|
git config --add remote.origin.fetch refs/heads/main:refs/heads/upstream &&
|
2013-06-22 07:58:08 +00:00
|
|
|
git fetch &&
|
2020-12-17 01:07:05 +00:00
|
|
|
git checkout -b ahead origin/main &&
|
2013-06-22 07:58:08 +00:00
|
|
|
echo 1 >>file &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m update file &&
|
2020-12-17 01:07:05 +00:00
|
|
|
git checkout main &&
|
|
|
|
git branch --track octopus origin/main &&
|
|
|
|
git branch --track rebase origin/main &&
|
|
|
|
git branch -d -r origin/main &&
|
2013-06-22 07:58:08 +00:00
|
|
|
git config --add remote.two.url ../two &&
|
|
|
|
git config --add remote.two.pushurl ../three &&
|
|
|
|
git config branch.rebase.rebase true &&
|
|
|
|
git config branch.octopus.merge "topic-a topic-b topic-c" &&
|
|
|
|
(
|
|
|
|
cd ../one &&
|
|
|
|
echo 1 >file &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m update file
|
|
|
|
) &&
|
|
|
|
git config --add remote.origin.push : &&
|
2020-12-17 01:07:05 +00:00
|
|
|
git config --add remote.origin.push refs/heads/main:refs/heads/upstream &&
|
2013-06-22 07:58:08 +00:00
|
|
|
git config --add remote.origin.push +refs/tags/lastbackup &&
|
2020-12-17 01:07:05 +00:00
|
|
|
git config --add remote.two.push +refs/heads/ahead:refs/heads/main &&
|
|
|
|
git config --add remote.two.push refs/heads/main:refs/heads/another &&
|
2013-06-22 07:58:08 +00:00
|
|
|
git remote show origin two >output &&
|
|
|
|
git branch -d rebase octopus &&
|
2021-02-11 01:53:53 +00:00
|
|
|
test_cmp expect output
|
2013-06-22 07:58:08 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
cat >test/expect <<EOF
|
2008-06-10 14:51:08 +00:00
|
|
|
* remote origin
|
2009-06-13 16:29:10 +00:00
|
|
|
Fetch URL: $(pwd)/one
|
|
|
|
Push URL: $(pwd)/one
|
2009-02-25 08:32:24 +00:00
|
|
|
HEAD branch: (not queried)
|
2009-02-25 08:32:27 +00:00
|
|
|
Remote branches: (status not queried)
|
2020-12-17 01:07:05 +00:00
|
|
|
main
|
2008-10-22 07:39:47 +00:00
|
|
|
side
|
2009-02-25 08:32:28 +00:00
|
|
|
Local branches configured for 'git pull':
|
2020-10-23 14:00:05 +00:00
|
|
|
ahead merges with remote main
|
|
|
|
main merges with remote main
|
2009-02-25 08:32:28 +00:00
|
|
|
Local refs configured for 'git push' (status not queried):
|
|
|
|
(matching) pushes to (matching)
|
2020-10-23 14:00:05 +00:00
|
|
|
refs/heads/main pushes to refs/heads/upstream
|
2009-02-25 08:32:28 +00:00
|
|
|
refs/tags/lastbackup forces to refs/tags/lastbackup
|
2008-06-10 14:51:08 +00:00
|
|
|
EOF
|
|
|
|
|
2020-12-17 01:07:05 +00:00
|
|
|
test_expect_success 'show -n' '
|
2013-06-22 07:58:08 +00:00
|
|
|
mv one one.unreachable &&
|
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
git remote show -n origin >output &&
|
|
|
|
mv ../one.unreachable ../one &&
|
2021-02-11 01:53:53 +00:00
|
|
|
test_cmp expect output
|
2013-06-22 07:58:08 +00:00
|
|
|
)
|
2008-06-10 14:51:08 +00:00
|
|
|
'
|
|
|
|
|
2008-02-29 01:45:24 +00:00
|
|
|
test_expect_success 'prune' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd one &&
|
|
|
|
git branch -m side side2
|
|
|
|
) &&
|
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
git fetch origin &&
|
|
|
|
git remote prune origin &&
|
|
|
|
git rev-parse refs/remotes/origin/side2 &&
|
|
|
|
test_must_fail git rev-parse refs/remotes/origin/side
|
|
|
|
)
|
2008-02-29 01:45:24 +00:00
|
|
|
'
|
|
|
|
|
2009-02-25 08:32:25 +00:00
|
|
|
test_expect_success 'set-head --delete' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
git symbolic-ref refs/remotes/origin/HEAD &&
|
|
|
|
git remote set-head --delete origin &&
|
|
|
|
test_must_fail git symbolic-ref refs/remotes/origin/HEAD
|
|
|
|
)
|
2009-02-25 08:32:25 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'set-head --auto' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
git remote set-head --auto origin &&
|
2020-12-17 01:07:05 +00:00
|
|
|
echo refs/remotes/origin/main >expect &&
|
2013-06-22 07:58:08 +00:00
|
|
|
git symbolic-ref refs/remotes/origin/HEAD >output &&
|
|
|
|
test_cmp expect output
|
2009-02-25 08:32:25 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2020-12-17 01:07:05 +00:00
|
|
|
test_expect_success 'set-head --auto has no problem w/multiple HEADs' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd test &&
|
2013-09-18 04:45:34 +00:00
|
|
|
git fetch two "refs/heads/*:refs/remotes/two/*" &&
|
2013-09-18 02:10:31 +00:00
|
|
|
git remote set-head --auto two >output 2>&1 &&
|
2020-12-17 01:07:05 +00:00
|
|
|
echo "two/HEAD set to main" >expect &&
|
2021-02-11 01:53:53 +00:00
|
|
|
test_cmp expect output
|
2013-06-22 07:58:08 +00:00
|
|
|
)
|
2009-02-25 08:32:25 +00:00
|
|
|
'
|
|
|
|
|
2013-06-22 07:58:08 +00:00
|
|
|
cat >test/expect <<\EOF
|
2009-02-25 08:32:25 +00:00
|
|
|
refs/remotes/origin/side2
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'set-head explicit' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
git remote set-head origin side2 &&
|
|
|
|
git symbolic-ref refs/remotes/origin/HEAD >output &&
|
2020-12-17 01:07:05 +00:00
|
|
|
git remote set-head origin main &&
|
2013-06-22 07:58:08 +00:00
|
|
|
test_cmp expect output
|
|
|
|
)
|
2009-02-25 08:32:25 +00:00
|
|
|
'
|
|
|
|
|
2013-06-22 07:58:08 +00:00
|
|
|
cat >test/expect <<EOF
|
2008-06-10 14:51:35 +00:00
|
|
|
Pruning origin
|
2008-09-01 19:07:33 +00:00
|
|
|
URL: $(pwd)/one
|
2008-06-10 14:51:35 +00:00
|
|
|
* [would prune] origin/side2
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'prune --dry-run' '
|
2018-07-02 00:23:48 +00:00
|
|
|
git -C one branch -m side2 side &&
|
|
|
|
test_when_finished "git -C one branch -m side side2" &&
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
git remote prune --dry-run origin >output &&
|
|
|
|
git rev-parse refs/remotes/origin/side2 &&
|
|
|
|
test_must_fail git rev-parse refs/remotes/origin/side &&
|
2021-02-11 01:53:53 +00:00
|
|
|
test_cmp expect output
|
2013-06-22 07:58:08 +00:00
|
|
|
)
|
2008-06-10 14:51:35 +00:00
|
|
|
'
|
|
|
|
|
2008-02-29 01:46:07 +00:00
|
|
|
test_expect_success 'add --mirror && prune' '
|
2013-06-22 07:58:08 +00:00
|
|
|
mkdir mirror &&
|
|
|
|
(
|
|
|
|
cd mirror &&
|
|
|
|
git init --bare &&
|
|
|
|
git remote add --mirror -f origin ../one
|
|
|
|
) &&
|
|
|
|
(
|
|
|
|
cd one &&
|
|
|
|
git branch -m side2 side
|
|
|
|
) &&
|
|
|
|
(
|
|
|
|
cd mirror &&
|
|
|
|
git rev-parse --verify refs/heads/side2 &&
|
|
|
|
test_must_fail git rev-parse --verify refs/heads/side &&
|
|
|
|
git fetch origin &&
|
|
|
|
git remote prune origin &&
|
|
|
|
test_must_fail git rev-parse --verify refs/heads/side2 &&
|
|
|
|
git rev-parse --verify refs/heads/side
|
|
|
|
)
|
2008-02-29 01:46:07 +00:00
|
|
|
'
|
|
|
|
|
remote: separate the concept of push and fetch mirrors
git-remote currently has one option, "--mirror", which sets
up mirror configuration which can be used for either
fetching or pushing. It looks like this:
[remote "mirror"]
url = wherever
fetch = +refs/*:refs/*
mirror = true
However, a remote like this can be dangerous and confusing.
Specifically:
1. If you issue the wrong command, it can be devastating.
You are not likely to "push" when you meant to "fetch",
but "git remote update" will try to fetch it, even if
you intended the remote only for pushing. In either
case, the results can be quite destructive. An
unintended push will overwrite or delete remote refs,
and an unintended fetch can overwrite local branches.
2. The tracking setup code can produce confusing results.
The fetch refspec above means that "git checkout -b new
master" will consider refs/heads/master to come from
the remote "mirror", even if you only ever intend to
push to the mirror. It will set up the "new" branch to
track mirror's refs/heads/master.
3. The push code tries to opportunistically update
tracking branches. If you "git push mirror foo:bar",
it will see that we are updating mirror's
refs/heads/bar, which corresponds to our local
refs/heads/bar, and will update our local branch.
To solve this, we split the concept into "push mirrors" and
"fetch mirrors". Push mirrors set only remote.*.mirror,
solving (2) and (3), and making an accidental fetch write
only into FETCH_HEAD. Fetch mirrors set only the fetch
refspec, meaning an accidental push will not force-overwrite
or delete refs on the remote end.
The new syntax is "--mirror=<fetch|push>". For
compatibility, we keep "--mirror" as-is, setting up both
types simultaneously.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-03-30 19:53:19 +00:00
|
|
|
test_expect_success 'add --mirror=fetch' '
|
|
|
|
mkdir mirror-fetch &&
|
2020-12-17 01:07:05 +00:00
|
|
|
git init -b main mirror-fetch/parent &&
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd mirror-fetch/parent &&
|
|
|
|
test_commit one
|
|
|
|
) &&
|
remote: separate the concept of push and fetch mirrors
git-remote currently has one option, "--mirror", which sets
up mirror configuration which can be used for either
fetching or pushing. It looks like this:
[remote "mirror"]
url = wherever
fetch = +refs/*:refs/*
mirror = true
However, a remote like this can be dangerous and confusing.
Specifically:
1. If you issue the wrong command, it can be devastating.
You are not likely to "push" when you meant to "fetch",
but "git remote update" will try to fetch it, even if
you intended the remote only for pushing. In either
case, the results can be quite destructive. An
unintended push will overwrite or delete remote refs,
and an unintended fetch can overwrite local branches.
2. The tracking setup code can produce confusing results.
The fetch refspec above means that "git checkout -b new
master" will consider refs/heads/master to come from
the remote "mirror", even if you only ever intend to
push to the mirror. It will set up the "new" branch to
track mirror's refs/heads/master.
3. The push code tries to opportunistically update
tracking branches. If you "git push mirror foo:bar",
it will see that we are updating mirror's
refs/heads/bar, which corresponds to our local
refs/heads/bar, and will update our local branch.
To solve this, we split the concept into "push mirrors" and
"fetch mirrors". Push mirrors set only remote.*.mirror,
solving (2) and (3), and making an accidental fetch write
only into FETCH_HEAD. Fetch mirrors set only the fetch
refspec, meaning an accidental push will not force-overwrite
or delete refs on the remote end.
The new syntax is "--mirror=<fetch|push>". For
compatibility, we keep "--mirror" as-is, setting up both
types simultaneously.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-03-30 19:53:19 +00:00
|
|
|
git init --bare mirror-fetch/child &&
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd mirror-fetch/child &&
|
|
|
|
git remote add --mirror=fetch -f parent ../parent
|
|
|
|
)
|
remote: separate the concept of push and fetch mirrors
git-remote currently has one option, "--mirror", which sets
up mirror configuration which can be used for either
fetching or pushing. It looks like this:
[remote "mirror"]
url = wherever
fetch = +refs/*:refs/*
mirror = true
However, a remote like this can be dangerous and confusing.
Specifically:
1. If you issue the wrong command, it can be devastating.
You are not likely to "push" when you meant to "fetch",
but "git remote update" will try to fetch it, even if
you intended the remote only for pushing. In either
case, the results can be quite destructive. An
unintended push will overwrite or delete remote refs,
and an unintended fetch can overwrite local branches.
2. The tracking setup code can produce confusing results.
The fetch refspec above means that "git checkout -b new
master" will consider refs/heads/master to come from
the remote "mirror", even if you only ever intend to
push to the mirror. It will set up the "new" branch to
track mirror's refs/heads/master.
3. The push code tries to opportunistically update
tracking branches. If you "git push mirror foo:bar",
it will see that we are updating mirror's
refs/heads/bar, which corresponds to our local
refs/heads/bar, and will update our local branch.
To solve this, we split the concept into "push mirrors" and
"fetch mirrors". Push mirrors set only remote.*.mirror,
solving (2) and (3), and making an accidental fetch write
only into FETCH_HEAD. Fetch mirrors set only the fetch
refspec, meaning an accidental push will not force-overwrite
or delete refs on the remote end.
The new syntax is "--mirror=<fetch|push>". For
compatibility, we keep "--mirror" as-is, setting up both
types simultaneously.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-03-30 19:53:19 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'fetch mirrors act as mirrors during fetch' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd mirror-fetch/parent &&
|
|
|
|
git branch new &&
|
2020-12-17 01:07:05 +00:00
|
|
|
git branch -m main renamed
|
remote: separate the concept of push and fetch mirrors
git-remote currently has one option, "--mirror", which sets
up mirror configuration which can be used for either
fetching or pushing. It looks like this:
[remote "mirror"]
url = wherever
fetch = +refs/*:refs/*
mirror = true
However, a remote like this can be dangerous and confusing.
Specifically:
1. If you issue the wrong command, it can be devastating.
You are not likely to "push" when you meant to "fetch",
but "git remote update" will try to fetch it, even if
you intended the remote only for pushing. In either
case, the results can be quite destructive. An
unintended push will overwrite or delete remote refs,
and an unintended fetch can overwrite local branches.
2. The tracking setup code can produce confusing results.
The fetch refspec above means that "git checkout -b new
master" will consider refs/heads/master to come from
the remote "mirror", even if you only ever intend to
push to the mirror. It will set up the "new" branch to
track mirror's refs/heads/master.
3. The push code tries to opportunistically update
tracking branches. If you "git push mirror foo:bar",
it will see that we are updating mirror's
refs/heads/bar, which corresponds to our local
refs/heads/bar, and will update our local branch.
To solve this, we split the concept into "push mirrors" and
"fetch mirrors". Push mirrors set only remote.*.mirror,
solving (2) and (3), and making an accidental fetch write
only into FETCH_HEAD. Fetch mirrors set only the fetch
refspec, meaning an accidental push will not force-overwrite
or delete refs on the remote end.
The new syntax is "--mirror=<fetch|push>". For
compatibility, we keep "--mirror" as-is, setting up both
types simultaneously.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-03-30 19:53:19 +00:00
|
|
|
) &&
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd mirror-fetch/child &&
|
|
|
|
git fetch parent &&
|
|
|
|
git rev-parse --verify refs/heads/new &&
|
|
|
|
git rev-parse --verify refs/heads/renamed
|
remote: separate the concept of push and fetch mirrors
git-remote currently has one option, "--mirror", which sets
up mirror configuration which can be used for either
fetching or pushing. It looks like this:
[remote "mirror"]
url = wherever
fetch = +refs/*:refs/*
mirror = true
However, a remote like this can be dangerous and confusing.
Specifically:
1. If you issue the wrong command, it can be devastating.
You are not likely to "push" when you meant to "fetch",
but "git remote update" will try to fetch it, even if
you intended the remote only for pushing. In either
case, the results can be quite destructive. An
unintended push will overwrite or delete remote refs,
and an unintended fetch can overwrite local branches.
2. The tracking setup code can produce confusing results.
The fetch refspec above means that "git checkout -b new
master" will consider refs/heads/master to come from
the remote "mirror", even if you only ever intend to
push to the mirror. It will set up the "new" branch to
track mirror's refs/heads/master.
3. The push code tries to opportunistically update
tracking branches. If you "git push mirror foo:bar",
it will see that we are updating mirror's
refs/heads/bar, which corresponds to our local
refs/heads/bar, and will update our local branch.
To solve this, we split the concept into "push mirrors" and
"fetch mirrors". Push mirrors set only remote.*.mirror,
solving (2) and (3), and making an accidental fetch write
only into FETCH_HEAD. Fetch mirrors set only the fetch
refspec, meaning an accidental push will not force-overwrite
or delete refs on the remote end.
The new syntax is "--mirror=<fetch|push>". For
compatibility, we keep "--mirror" as-is, setting up both
types simultaneously.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-03-30 19:53:19 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'fetch mirrors can prune' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd mirror-fetch/child &&
|
|
|
|
git remote prune parent &&
|
2020-12-17 01:07:05 +00:00
|
|
|
test_must_fail git rev-parse --verify refs/heads/main
|
remote: separate the concept of push and fetch mirrors
git-remote currently has one option, "--mirror", which sets
up mirror configuration which can be used for either
fetching or pushing. It looks like this:
[remote "mirror"]
url = wherever
fetch = +refs/*:refs/*
mirror = true
However, a remote like this can be dangerous and confusing.
Specifically:
1. If you issue the wrong command, it can be devastating.
You are not likely to "push" when you meant to "fetch",
but "git remote update" will try to fetch it, even if
you intended the remote only for pushing. In either
case, the results can be quite destructive. An
unintended push will overwrite or delete remote refs,
and an unintended fetch can overwrite local branches.
2. The tracking setup code can produce confusing results.
The fetch refspec above means that "git checkout -b new
master" will consider refs/heads/master to come from
the remote "mirror", even if you only ever intend to
push to the mirror. It will set up the "new" branch to
track mirror's refs/heads/master.
3. The push code tries to opportunistically update
tracking branches. If you "git push mirror foo:bar",
it will see that we are updating mirror's
refs/heads/bar, which corresponds to our local
refs/heads/bar, and will update our local branch.
To solve this, we split the concept into "push mirrors" and
"fetch mirrors". Push mirrors set only remote.*.mirror,
solving (2) and (3), and making an accidental fetch write
only into FETCH_HEAD. Fetch mirrors set only the fetch
refspec, meaning an accidental push will not force-overwrite
or delete refs on the remote end.
The new syntax is "--mirror=<fetch|push>". For
compatibility, we keep "--mirror" as-is, setting up both
types simultaneously.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-03-30 19:53:19 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'fetch mirrors do not act as mirrors during push' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd mirror-fetch/parent &&
|
|
|
|
git checkout HEAD^0
|
remote: separate the concept of push and fetch mirrors
git-remote currently has one option, "--mirror", which sets
up mirror configuration which can be used for either
fetching or pushing. It looks like this:
[remote "mirror"]
url = wherever
fetch = +refs/*:refs/*
mirror = true
However, a remote like this can be dangerous and confusing.
Specifically:
1. If you issue the wrong command, it can be devastating.
You are not likely to "push" when you meant to "fetch",
but "git remote update" will try to fetch it, even if
you intended the remote only for pushing. In either
case, the results can be quite destructive. An
unintended push will overwrite or delete remote refs,
and an unintended fetch can overwrite local branches.
2. The tracking setup code can produce confusing results.
The fetch refspec above means that "git checkout -b new
master" will consider refs/heads/master to come from
the remote "mirror", even if you only ever intend to
push to the mirror. It will set up the "new" branch to
track mirror's refs/heads/master.
3. The push code tries to opportunistically update
tracking branches. If you "git push mirror foo:bar",
it will see that we are updating mirror's
refs/heads/bar, which corresponds to our local
refs/heads/bar, and will update our local branch.
To solve this, we split the concept into "push mirrors" and
"fetch mirrors". Push mirrors set only remote.*.mirror,
solving (2) and (3), and making an accidental fetch write
only into FETCH_HEAD. Fetch mirrors set only the fetch
refspec, meaning an accidental push will not force-overwrite
or delete refs on the remote end.
The new syntax is "--mirror=<fetch|push>". For
compatibility, we keep "--mirror" as-is, setting up both
types simultaneously.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-03-30 19:53:19 +00:00
|
|
|
) &&
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd mirror-fetch/child &&
|
|
|
|
git branch -m renamed renamed2 &&
|
|
|
|
git push parent :
|
remote: separate the concept of push and fetch mirrors
git-remote currently has one option, "--mirror", which sets
up mirror configuration which can be used for either
fetching or pushing. It looks like this:
[remote "mirror"]
url = wherever
fetch = +refs/*:refs/*
mirror = true
However, a remote like this can be dangerous and confusing.
Specifically:
1. If you issue the wrong command, it can be devastating.
You are not likely to "push" when you meant to "fetch",
but "git remote update" will try to fetch it, even if
you intended the remote only for pushing. In either
case, the results can be quite destructive. An
unintended push will overwrite or delete remote refs,
and an unintended fetch can overwrite local branches.
2. The tracking setup code can produce confusing results.
The fetch refspec above means that "git checkout -b new
master" will consider refs/heads/master to come from
the remote "mirror", even if you only ever intend to
push to the mirror. It will set up the "new" branch to
track mirror's refs/heads/master.
3. The push code tries to opportunistically update
tracking branches. If you "git push mirror foo:bar",
it will see that we are updating mirror's
refs/heads/bar, which corresponds to our local
refs/heads/bar, and will update our local branch.
To solve this, we split the concept into "push mirrors" and
"fetch mirrors". Push mirrors set only remote.*.mirror,
solving (2) and (3), and making an accidental fetch write
only into FETCH_HEAD. Fetch mirrors set only the fetch
refspec, meaning an accidental push will not force-overwrite
or delete refs on the remote end.
The new syntax is "--mirror=<fetch|push>". For
compatibility, we keep "--mirror" as-is, setting up both
types simultaneously.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-03-30 19:53:19 +00:00
|
|
|
) &&
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd mirror-fetch/parent &&
|
|
|
|
git rev-parse --verify renamed &&
|
|
|
|
test_must_fail git rev-parse --verify refs/heads/renamed2
|
remote: separate the concept of push and fetch mirrors
git-remote currently has one option, "--mirror", which sets
up mirror configuration which can be used for either
fetching or pushing. It looks like this:
[remote "mirror"]
url = wherever
fetch = +refs/*:refs/*
mirror = true
However, a remote like this can be dangerous and confusing.
Specifically:
1. If you issue the wrong command, it can be devastating.
You are not likely to "push" when you meant to "fetch",
but "git remote update" will try to fetch it, even if
you intended the remote only for pushing. In either
case, the results can be quite destructive. An
unintended push will overwrite or delete remote refs,
and an unintended fetch can overwrite local branches.
2. The tracking setup code can produce confusing results.
The fetch refspec above means that "git checkout -b new
master" will consider refs/heads/master to come from
the remote "mirror", even if you only ever intend to
push to the mirror. It will set up the "new" branch to
track mirror's refs/heads/master.
3. The push code tries to opportunistically update
tracking branches. If you "git push mirror foo:bar",
it will see that we are updating mirror's
refs/heads/bar, which corresponds to our local
refs/heads/bar, and will update our local branch.
To solve this, we split the concept into "push mirrors" and
"fetch mirrors". Push mirrors set only remote.*.mirror,
solving (2) and (3), and making an accidental fetch write
only into FETCH_HEAD. Fetch mirrors set only the fetch
refspec, meaning an accidental push will not force-overwrite
or delete refs on the remote end.
The new syntax is "--mirror=<fetch|push>". For
compatibility, we keep "--mirror" as-is, setting up both
types simultaneously.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-03-30 19:53:19 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2011-05-26 15:11:00 +00:00
|
|
|
test_expect_success 'add fetch mirror with specific branches' '
|
|
|
|
git init --bare mirror-fetch/track &&
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd mirror-fetch/track &&
|
|
|
|
git remote add --mirror=fetch -t heads/new parent ../parent
|
2011-05-26 15:11:00 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'fetch mirror respects specific branches' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd mirror-fetch/track &&
|
|
|
|
git fetch parent &&
|
|
|
|
git rev-parse --verify refs/heads/new &&
|
|
|
|
test_must_fail git rev-parse --verify refs/heads/renamed
|
2011-05-26 15:11:00 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
remote: separate the concept of push and fetch mirrors
git-remote currently has one option, "--mirror", which sets
up mirror configuration which can be used for either
fetching or pushing. It looks like this:
[remote "mirror"]
url = wherever
fetch = +refs/*:refs/*
mirror = true
However, a remote like this can be dangerous and confusing.
Specifically:
1. If you issue the wrong command, it can be devastating.
You are not likely to "push" when you meant to "fetch",
but "git remote update" will try to fetch it, even if
you intended the remote only for pushing. In either
case, the results can be quite destructive. An
unintended push will overwrite or delete remote refs,
and an unintended fetch can overwrite local branches.
2. The tracking setup code can produce confusing results.
The fetch refspec above means that "git checkout -b new
master" will consider refs/heads/master to come from
the remote "mirror", even if you only ever intend to
push to the mirror. It will set up the "new" branch to
track mirror's refs/heads/master.
3. The push code tries to opportunistically update
tracking branches. If you "git push mirror foo:bar",
it will see that we are updating mirror's
refs/heads/bar, which corresponds to our local
refs/heads/bar, and will update our local branch.
To solve this, we split the concept into "push mirrors" and
"fetch mirrors". Push mirrors set only remote.*.mirror,
solving (2) and (3), and making an accidental fetch write
only into FETCH_HEAD. Fetch mirrors set only the fetch
refspec, meaning an accidental push will not force-overwrite
or delete refs on the remote end.
The new syntax is "--mirror=<fetch|push>". For
compatibility, we keep "--mirror" as-is, setting up both
types simultaneously.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-03-30 19:53:19 +00:00
|
|
|
test_expect_success 'add --mirror=push' '
|
|
|
|
mkdir mirror-push &&
|
|
|
|
git init --bare mirror-push/public &&
|
2020-12-17 01:07:05 +00:00
|
|
|
git init -b main mirror-push/private &&
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd mirror-push/private &&
|
|
|
|
test_commit one &&
|
|
|
|
git remote add --mirror=push public ../public
|
remote: separate the concept of push and fetch mirrors
git-remote currently has one option, "--mirror", which sets
up mirror configuration which can be used for either
fetching or pushing. It looks like this:
[remote "mirror"]
url = wherever
fetch = +refs/*:refs/*
mirror = true
However, a remote like this can be dangerous and confusing.
Specifically:
1. If you issue the wrong command, it can be devastating.
You are not likely to "push" when you meant to "fetch",
but "git remote update" will try to fetch it, even if
you intended the remote only for pushing. In either
case, the results can be quite destructive. An
unintended push will overwrite or delete remote refs,
and an unintended fetch can overwrite local branches.
2. The tracking setup code can produce confusing results.
The fetch refspec above means that "git checkout -b new
master" will consider refs/heads/master to come from
the remote "mirror", even if you only ever intend to
push to the mirror. It will set up the "new" branch to
track mirror's refs/heads/master.
3. The push code tries to opportunistically update
tracking branches. If you "git push mirror foo:bar",
it will see that we are updating mirror's
refs/heads/bar, which corresponds to our local
refs/heads/bar, and will update our local branch.
To solve this, we split the concept into "push mirrors" and
"fetch mirrors". Push mirrors set only remote.*.mirror,
solving (2) and (3), and making an accidental fetch write
only into FETCH_HEAD. Fetch mirrors set only the fetch
refspec, meaning an accidental push will not force-overwrite
or delete refs on the remote end.
The new syntax is "--mirror=<fetch|push>". For
compatibility, we keep "--mirror" as-is, setting up both
types simultaneously.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-03-30 19:53:19 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'push mirrors act as mirrors during push' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd mirror-push/private &&
|
|
|
|
git branch new &&
|
2020-12-17 01:07:05 +00:00
|
|
|
git branch -m main renamed &&
|
2013-06-22 07:58:08 +00:00
|
|
|
git push public
|
remote: separate the concept of push and fetch mirrors
git-remote currently has one option, "--mirror", which sets
up mirror configuration which can be used for either
fetching or pushing. It looks like this:
[remote "mirror"]
url = wherever
fetch = +refs/*:refs/*
mirror = true
However, a remote like this can be dangerous and confusing.
Specifically:
1. If you issue the wrong command, it can be devastating.
You are not likely to "push" when you meant to "fetch",
but "git remote update" will try to fetch it, even if
you intended the remote only for pushing. In either
case, the results can be quite destructive. An
unintended push will overwrite or delete remote refs,
and an unintended fetch can overwrite local branches.
2. The tracking setup code can produce confusing results.
The fetch refspec above means that "git checkout -b new
master" will consider refs/heads/master to come from
the remote "mirror", even if you only ever intend to
push to the mirror. It will set up the "new" branch to
track mirror's refs/heads/master.
3. The push code tries to opportunistically update
tracking branches. If you "git push mirror foo:bar",
it will see that we are updating mirror's
refs/heads/bar, which corresponds to our local
refs/heads/bar, and will update our local branch.
To solve this, we split the concept into "push mirrors" and
"fetch mirrors". Push mirrors set only remote.*.mirror,
solving (2) and (3), and making an accidental fetch write
only into FETCH_HEAD. Fetch mirrors set only the fetch
refspec, meaning an accidental push will not force-overwrite
or delete refs on the remote end.
The new syntax is "--mirror=<fetch|push>". For
compatibility, we keep "--mirror" as-is, setting up both
types simultaneously.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-03-30 19:53:19 +00:00
|
|
|
) &&
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd mirror-push/private &&
|
|
|
|
git rev-parse --verify refs/heads/new &&
|
|
|
|
git rev-parse --verify refs/heads/renamed &&
|
2020-12-17 01:07:05 +00:00
|
|
|
test_must_fail git rev-parse --verify refs/heads/main
|
remote: separate the concept of push and fetch mirrors
git-remote currently has one option, "--mirror", which sets
up mirror configuration which can be used for either
fetching or pushing. It looks like this:
[remote "mirror"]
url = wherever
fetch = +refs/*:refs/*
mirror = true
However, a remote like this can be dangerous and confusing.
Specifically:
1. If you issue the wrong command, it can be devastating.
You are not likely to "push" when you meant to "fetch",
but "git remote update" will try to fetch it, even if
you intended the remote only for pushing. In either
case, the results can be quite destructive. An
unintended push will overwrite or delete remote refs,
and an unintended fetch can overwrite local branches.
2. The tracking setup code can produce confusing results.
The fetch refspec above means that "git checkout -b new
master" will consider refs/heads/master to come from
the remote "mirror", even if you only ever intend to
push to the mirror. It will set up the "new" branch to
track mirror's refs/heads/master.
3. The push code tries to opportunistically update
tracking branches. If you "git push mirror foo:bar",
it will see that we are updating mirror's
refs/heads/bar, which corresponds to our local
refs/heads/bar, and will update our local branch.
To solve this, we split the concept into "push mirrors" and
"fetch mirrors". Push mirrors set only remote.*.mirror,
solving (2) and (3), and making an accidental fetch write
only into FETCH_HEAD. Fetch mirrors set only the fetch
refspec, meaning an accidental push will not force-overwrite
or delete refs on the remote end.
The new syntax is "--mirror=<fetch|push>". For
compatibility, we keep "--mirror" as-is, setting up both
types simultaneously.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-03-30 19:53:19 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'push mirrors do not act as mirrors during fetch' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd mirror-push/public &&
|
|
|
|
git branch -m renamed renamed2 &&
|
|
|
|
git symbolic-ref HEAD refs/heads/renamed2
|
remote: separate the concept of push and fetch mirrors
git-remote currently has one option, "--mirror", which sets
up mirror configuration which can be used for either
fetching or pushing. It looks like this:
[remote "mirror"]
url = wherever
fetch = +refs/*:refs/*
mirror = true
However, a remote like this can be dangerous and confusing.
Specifically:
1. If you issue the wrong command, it can be devastating.
You are not likely to "push" when you meant to "fetch",
but "git remote update" will try to fetch it, even if
you intended the remote only for pushing. In either
case, the results can be quite destructive. An
unintended push will overwrite or delete remote refs,
and an unintended fetch can overwrite local branches.
2. The tracking setup code can produce confusing results.
The fetch refspec above means that "git checkout -b new
master" will consider refs/heads/master to come from
the remote "mirror", even if you only ever intend to
push to the mirror. It will set up the "new" branch to
track mirror's refs/heads/master.
3. The push code tries to opportunistically update
tracking branches. If you "git push mirror foo:bar",
it will see that we are updating mirror's
refs/heads/bar, which corresponds to our local
refs/heads/bar, and will update our local branch.
To solve this, we split the concept into "push mirrors" and
"fetch mirrors". Push mirrors set only remote.*.mirror,
solving (2) and (3), and making an accidental fetch write
only into FETCH_HEAD. Fetch mirrors set only the fetch
refspec, meaning an accidental push will not force-overwrite
or delete refs on the remote end.
The new syntax is "--mirror=<fetch|push>". For
compatibility, we keep "--mirror" as-is, setting up both
types simultaneously.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-03-30 19:53:19 +00:00
|
|
|
) &&
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd mirror-push/private &&
|
|
|
|
git fetch public &&
|
|
|
|
git rev-parse --verify refs/heads/renamed &&
|
|
|
|
test_must_fail git rev-parse --verify refs/heads/renamed2
|
remote: separate the concept of push and fetch mirrors
git-remote currently has one option, "--mirror", which sets
up mirror configuration which can be used for either
fetching or pushing. It looks like this:
[remote "mirror"]
url = wherever
fetch = +refs/*:refs/*
mirror = true
However, a remote like this can be dangerous and confusing.
Specifically:
1. If you issue the wrong command, it can be devastating.
You are not likely to "push" when you meant to "fetch",
but "git remote update" will try to fetch it, even if
you intended the remote only for pushing. In either
case, the results can be quite destructive. An
unintended push will overwrite or delete remote refs,
and an unintended fetch can overwrite local branches.
2. The tracking setup code can produce confusing results.
The fetch refspec above means that "git checkout -b new
master" will consider refs/heads/master to come from
the remote "mirror", even if you only ever intend to
push to the mirror. It will set up the "new" branch to
track mirror's refs/heads/master.
3. The push code tries to opportunistically update
tracking branches. If you "git push mirror foo:bar",
it will see that we are updating mirror's
refs/heads/bar, which corresponds to our local
refs/heads/bar, and will update our local branch.
To solve this, we split the concept into "push mirrors" and
"fetch mirrors". Push mirrors set only remote.*.mirror,
solving (2) and (3), and making an accidental fetch write
only into FETCH_HEAD. Fetch mirrors set only the fetch
refspec, meaning an accidental push will not force-overwrite
or delete refs on the remote end.
The new syntax is "--mirror=<fetch|push>". For
compatibility, we keep "--mirror" as-is, setting up both
types simultaneously.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-03-30 19:53:19 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2011-05-26 15:11:00 +00:00
|
|
|
test_expect_success 'push mirrors do not allow you to specify refs' '
|
|
|
|
git init mirror-push/track &&
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd mirror-push/track &&
|
|
|
|
test_must_fail git remote add --mirror=push -t new public ../public
|
2011-05-26 15:11:00 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2008-06-01 03:58:05 +00:00
|
|
|
test_expect_success 'add alt && prune' '
|
2013-06-22 07:58:08 +00:00
|
|
|
mkdir alttst &&
|
|
|
|
(
|
|
|
|
cd alttst &&
|
|
|
|
git init &&
|
|
|
|
git remote add -f origin ../one &&
|
|
|
|
git config remote.alt.url ../one &&
|
|
|
|
git config remote.alt.fetch "+refs/heads/*:refs/remotes/origin/*"
|
|
|
|
) &&
|
|
|
|
(
|
|
|
|
cd one &&
|
|
|
|
git branch -m side side2
|
|
|
|
) &&
|
|
|
|
(
|
|
|
|
cd alttst &&
|
|
|
|
git rev-parse --verify refs/remotes/origin/side &&
|
|
|
|
test_must_fail git rev-parse --verify refs/remotes/origin/side2 &&
|
|
|
|
git fetch alt &&
|
|
|
|
git remote prune alt &&
|
|
|
|
test_must_fail git rev-parse --verify refs/remotes/origin/side &&
|
|
|
|
git rev-parse --verify refs/remotes/origin/side2
|
|
|
|
)
|
2008-06-01 03:58:05 +00:00
|
|
|
'
|
|
|
|
|
2010-04-19 23:31:31 +00:00
|
|
|
cat >test/expect <<\EOF
|
|
|
|
some-tag
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'add with reachable tags (default)' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd one &&
|
|
|
|
>foobar &&
|
|
|
|
git add foobar &&
|
|
|
|
git commit -m "Foobar" &&
|
|
|
|
git tag -a -m "Foobar tag" foobar-tag &&
|
|
|
|
git reset --hard HEAD~1 &&
|
|
|
|
git tag -a -m "Some tag" some-tag
|
|
|
|
) &&
|
|
|
|
mkdir add-tags &&
|
|
|
|
(
|
|
|
|
cd add-tags &&
|
|
|
|
git init &&
|
|
|
|
git remote add -f origin ../one &&
|
|
|
|
git tag -l some-tag >../test/output &&
|
|
|
|
git tag -l foobar-tag >>../test/output &&
|
|
|
|
test_must_fail git config remote.origin.tagopt
|
|
|
|
) &&
|
2010-04-19 23:31:31 +00:00
|
|
|
test_cmp test/expect test/output
|
|
|
|
'
|
|
|
|
|
|
|
|
cat >test/expect <<\EOF
|
|
|
|
some-tag
|
|
|
|
foobar-tag
|
|
|
|
--tags
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'add --tags' '
|
2013-06-22 07:58:08 +00:00
|
|
|
rm -rf add-tags &&
|
|
|
|
(
|
|
|
|
mkdir add-tags &&
|
|
|
|
cd add-tags &&
|
|
|
|
git init &&
|
|
|
|
git remote add -f --tags origin ../one &&
|
|
|
|
git tag -l some-tag >../test/output &&
|
|
|
|
git tag -l foobar-tag >>../test/output &&
|
|
|
|
git config remote.origin.tagopt >>../test/output
|
|
|
|
) &&
|
2010-04-19 23:31:31 +00:00
|
|
|
test_cmp test/expect test/output
|
|
|
|
'
|
|
|
|
|
|
|
|
cat >test/expect <<\EOF
|
|
|
|
--no-tags
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'add --no-tags' '
|
2013-06-22 07:58:08 +00:00
|
|
|
rm -rf add-tags &&
|
|
|
|
(
|
|
|
|
mkdir add-no-tags &&
|
|
|
|
cd add-no-tags &&
|
|
|
|
git init &&
|
|
|
|
git remote add -f --no-tags origin ../one &&
|
2021-02-25 01:21:16 +00:00
|
|
|
grep tagOpt .git/config &&
|
2013-06-22 07:58:08 +00:00
|
|
|
git tag -l some-tag >../test/output &&
|
|
|
|
git tag -l foobar-tag >../test/output &&
|
|
|
|
git config remote.origin.tagopt >>../test/output
|
|
|
|
) &&
|
|
|
|
(
|
|
|
|
cd one &&
|
|
|
|
git tag -d some-tag foobar-tag
|
|
|
|
) &&
|
2010-04-19 23:31:31 +00:00
|
|
|
test_cmp test/expect test/output
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'reject --no-no-tags' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd add-no-tags &&
|
|
|
|
test_must_fail git remote add -f --no-no-tags neworigin ../one
|
|
|
|
)
|
2010-04-19 23:31:31 +00:00
|
|
|
'
|
|
|
|
|
2013-06-22 07:58:08 +00:00
|
|
|
cat >one/expect <<\EOF
|
2020-12-17 01:07:05 +00:00
|
|
|
apis/main
|
2008-03-04 11:23:53 +00:00
|
|
|
apis/side
|
|
|
|
drosophila/another
|
2020-12-17 01:07:05 +00:00
|
|
|
drosophila/main
|
2008-03-04 11:23:53 +00:00
|
|
|
drosophila/side
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'update' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd one &&
|
|
|
|
git remote add drosophila ../two &&
|
|
|
|
git remote add apis ../mirror &&
|
|
|
|
git remote update &&
|
|
|
|
git branch -r >output &&
|
|
|
|
test_cmp expect output
|
|
|
|
)
|
2008-03-04 11:23:53 +00:00
|
|
|
'
|
|
|
|
|
2013-06-22 07:58:08 +00:00
|
|
|
cat >one/expect <<\EOF
|
2008-03-04 11:23:53 +00:00
|
|
|
drosophila/another
|
2020-12-17 01:07:05 +00:00
|
|
|
drosophila/main
|
2008-03-04 11:23:53 +00:00
|
|
|
drosophila/side
|
2020-12-17 01:07:05 +00:00
|
|
|
manduca/main
|
2008-03-04 11:23:53 +00:00
|
|
|
manduca/side
|
2020-12-17 01:07:05 +00:00
|
|
|
megaloprepus/main
|
2008-03-04 11:23:53 +00:00
|
|
|
megaloprepus/side
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'update with arguments' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd one &&
|
|
|
|
for b in $(git branch -r)
|
|
|
|
do
|
2015-03-25 05:29:52 +00:00
|
|
|
git branch -r -d $b || exit 1
|
2013-06-22 07:58:08 +00:00
|
|
|
done &&
|
|
|
|
git remote add manduca ../mirror &&
|
|
|
|
git remote add megaloprepus ../mirror &&
|
|
|
|
git config remotes.phobaeticus "drosophila megaloprepus" &&
|
|
|
|
git config remotes.titanus manduca &&
|
|
|
|
git remote update phobaeticus titanus &&
|
|
|
|
git branch -r >output &&
|
|
|
|
test_cmp expect output
|
|
|
|
)
|
2008-03-04 11:23:53 +00:00
|
|
|
'
|
|
|
|
|
2009-11-09 20:11:59 +00:00
|
|
|
test_expect_success 'update --prune' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd one &&
|
|
|
|
git branch -m side2 side3
|
|
|
|
) &&
|
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
git remote update --prune &&
|
|
|
|
(
|
|
|
|
cd ../one &&
|
|
|
|
git branch -m side3 side2
|
|
|
|
) &&
|
|
|
|
git rev-parse refs/remotes/origin/side3 &&
|
|
|
|
test_must_fail git rev-parse refs/remotes/origin/side2
|
|
|
|
)
|
2009-11-09 20:11:59 +00:00
|
|
|
'
|
|
|
|
|
2013-06-22 07:58:08 +00:00
|
|
|
cat >one/expect <<-\EOF
|
2020-12-17 01:07:05 +00:00
|
|
|
apis/main
|
2008-03-04 11:23:53 +00:00
|
|
|
apis/side
|
2020-12-17 01:07:05 +00:00
|
|
|
manduca/main
|
2008-03-04 11:23:53 +00:00
|
|
|
manduca/side
|
2020-12-17 01:07:05 +00:00
|
|
|
megaloprepus/main
|
2008-03-04 11:23:53 +00:00
|
|
|
megaloprepus/side
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'update default' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd one &&
|
|
|
|
for b in $(git branch -r)
|
|
|
|
do
|
2015-03-25 05:29:52 +00:00
|
|
|
git branch -r -d $b || exit 1
|
2013-06-22 07:58:08 +00:00
|
|
|
done &&
|
|
|
|
git config remote.drosophila.skipDefaultUpdate true &&
|
|
|
|
git remote update default &&
|
|
|
|
git branch -r >output &&
|
|
|
|
test_cmp expect output
|
|
|
|
)
|
2008-03-04 11:23:53 +00:00
|
|
|
'
|
|
|
|
|
2013-06-22 07:58:08 +00:00
|
|
|
cat >one/expect <<\EOF
|
2008-03-04 11:23:53 +00:00
|
|
|
drosophila/another
|
2020-12-17 01:07:05 +00:00
|
|
|
drosophila/main
|
2008-03-04 11:23:53 +00:00
|
|
|
drosophila/side
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'update default (overridden, with funny whitespace)' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd one &&
|
|
|
|
for b in $(git branch -r)
|
|
|
|
do
|
2015-03-25 05:29:52 +00:00
|
|
|
git branch -r -d $b || exit 1
|
2013-06-22 07:58:08 +00:00
|
|
|
done &&
|
|
|
|
git config remotes.default "$(printf "\t drosophila \n")" &&
|
|
|
|
git remote update default &&
|
|
|
|
git branch -r >output &&
|
|
|
|
test_cmp expect output
|
|
|
|
)
|
2008-03-04 11:23:53 +00:00
|
|
|
'
|
|
|
|
|
2009-12-31 09:43:17 +00:00
|
|
|
test_expect_success 'update (with remotes.default defined)' '
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd one &&
|
|
|
|
for b in $(git branch -r)
|
|
|
|
do
|
2015-03-25 05:29:52 +00:00
|
|
|
git branch -r -d $b || exit 1
|
2013-06-22 07:58:08 +00:00
|
|
|
done &&
|
|
|
|
git config remotes.default "drosophila" &&
|
|
|
|
git remote update &&
|
|
|
|
git branch -r >output &&
|
|
|
|
test_cmp expect output
|
|
|
|
)
|
2009-12-31 09:43:17 +00:00
|
|
|
'
|
|
|
|
|
2008-03-19 00:27:42 +00:00
|
|
|
test_expect_success '"remote show" does not show symbolic refs' '
|
|
|
|
git clone one three &&
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd three &&
|
|
|
|
git remote show origin >output &&
|
|
|
|
! grep "^ *HEAD$" < output &&
|
|
|
|
! grep -i stale < output
|
|
|
|
)
|
2008-03-19 00:27:42 +00:00
|
|
|
'
|
|
|
|
|
2008-04-13 09:56:54 +00:00
|
|
|
test_expect_success 'reject adding remote with an invalid name' '
|
2008-07-12 15:47:52 +00:00
|
|
|
test_must_fail git remote add some:url desired-name
|
2008-04-13 09:56:54 +00:00
|
|
|
'
|
|
|
|
|
2008-11-03 18:26:18 +00:00
|
|
|
# The first three test if the tracking branches are properly renamed,
|
|
|
|
# the last two ones check if the config is updated.
|
|
|
|
|
|
|
|
test_expect_success 'rename a remote' '
|
2020-02-01 09:34:09 +00:00
|
|
|
test_config_global remote.pushDefault origin &&
|
2008-11-03 18:26:18 +00:00
|
|
|
git clone one four &&
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd four &&
|
2020-12-17 01:07:05 +00:00
|
|
|
git config branch.main.pushRemote origin &&
|
builtin/remote.c: show progress when renaming remote references
When renaming a remote, Git needs to rename all remote tracking
references to the remote's new name (e.g., renaming
"refs/remotes/old/foo" to "refs/remotes/new/foo" when renaming a remote
from "old" to "new").
This can be somewhat slow when there are many references to rename,
since each rename is done in a separate call to rename_ref() as opposed
to grouping all renames together into the same transaction. It would be
nice to execute all renames as a single transaction, but there is a
snag: the reference transaction backend doesn't support renames during a
transaction (only individually, via rename_ref()).
The reasons there are described in more detail in [1], but the main
problem is that in order to preserve the existing reflog, it must be
moved while holding both locks (i.e., on "oldname" and "newname"), and
the ref transaction code doesn't support inserting arbitrary actions
into the middle of a transaction like that.
As an aside, adding support for this to the ref transaction code is
less straightforward than inserting both a ref_update() and ref_delete()
call into the same transaction. rename_ref()'s special handling to
detect D/F conflicts would need to be rewritten for the transaction code
if we wanted to proactively catch D/F conflicts when renaming a
reference during a transaction. The reftable backend could support this
much more readily because of its lack of D/F conflicts.
Instead of a more complex modification to the ref transaction code,
display a progress meter when running verbosely in order to convince the
user that Git is doing work while renaming a remote.
This is mostly done as-expected, with the minor caveat that we
intentionally count symrefs renames twice, since renaming a symref takes
place over two separate calls (one to delete the old one, and another to
create the new one).
[1]: https://lore.kernel.org/git/572367B4.4050207@alum.mit.edu/
Suggested-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-03-03 22:25:18 +00:00
|
|
|
GIT_TRACE2_EVENT=$(pwd)/trace \
|
|
|
|
git remote rename --progress origin upstream &&
|
|
|
|
test_region progress "Renaming remote references" trace &&
|
2021-02-25 01:21:17 +00:00
|
|
|
grep "pushRemote" .git/config &&
|
2017-01-06 16:22:23 +00:00
|
|
|
test -z "$(git for-each-ref refs/remotes/origin)" &&
|
2020-12-17 01:07:05 +00:00
|
|
|
test "$(git symbolic-ref refs/remotes/upstream/HEAD)" = "refs/remotes/upstream/main" &&
|
|
|
|
test "$(git rev-parse upstream/main)" = "$(git rev-parse main)" &&
|
2013-06-22 07:58:08 +00:00
|
|
|
test "$(git config remote.upstream.fetch)" = "+refs/heads/*:refs/remotes/upstream/*" &&
|
2020-12-17 01:07:05 +00:00
|
|
|
test "$(git config branch.main.remote)" = "upstream" &&
|
|
|
|
test "$(git config branch.main.pushRemote)" = "upstream" &&
|
2020-02-01 09:34:09 +00:00
|
|
|
test "$(git config --global remote.pushDefault)" = "origin"
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'rename a remote renames repo remote.pushDefault' '
|
|
|
|
git clone one four.1 &&
|
|
|
|
(
|
|
|
|
cd four.1 &&
|
|
|
|
git config remote.pushDefault origin &&
|
|
|
|
git remote rename origin upstream &&
|
2021-02-25 01:21:17 +00:00
|
|
|
grep pushDefault .git/config &&
|
2020-02-01 09:34:09 +00:00
|
|
|
test "$(git config --local remote.pushDefault)" = "upstream"
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'rename a remote renames repo remote.pushDefault but ignores global' '
|
|
|
|
test_config_global remote.pushDefault other &&
|
|
|
|
git clone one four.2 &&
|
|
|
|
(
|
|
|
|
cd four.2 &&
|
|
|
|
git config remote.pushDefault origin &&
|
|
|
|
git remote rename origin upstream &&
|
|
|
|
test "$(git config --global remote.pushDefault)" = "other" &&
|
|
|
|
test "$(git config --local remote.pushDefault)" = "upstream"
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'rename a remote renames repo remote.pushDefault but keeps global' '
|
|
|
|
test_config_global remote.pushDefault origin &&
|
|
|
|
git clone one four.3 &&
|
|
|
|
(
|
|
|
|
cd four.3 &&
|
|
|
|
git config remote.pushDefault origin &&
|
|
|
|
git remote rename origin upstream &&
|
|
|
|
test "$(git config --global remote.pushDefault)" = "origin" &&
|
|
|
|
test "$(git config --local remote.pushDefault)" = "upstream"
|
2013-06-22 07:58:08 +00:00
|
|
|
)
|
2008-11-03 18:26:18 +00:00
|
|
|
'
|
2008-11-10 20:43:01 +00:00
|
|
|
|
2011-09-02 00:50:33 +00:00
|
|
|
test_expect_success 'rename does not update a non-default fetch refspec' '
|
|
|
|
git clone one four.one &&
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd four.one &&
|
|
|
|
git config remote.origin.fetch +refs/heads/*:refs/heads/origin/* &&
|
|
|
|
git remote rename origin upstream &&
|
|
|
|
test "$(git config remote.upstream.fetch)" = "+refs/heads/*:refs/heads/origin/*" &&
|
2020-12-17 01:07:05 +00:00
|
|
|
git rev-parse -q origin/main
|
2013-06-22 07:58:08 +00:00
|
|
|
)
|
2011-09-02 00:50:33 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'rename a remote with name part of fetch spec' '
|
|
|
|
git clone one four.two &&
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd four.two &&
|
|
|
|
git remote rename origin remote &&
|
|
|
|
git remote rename remote upstream &&
|
|
|
|
test "$(git config remote.upstream.fetch)" = "+refs/heads/*:refs/remotes/upstream/*"
|
|
|
|
)
|
2011-09-02 00:50:33 +00:00
|
|
|
'
|
|
|
|
|
2011-09-02 00:50:34 +00:00
|
|
|
test_expect_success 'rename a remote with name prefix of other remote' '
|
|
|
|
git clone one four.three &&
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd four.three &&
|
|
|
|
git remote add o git://example.com/repo.git &&
|
|
|
|
git remote rename o upstream &&
|
2020-12-17 01:07:05 +00:00
|
|
|
test "$(git rev-parse origin/main)" = "$(git rev-parse main)"
|
2013-06-22 07:58:08 +00:00
|
|
|
)
|
2011-09-02 00:50:34 +00:00
|
|
|
'
|
|
|
|
|
2017-01-19 21:20:02 +00:00
|
|
|
test_expect_success 'rename succeeds with existing remote.<target>.prune' '
|
2017-01-19 21:19:58 +00:00
|
|
|
git clone one four.four &&
|
|
|
|
test_when_finished git config --global --unset remote.upstream.prune &&
|
|
|
|
git config --global remote.upstream.prune true &&
|
|
|
|
git -C four.four remote rename origin upstream
|
|
|
|
'
|
|
|
|
|
2020-01-27 07:04:30 +00:00
|
|
|
test_expect_success 'remove a remote' '
|
2020-02-01 09:34:09 +00:00
|
|
|
test_config_global remote.pushDefault origin &&
|
2020-01-27 07:04:30 +00:00
|
|
|
git clone one four.five &&
|
|
|
|
(
|
|
|
|
cd four.five &&
|
2020-12-17 01:07:05 +00:00
|
|
|
git config branch.main.pushRemote origin &&
|
2020-01-27 07:04:30 +00:00
|
|
|
git remote remove origin &&
|
|
|
|
test -z "$(git for-each-ref refs/remotes/origin)" &&
|
2020-12-17 01:07:05 +00:00
|
|
|
test_must_fail git config branch.main.remote &&
|
|
|
|
test_must_fail git config branch.main.pushRemote &&
|
2020-02-01 09:34:09 +00:00
|
|
|
test "$(git config --global remote.pushDefault)" = "origin"
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'remove a remote removes repo remote.pushDefault' '
|
|
|
|
git clone one four.five.1 &&
|
|
|
|
(
|
|
|
|
cd four.five.1 &&
|
|
|
|
git config remote.pushDefault origin &&
|
|
|
|
git remote remove origin &&
|
|
|
|
test_must_fail git config --local remote.pushDefault
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'remove a remote removes repo remote.pushDefault but ignores global' '
|
|
|
|
test_config_global remote.pushDefault other &&
|
|
|
|
git clone one four.five.2 &&
|
|
|
|
(
|
|
|
|
cd four.five.2 &&
|
|
|
|
git config remote.pushDefault origin &&
|
|
|
|
git remote remove origin &&
|
|
|
|
test "$(git config --global remote.pushDefault)" = "other" &&
|
|
|
|
test_must_fail git config --local remote.pushDefault
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'remove a remote removes repo remote.pushDefault but keeps global' '
|
|
|
|
test_config_global remote.pushDefault origin &&
|
|
|
|
git clone one four.five.3 &&
|
|
|
|
(
|
|
|
|
cd four.five.3 &&
|
|
|
|
git config remote.pushDefault origin &&
|
|
|
|
git remote remove origin &&
|
|
|
|
test "$(git config --global remote.pushDefault)" = "origin" &&
|
|
|
|
test_must_fail git config --local remote.pushDefault
|
2020-01-27 07:04:30 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2013-06-22 07:58:08 +00:00
|
|
|
cat >remotes_origin <<EOF
|
2008-11-10 20:43:01 +00:00
|
|
|
URL: $(pwd)/one
|
2020-12-17 01:07:05 +00:00
|
|
|
Push: refs/heads/main:refs/heads/upstream
|
2013-06-22 07:58:18 +00:00
|
|
|
Push: refs/heads/next:refs/heads/upstream2
|
2020-12-17 01:07:05 +00:00
|
|
|
Pull: refs/heads/main:refs/heads/origin
|
2013-06-22 07:58:18 +00:00
|
|
|
Pull: refs/heads/next:refs/heads/origin2
|
2008-11-10 20:43:01 +00:00
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'migrate a remote from named file in $GIT_DIR/remotes' '
|
|
|
|
git clone one five &&
|
|
|
|
origin_url=$(pwd)/one &&
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd five &&
|
|
|
|
git remote remove origin &&
|
|
|
|
mkdir -p .git/remotes &&
|
|
|
|
cat ../remotes_origin >.git/remotes/origin &&
|
|
|
|
git remote rename origin origin &&
|
2013-06-22 07:58:10 +00:00
|
|
|
test_path_is_missing .git/remotes/origin &&
|
2013-06-22 07:58:08 +00:00
|
|
|
test "$(git config remote.origin.url)" = "$origin_url" &&
|
2013-06-22 07:58:18 +00:00
|
|
|
cat >push_expected <<-\EOF &&
|
2020-12-17 01:07:05 +00:00
|
|
|
refs/heads/main:refs/heads/upstream
|
2013-06-22 07:58:18 +00:00
|
|
|
refs/heads/next:refs/heads/upstream2
|
|
|
|
EOF
|
|
|
|
cat >fetch_expected <<-\EOF &&
|
2020-12-17 01:07:05 +00:00
|
|
|
refs/heads/main:refs/heads/origin
|
2013-06-22 07:58:18 +00:00
|
|
|
refs/heads/next:refs/heads/origin2
|
|
|
|
EOF
|
|
|
|
git config --get-all remote.origin.push >push_actual &&
|
|
|
|
git config --get-all remote.origin.fetch >fetch_actual &&
|
|
|
|
test_cmp push_expected push_actual &&
|
|
|
|
test_cmp fetch_expected fetch_actual
|
2013-06-22 07:58:08 +00:00
|
|
|
)
|
2008-11-10 20:43:01 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'migrate a remote from named file in $GIT_DIR/branches' '
|
|
|
|
git clone one six &&
|
|
|
|
origin_url=$(pwd)/one &&
|
2013-06-22 07:58:08 +00:00
|
|
|
(
|
|
|
|
cd six &&
|
|
|
|
git remote rm origin &&
|
2020-12-17 01:07:05 +00:00
|
|
|
echo "$origin_url#main" >.git/branches/origin &&
|
2013-06-22 07:58:08 +00:00
|
|
|
git remote rename origin origin &&
|
2013-06-22 07:58:10 +00:00
|
|
|
test_path_is_missing .git/branches/origin &&
|
2013-06-22 07:58:08 +00:00
|
|
|
test "$(git config remote.origin.url)" = "$origin_url" &&
|
2020-12-17 01:07:05 +00:00
|
|
|
test "$(git config remote.origin.fetch)" = "refs/heads/main:refs/heads/origin" &&
|
|
|
|
test "$(git config remote.origin.push)" = "HEAD:refs/heads/main"
|
2013-06-22 07:58:08 +00:00
|
|
|
)
|
2008-11-10 20:43:01 +00:00
|
|
|
'
|
|
|
|
|
2013-06-22 07:58:13 +00:00
|
|
|
test_expect_success 'migrate a remote from named file in $GIT_DIR/branches (2)' '
|
2009-02-09 07:27:10 +00:00
|
|
|
git clone one seven &&
|
2013-06-22 07:58:13 +00:00
|
|
|
(
|
|
|
|
cd seven &&
|
|
|
|
git remote rm origin &&
|
|
|
|
echo "quux#foom" > .git/branches/origin &&
|
|
|
|
git remote rename origin origin &&
|
|
|
|
test_path_is_missing .git/branches/origin &&
|
|
|
|
test "$(git config remote.origin.url)" = "quux" &&
|
2018-07-02 00:24:01 +00:00
|
|
|
test "$(git config remote.origin.fetch)" = "refs/heads/foom:refs/heads/origin" &&
|
2013-06-22 07:58:13 +00:00
|
|
|
test "$(git config remote.origin.push)" = "HEAD:refs/heads/foom"
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'remote prune to cause a dangling symref' '
|
|
|
|
git clone one eight &&
|
2009-02-09 07:27:10 +00:00
|
|
|
(
|
|
|
|
cd one &&
|
|
|
|
git checkout side2 &&
|
2020-12-17 01:07:05 +00:00
|
|
|
git branch -D main
|
2009-02-09 07:27:10 +00:00
|
|
|
) &&
|
|
|
|
(
|
2013-06-22 07:58:13 +00:00
|
|
|
cd eight &&
|
2009-02-09 07:27:10 +00:00
|
|
|
git remote prune origin
|
2010-03-16 05:12:55 +00:00
|
|
|
) >err 2>&1 &&
|
2012-08-27 05:36:54 +00:00
|
|
|
test_i18ngrep "has become dangling" err &&
|
2009-02-09 07:27:10 +00:00
|
|
|
|
2010-03-16 05:12:55 +00:00
|
|
|
: And the dangling symref will not cause other annoying errors &&
|
2009-02-09 07:27:10 +00:00
|
|
|
(
|
2013-06-22 07:58:13 +00:00
|
|
|
cd eight &&
|
2009-02-09 07:27:10 +00:00
|
|
|
git branch -a
|
|
|
|
) 2>err &&
|
2010-03-16 05:12:55 +00:00
|
|
|
! grep "points nowhere" err &&
|
2009-02-09 07:52:01 +00:00
|
|
|
(
|
2013-06-22 07:58:13 +00:00
|
|
|
cd eight &&
|
2009-02-09 07:52:01 +00:00
|
|
|
test_must_fail git branch nomore origin
|
|
|
|
) 2>err &&
|
2018-07-21 07:49:35 +00:00
|
|
|
test_i18ngrep "dangling symref" err
|
2009-02-09 07:27:10 +00:00
|
|
|
'
|
|
|
|
|
2009-05-27 20:13:43 +00:00
|
|
|
test_expect_success 'show empty remote' '
|
|
|
|
test_create_repo empty &&
|
|
|
|
git clone empty empty-clone &&
|
|
|
|
(
|
|
|
|
cd empty-clone &&
|
|
|
|
git remote show origin
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2010-05-19 18:38:50 +00:00
|
|
|
test_expect_success 'remote set-branches requires a remote' '
|
|
|
|
test_must_fail git remote set-branches &&
|
|
|
|
test_must_fail git remote set-branches --add
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'remote set-branches' '
|
|
|
|
echo "+refs/heads/*:refs/remotes/scratch/*" >expect.initial &&
|
|
|
|
sort <<-\EOF >expect.add &&
|
|
|
|
+refs/heads/*:refs/remotes/scratch/*
|
|
|
|
+refs/heads/other:refs/remotes/scratch/other
|
|
|
|
EOF
|
|
|
|
sort <<-\EOF >expect.replace &&
|
|
|
|
+refs/heads/maint:refs/remotes/scratch/maint
|
2020-12-17 01:07:05 +00:00
|
|
|
+refs/heads/main:refs/remotes/scratch/main
|
2010-05-19 18:38:50 +00:00
|
|
|
+refs/heads/next:refs/remotes/scratch/next
|
|
|
|
EOF
|
|
|
|
sort <<-\EOF >expect.add-two &&
|
|
|
|
+refs/heads/maint:refs/remotes/scratch/maint
|
2020-12-17 01:07:05 +00:00
|
|
|
+refs/heads/main:refs/remotes/scratch/main
|
2010-05-19 18:38:50 +00:00
|
|
|
+refs/heads/next:refs/remotes/scratch/next
|
2020-06-25 12:18:59 +00:00
|
|
|
+refs/heads/seen:refs/remotes/scratch/seen
|
2010-05-19 18:38:50 +00:00
|
|
|
+refs/heads/t/topic:refs/remotes/scratch/t/topic
|
|
|
|
EOF
|
|
|
|
sort <<-\EOF >expect.setup-ffonly &&
|
2020-12-17 01:07:05 +00:00
|
|
|
refs/heads/main:refs/remotes/scratch/main
|
2010-05-19 18:38:50 +00:00
|
|
|
+refs/heads/next:refs/remotes/scratch/next
|
|
|
|
EOF
|
|
|
|
sort <<-\EOF >expect.respect-ffonly &&
|
2020-12-17 01:07:05 +00:00
|
|
|
refs/heads/main:refs/remotes/scratch/main
|
2010-05-19 18:38:50 +00:00
|
|
|
+refs/heads/next:refs/remotes/scratch/next
|
2020-06-25 12:18:59 +00:00
|
|
|
+refs/heads/seen:refs/remotes/scratch/seen
|
2010-05-19 18:38:50 +00:00
|
|
|
EOF
|
|
|
|
|
|
|
|
git clone .git/ setbranches &&
|
|
|
|
(
|
|
|
|
cd setbranches &&
|
|
|
|
git remote rename origin scratch &&
|
|
|
|
git config --get-all remote.scratch.fetch >config-result &&
|
|
|
|
sort <config-result >../actual.initial &&
|
|
|
|
|
|
|
|
git remote set-branches scratch --add other &&
|
|
|
|
git config --get-all remote.scratch.fetch >config-result &&
|
|
|
|
sort <config-result >../actual.add &&
|
|
|
|
|
2020-12-17 01:07:05 +00:00
|
|
|
git remote set-branches scratch maint main next &&
|
2010-05-19 18:38:50 +00:00
|
|
|
git config --get-all remote.scratch.fetch >config-result &&
|
|
|
|
sort <config-result >../actual.replace &&
|
|
|
|
|
2020-06-25 12:18:59 +00:00
|
|
|
git remote set-branches --add scratch seen t/topic &&
|
2010-05-19 18:38:50 +00:00
|
|
|
git config --get-all remote.scratch.fetch >config-result &&
|
|
|
|
sort <config-result >../actual.add-two &&
|
|
|
|
|
|
|
|
git config --unset-all remote.scratch.fetch &&
|
|
|
|
git config remote.scratch.fetch \
|
2020-12-17 01:07:05 +00:00
|
|
|
refs/heads/main:refs/remotes/scratch/main &&
|
2010-05-19 18:38:50 +00:00
|
|
|
git config --add remote.scratch.fetch \
|
|
|
|
+refs/heads/next:refs/remotes/scratch/next &&
|
|
|
|
git config --get-all remote.scratch.fetch >config-result &&
|
|
|
|
sort <config-result >../actual.setup-ffonly &&
|
|
|
|
|
2020-06-25 12:18:59 +00:00
|
|
|
git remote set-branches --add scratch seen &&
|
2010-05-19 18:38:50 +00:00
|
|
|
git config --get-all remote.scratch.fetch >config-result &&
|
|
|
|
sort <config-result >../actual.respect-ffonly
|
|
|
|
) &&
|
|
|
|
test_cmp expect.initial actual.initial &&
|
|
|
|
test_cmp expect.add actual.add &&
|
|
|
|
test_cmp expect.replace actual.replace &&
|
|
|
|
test_cmp expect.add-two actual.add-two &&
|
|
|
|
test_cmp expect.setup-ffonly actual.setup-ffonly &&
|
|
|
|
test_cmp expect.respect-ffonly actual.respect-ffonly
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'remote set-branches with --mirror' '
|
|
|
|
echo "+refs/*:refs/*" >expect.initial &&
|
2020-12-17 01:07:05 +00:00
|
|
|
echo "+refs/heads/main:refs/heads/main" >expect.replace &&
|
2010-05-19 18:38:50 +00:00
|
|
|
git clone --mirror .git/ setbranches-mirror &&
|
|
|
|
(
|
|
|
|
cd setbranches-mirror &&
|
|
|
|
git remote rename origin scratch &&
|
|
|
|
git config --get-all remote.scratch.fetch >../actual.initial &&
|
|
|
|
|
2020-12-17 01:07:05 +00:00
|
|
|
git remote set-branches scratch heads/main &&
|
2010-05-19 18:38:50 +00:00
|
|
|
git config --get-all remote.scratch.fetch >../actual.replace
|
|
|
|
) &&
|
|
|
|
test_cmp expect.initial actual.initial &&
|
|
|
|
test_cmp expect.replace actual.replace
|
|
|
|
'
|
|
|
|
|
2010-01-18 17:18:02 +00:00
|
|
|
test_expect_success 'new remote' '
|
|
|
|
git remote add someremote foo &&
|
|
|
|
echo foo >expect &&
|
|
|
|
git config --get-all remote.someremote.url >actual &&
|
|
|
|
cmp expect actual
|
|
|
|
'
|
|
|
|
|
2015-09-16 01:53:47 +00:00
|
|
|
get_url_test () {
|
|
|
|
cat >expect &&
|
|
|
|
git remote get-url "$@" >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
}
|
|
|
|
|
|
|
|
test_expect_success 'get-url on new remote' '
|
|
|
|
echo foo | get_url_test someremote &&
|
|
|
|
echo foo | get_url_test --all someremote &&
|
|
|
|
echo foo | get_url_test --push someremote &&
|
|
|
|
echo foo | get_url_test --push --all someremote
|
|
|
|
'
|
|
|
|
|
2016-02-22 11:23:28 +00:00
|
|
|
test_expect_success 'remote set-url with locked config' '
|
|
|
|
test_when_finished "rm -f .git/config.lock" &&
|
|
|
|
git config --get-all remote.someremote.url >expect &&
|
|
|
|
>.git/config.lock &&
|
|
|
|
test_must_fail git remote set-url someremote baz &&
|
|
|
|
git config --get-all remote.someremote.url >actual &&
|
|
|
|
cmp expect actual
|
|
|
|
'
|
|
|
|
|
2010-01-18 17:18:02 +00:00
|
|
|
test_expect_success 'remote set-url bar' '
|
|
|
|
git remote set-url someremote bar &&
|
|
|
|
echo bar >expect &&
|
|
|
|
git config --get-all remote.someremote.url >actual &&
|
|
|
|
cmp expect actual
|
|
|
|
'
|
2009-02-09 07:52:01 +00:00
|
|
|
|
2010-01-18 17:18:02 +00:00
|
|
|
test_expect_success 'remote set-url baz bar' '
|
|
|
|
git remote set-url someremote baz bar &&
|
|
|
|
echo baz >expect &&
|
|
|
|
git config --get-all remote.someremote.url >actual &&
|
|
|
|
cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'remote set-url zot bar' '
|
|
|
|
test_must_fail git remote set-url someremote zot bar &&
|
|
|
|
echo baz >expect &&
|
|
|
|
git config --get-all remote.someremote.url >actual &&
|
|
|
|
cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'remote set-url --push zot baz' '
|
|
|
|
test_must_fail git remote set-url --push someremote zot baz &&
|
|
|
|
echo "YYY" >expect &&
|
|
|
|
echo baz >>expect &&
|
|
|
|
test_must_fail git config --get-all remote.someremote.pushurl >actual &&
|
|
|
|
echo "YYY" >>actual &&
|
|
|
|
git config --get-all remote.someremote.url >>actual &&
|
|
|
|
cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'remote set-url --push zot' '
|
|
|
|
git remote set-url --push someremote zot &&
|
|
|
|
echo zot >expect &&
|
|
|
|
echo "YYY" >>expect &&
|
|
|
|
echo baz >>expect &&
|
|
|
|
git config --get-all remote.someremote.pushurl >actual &&
|
|
|
|
echo "YYY" >>actual &&
|
|
|
|
git config --get-all remote.someremote.url >>actual &&
|
|
|
|
cmp expect actual
|
|
|
|
'
|
|
|
|
|
2015-09-16 01:53:47 +00:00
|
|
|
test_expect_success 'get-url with different urls' '
|
|
|
|
echo baz | get_url_test someremote &&
|
|
|
|
echo baz | get_url_test --all someremote &&
|
|
|
|
echo zot | get_url_test --push someremote &&
|
|
|
|
echo zot | get_url_test --push --all someremote
|
|
|
|
'
|
|
|
|
|
2010-01-18 17:18:02 +00:00
|
|
|
test_expect_success 'remote set-url --push qux zot' '
|
|
|
|
git remote set-url --push someremote qux zot &&
|
|
|
|
echo qux >expect &&
|
|
|
|
echo "YYY" >>expect &&
|
|
|
|
echo baz >>expect &&
|
|
|
|
git config --get-all remote.someremote.pushurl >actual &&
|
|
|
|
echo "YYY" >>actual &&
|
|
|
|
git config --get-all remote.someremote.url >>actual &&
|
|
|
|
cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'remote set-url --push foo qu+x' '
|
|
|
|
git remote set-url --push someremote foo qu+x &&
|
|
|
|
echo foo >expect &&
|
|
|
|
echo "YYY" >>expect &&
|
|
|
|
echo baz >>expect &&
|
|
|
|
git config --get-all remote.someremote.pushurl >actual &&
|
|
|
|
echo "YYY" >>actual &&
|
|
|
|
git config --get-all remote.someremote.url >>actual &&
|
|
|
|
cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'remote set-url --push --add aaa' '
|
|
|
|
git remote set-url --push --add someremote aaa &&
|
|
|
|
echo foo >expect &&
|
|
|
|
echo aaa >>expect &&
|
|
|
|
echo "YYY" >>expect &&
|
|
|
|
echo baz >>expect &&
|
|
|
|
git config --get-all remote.someremote.pushurl >actual &&
|
|
|
|
echo "YYY" >>actual &&
|
|
|
|
git config --get-all remote.someremote.url >>actual &&
|
|
|
|
cmp expect actual
|
|
|
|
'
|
|
|
|
|
2015-09-16 01:53:47 +00:00
|
|
|
test_expect_success 'get-url on multi push remote' '
|
|
|
|
echo foo | get_url_test --push someremote &&
|
|
|
|
get_url_test --push --all someremote <<-\EOF
|
|
|
|
foo
|
|
|
|
aaa
|
|
|
|
EOF
|
|
|
|
'
|
|
|
|
|
2010-01-18 17:18:02 +00:00
|
|
|
test_expect_success 'remote set-url --push bar aaa' '
|
|
|
|
git remote set-url --push someremote bar aaa &&
|
|
|
|
echo foo >expect &&
|
|
|
|
echo bar >>expect &&
|
|
|
|
echo "YYY" >>expect &&
|
|
|
|
echo baz >>expect &&
|
|
|
|
git config --get-all remote.someremote.pushurl >actual &&
|
|
|
|
echo "YYY" >>actual &&
|
|
|
|
git config --get-all remote.someremote.url >>actual &&
|
|
|
|
cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'remote set-url --push --delete bar' '
|
|
|
|
git remote set-url --push --delete someremote bar &&
|
|
|
|
echo foo >expect &&
|
|
|
|
echo "YYY" >>expect &&
|
|
|
|
echo baz >>expect &&
|
|
|
|
git config --get-all remote.someremote.pushurl >actual &&
|
|
|
|
echo "YYY" >>actual &&
|
|
|
|
git config --get-all remote.someremote.url >>actual &&
|
|
|
|
cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'remote set-url --push --delete foo' '
|
|
|
|
git remote set-url --push --delete someremote foo &&
|
|
|
|
echo "YYY" >expect &&
|
|
|
|
echo baz >>expect &&
|
|
|
|
test_must_fail git config --get-all remote.someremote.pushurl >actual &&
|
|
|
|
echo "YYY" >>actual &&
|
|
|
|
git config --get-all remote.someremote.url >>actual &&
|
|
|
|
cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'remote set-url --add bbb' '
|
|
|
|
git remote set-url --add someremote bbb &&
|
|
|
|
echo "YYY" >expect &&
|
|
|
|
echo baz >>expect &&
|
|
|
|
echo bbb >>expect &&
|
|
|
|
test_must_fail git config --get-all remote.someremote.pushurl >actual &&
|
|
|
|
echo "YYY" >>actual &&
|
|
|
|
git config --get-all remote.someremote.url >>actual &&
|
|
|
|
cmp expect actual
|
|
|
|
'
|
|
|
|
|
2015-09-16 01:53:47 +00:00
|
|
|
test_expect_success 'get-url on multi fetch remote' '
|
|
|
|
echo baz | get_url_test someremote &&
|
|
|
|
get_url_test --all someremote <<-\EOF
|
|
|
|
baz
|
|
|
|
bbb
|
|
|
|
EOF
|
|
|
|
'
|
|
|
|
|
2010-01-18 17:18:02 +00:00
|
|
|
test_expect_success 'remote set-url --delete .*' '
|
2010-03-20 00:10:20 +00:00
|
|
|
test_must_fail git remote set-url --delete someremote .\* &&
|
2010-01-18 17:18:02 +00:00
|
|
|
echo "YYY" >expect &&
|
|
|
|
echo baz >>expect &&
|
|
|
|
echo bbb >>expect &&
|
|
|
|
test_must_fail git config --get-all remote.someremote.pushurl >actual &&
|
|
|
|
echo "YYY" >>actual &&
|
|
|
|
git config --get-all remote.someremote.url >>actual &&
|
|
|
|
cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'remote set-url --delete bbb' '
|
|
|
|
git remote set-url --delete someremote bbb &&
|
|
|
|
echo "YYY" >expect &&
|
|
|
|
echo baz >>expect &&
|
|
|
|
test_must_fail git config --get-all remote.someremote.pushurl >actual &&
|
|
|
|
echo "YYY" >>actual &&
|
|
|
|
git config --get-all remote.someremote.url >>actual &&
|
|
|
|
cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'remote set-url --delete baz' '
|
|
|
|
test_must_fail git remote set-url --delete someremote baz &&
|
|
|
|
echo "YYY" >expect &&
|
|
|
|
echo baz >>expect &&
|
|
|
|
test_must_fail git config --get-all remote.someremote.pushurl >actual &&
|
|
|
|
echo "YYY" >>actual &&
|
|
|
|
git config --get-all remote.someremote.url >>actual &&
|
|
|
|
cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'remote set-url --add ccc' '
|
|
|
|
git remote set-url --add someremote ccc &&
|
|
|
|
echo "YYY" >expect &&
|
|
|
|
echo baz >>expect &&
|
|
|
|
echo ccc >>expect &&
|
|
|
|
test_must_fail git config --get-all remote.someremote.pushurl >actual &&
|
|
|
|
echo "YYY" >>actual &&
|
|
|
|
git config --get-all remote.someremote.url >>actual &&
|
|
|
|
cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'remote set-url --delete baz' '
|
|
|
|
git remote set-url --delete someremote baz &&
|
|
|
|
echo "YYY" >expect &&
|
|
|
|
echo ccc >>expect &&
|
|
|
|
test_must_fail git config --get-all remote.someremote.pushurl >actual &&
|
|
|
|
echo "YYY" >>actual &&
|
|
|
|
git config --get-all remote.someremote.url >>actual &&
|
|
|
|
cmp expect actual
|
|
|
|
'
|
|
|
|
|
2013-04-24 13:54:35 +00:00
|
|
|
test_expect_success 'extra args: setup' '
|
|
|
|
# add a dummy origin so that this does not trigger failure
|
|
|
|
git remote add origin .
|
|
|
|
'
|
|
|
|
|
|
|
|
test_extra_arg () {
|
2013-04-24 13:54:37 +00:00
|
|
|
test_expect_success "extra args: $*" "
|
2013-04-24 13:54:35 +00:00
|
|
|
test_must_fail git remote $* bogus_extra_arg 2>actual &&
|
2016-06-17 20:21:07 +00:00
|
|
|
test_i18ngrep '^usage:' actual
|
2013-04-24 13:54:35 +00:00
|
|
|
"
|
|
|
|
}
|
|
|
|
|
2013-04-24 13:54:36 +00:00
|
|
|
test_extra_arg add nick url
|
2013-04-24 13:54:35 +00:00
|
|
|
test_extra_arg rename origin newname
|
|
|
|
test_extra_arg remove origin
|
2020-12-17 01:07:05 +00:00
|
|
|
test_extra_arg set-head origin main
|
2013-04-24 13:54:35 +00:00
|
|
|
# set-branches takes any number of args
|
2015-09-16 01:53:47 +00:00
|
|
|
test_extra_arg get-url origin newurl
|
2013-04-24 13:54:35 +00:00
|
|
|
test_extra_arg set-url origin newurl oldurl
|
2013-04-24 13:54:37 +00:00
|
|
|
# show takes any number of args
|
|
|
|
# prune takes any number of args
|
2013-04-24 13:54:35 +00:00
|
|
|
# update takes any number of args
|
|
|
|
|
2014-12-23 13:25:09 +00:00
|
|
|
test_expect_success 'add remote matching the "insteadOf" URL' '
|
|
|
|
git config url.xyz@example.com.insteadOf backup &&
|
|
|
|
git remote add backup xyz@example.com
|
|
|
|
'
|
|
|
|
|
push: add an advice on unqualified <dst> push
Add an advice to the recently improved error message added in
f8aae12034 ("push: allow unqualified dest refspecs to DWIM",
2008-04-23).
Now with advice.pushUnqualifiedRefName=true (on by default) we show a
hint about how to proceed:
$ ./git-push avar v2.19.0^{commit}:newbranch -n
error: The destination you provided is not a full refname (i.e.,
starting with "refs/"). We tried to guess what you meant by:
- Looking for a ref that matches 'newbranch' on the remote side.
- Checking if the <src> being pushed ('v2.19.0^{commit}')
is a ref in "refs/{heads,tags}/". If so we add a corresponding
refs/{heads,tags}/ prefix on the remote side.
Neither worked, so we gave up. You must fully qualify the ref.
hint: The <src> part of the refspec is a commit object.
hint: Did you mean to create a new branch by pushing to
hint: 'v2.19.0^{commit}:refs/heads/newbranch'?
error: failed to push some refs to 'git@github.com:avar/git.git'
When trying to push a tag, tree or a blob we suggest that perhaps the
user meant to push them to refs/tags/ instead.
The if/else duplication for all of OBJ_{COMMIT,TAG,TREE,BLOB} is
unfortunate, but is required to correctly mark the messages for
translation. See the discussion in
<87r2gxebsi.fsf@evledraar.gmail.com> about that.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-13 19:52:43 +00:00
|
|
|
test_expect_success 'unqualified <dst> refspec DWIM and advice' '
|
|
|
|
test_when_finished "(cd test && git tag -d some-tag)" &&
|
|
|
|
(
|
|
|
|
cd test &&
|
2020-12-17 01:07:05 +00:00
|
|
|
git tag -a -m "Some tag" some-tag main &&
|
push: add an advice on unqualified <dst> push
Add an advice to the recently improved error message added in
f8aae12034 ("push: allow unqualified dest refspecs to DWIM",
2008-04-23).
Now with advice.pushUnqualifiedRefName=true (on by default) we show a
hint about how to proceed:
$ ./git-push avar v2.19.0^{commit}:newbranch -n
error: The destination you provided is not a full refname (i.e.,
starting with "refs/"). We tried to guess what you meant by:
- Looking for a ref that matches 'newbranch' on the remote side.
- Checking if the <src> being pushed ('v2.19.0^{commit}')
is a ref in "refs/{heads,tags}/". If so we add a corresponding
refs/{heads,tags}/ prefix on the remote side.
Neither worked, so we gave up. You must fully qualify the ref.
hint: The <src> part of the refspec is a commit object.
hint: Did you mean to create a new branch by pushing to
hint: 'v2.19.0^{commit}:refs/heads/newbranch'?
error: failed to push some refs to 'git@github.com:avar/git.git'
When trying to push a tag, tree or a blob we suggest that perhaps the
user meant to push them to refs/tags/ instead.
The if/else duplication for all of OBJ_{COMMIT,TAG,TREE,BLOB} is
unfortunate, but is required to correctly mark the messages for
translation. See the discussion in
<87r2gxebsi.fsf@evledraar.gmail.com> about that.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-13 19:52:43 +00:00
|
|
|
for type in commit tag tree blob
|
|
|
|
do
|
|
|
|
if test "$type" = "blob"
|
|
|
|
then
|
|
|
|
oid=$(git rev-parse some-tag:file)
|
|
|
|
else
|
|
|
|
oid=$(git rev-parse some-tag^{$type})
|
|
|
|
fi &&
|
|
|
|
test_must_fail git push origin $oid:dst 2>err &&
|
|
|
|
test_i18ngrep "error: The destination you" err &&
|
|
|
|
test_i18ngrep "hint: Did you mean" err &&
|
|
|
|
test_must_fail git -c advice.pushUnqualifiedRefName=false \
|
|
|
|
push origin $oid:dst 2>err &&
|
|
|
|
test_i18ngrep "error: The destination you" err &&
|
|
|
|
test_i18ngrep ! "hint: Did you mean" err ||
|
2021-12-09 05:11:10 +00:00
|
|
|
exit 1
|
|
|
|
done
|
push: add an advice on unqualified <dst> push
Add an advice to the recently improved error message added in
f8aae12034 ("push: allow unqualified dest refspecs to DWIM",
2008-04-23).
Now with advice.pushUnqualifiedRefName=true (on by default) we show a
hint about how to proceed:
$ ./git-push avar v2.19.0^{commit}:newbranch -n
error: The destination you provided is not a full refname (i.e.,
starting with "refs/"). We tried to guess what you meant by:
- Looking for a ref that matches 'newbranch' on the remote side.
- Checking if the <src> being pushed ('v2.19.0^{commit}')
is a ref in "refs/{heads,tags}/". If so we add a corresponding
refs/{heads,tags}/ prefix on the remote side.
Neither worked, so we gave up. You must fully qualify the ref.
hint: The <src> part of the refspec is a commit object.
hint: Did you mean to create a new branch by pushing to
hint: 'v2.19.0^{commit}:refs/heads/newbranch'?
error: failed to push some refs to 'git@github.com:avar/git.git'
When trying to push a tag, tree or a blob we suggest that perhaps the
user meant to push them to refs/tags/ instead.
The if/else duplication for all of OBJ_{COMMIT,TAG,TREE,BLOB} is
unfortunate, but is required to correctly mark the messages for
translation. See the discussion in
<87r2gxebsi.fsf@evledraar.gmail.com> about that.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-13 19:52:43 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2020-12-17 01:07:05 +00:00
|
|
|
test_expect_success 'refs/remotes/* <src> refspec and unqualified <dst> DWIM and advice' '
|
2018-11-13 19:52:44 +00:00
|
|
|
(
|
|
|
|
cd two &&
|
2020-12-17 01:07:05 +00:00
|
|
|
git tag -a -m "Some tag" my-tag main &&
|
2018-11-13 19:52:44 +00:00
|
|
|
git update-ref refs/trees/my-head-tree HEAD^{tree} &&
|
|
|
|
git update-ref refs/blobs/my-file-blob HEAD:file
|
|
|
|
) &&
|
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
git config --add remote.two.fetch "+refs/tags/*:refs/remotes/tags-from-two/*" &&
|
|
|
|
git config --add remote.two.fetch "+refs/trees/*:refs/remotes/trees-from-two/*" &&
|
|
|
|
git config --add remote.two.fetch "+refs/blobs/*:refs/remotes/blobs-from-two/*" &&
|
|
|
|
git fetch --no-tags two &&
|
|
|
|
|
|
|
|
test_must_fail git push origin refs/remotes/two/another:dst 2>err &&
|
|
|
|
test_i18ngrep "error: The destination you" err &&
|
|
|
|
|
|
|
|
test_must_fail git push origin refs/remotes/tags-from-two/my-tag:dst-tag 2>err &&
|
|
|
|
test_i18ngrep "error: The destination you" err &&
|
|
|
|
|
|
|
|
test_must_fail git push origin refs/remotes/trees-from-two/my-head-tree:dst-tree 2>err &&
|
|
|
|
test_i18ngrep "error: The destination you" err &&
|
|
|
|
|
|
|
|
test_must_fail git push origin refs/remotes/blobs-from-two/my-file-blob:dst-blob 2>err &&
|
|
|
|
test_i18ngrep "error: The destination you" err
|
|
|
|
)
|
|
|
|
'
|
push: add an advice on unqualified <dst> push
Add an advice to the recently improved error message added in
f8aae12034 ("push: allow unqualified dest refspecs to DWIM",
2008-04-23).
Now with advice.pushUnqualifiedRefName=true (on by default) we show a
hint about how to proceed:
$ ./git-push avar v2.19.0^{commit}:newbranch -n
error: The destination you provided is not a full refname (i.e.,
starting with "refs/"). We tried to guess what you meant by:
- Looking for a ref that matches 'newbranch' on the remote side.
- Checking if the <src> being pushed ('v2.19.0^{commit}')
is a ref in "refs/{heads,tags}/". If so we add a corresponding
refs/{heads,tags}/ prefix on the remote side.
Neither worked, so we gave up. You must fully qualify the ref.
hint: The <src> part of the refspec is a commit object.
hint: Did you mean to create a new branch by pushing to
hint: 'v2.19.0^{commit}:refs/heads/newbranch'?
error: failed to push some refs to 'git@github.com:avar/git.git'
When trying to push a tag, tree or a blob we suggest that perhaps the
user meant to push them to refs/tags/ instead.
The if/else duplication for all of OBJ_{COMMIT,TAG,TREE,BLOB} is
unfortunate, but is required to correctly mark the messages for
translation. See the discussion in
<87r2gxebsi.fsf@evledraar.gmail.com> about that.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-13 19:52:43 +00:00
|
|
|
|
2010-01-18 17:18:02 +00:00
|
|
|
test_done
|